Spaces:
Sleeping
Sleeping
| /** API-Client zum Engines-Dienst. Immer relative `/api/*`-Pfade: lokal leitet | |
| * der Vite-Proxy an FastAPI :8000 weiter, im HF-Space mountet `space.py` die | |
| * API unter /api, auf Vercel leitet ein Rewrite an den Space weiter. */ | |
| import type { CatalogItemInput, RoomInput } from "@fp/shared/rules"; | |
| import { istBackendAntwort, istJsonAntwort, warteAufBackend, type BackendStatus } from "./backend"; | |
| import type { FarbSlug } from "./farben"; | |
| import type { FlaechenKonzept } from "./oberflaechen"; | |
| export interface Placement { | |
| id: string; | |
| catalogItemId: string; | |
| pose: { pos: [number, number]; yawDeg: number }; | |
| gewerk: string; | |
| locked: boolean; | |
| source: string; | |
| mountHeight?: number; | |
| /** Gewählte Farbvariante (KI oder Nutzer), Welle 3. Fehlt = Default-Optik. */ | |
| farbe?: FarbSlug; | |
| } | |
| export interface Plan { | |
| id: string; | |
| roomRef: string; | |
| version: number; | |
| status: string; | |
| placements: Placement[]; | |
| constraintReport: unknown; | |
| meta: { seed: number; normProfile: string; solverVersion: string }; | |
| } | |
| export interface KatalogItem extends CatalogItemInput { | |
| name: string; | |
| priorityClass: "P1" | "P2" | "P3"; | |
| /** Optionale 3D-Bausatz-Variante für den Viewer (Katalog-Feld modell3d). */ | |
| modell3d?: string; | |
| /** Wählbare Farbvarianten (Welle 2); erste = Default-Optik. Grundlage für den | |
| * UI-Farbpicker und die KI-Farbwahl. */ | |
| farbVarianten?: FarbSlug[]; | |
| /** Stil-Achsen-Ausprägungen des Items (für Stil-Match/Kurator). */ | |
| achsenTags?: Record<string, number>; | |
| /** Preis-Stammdaten (für Kostenanzeige & LV). Provenance liegt im Schema. */ | |
| preis?: { | |
| value: number; | |
| currency: "CHF"; | |
| stand?: string; | |
| quelle?: string; | |
| bandbreitePct?: number; | |
| }; | |
| } | |
| export interface Room extends RoomInput { | |
| id: string; | |
| name: string; | |
| } | |
| /** Scene-Dressing-Objekt (rein visuelle Deko-Ebene, getrennt vom Plan). | |
| * Vertrag: packages/shared/schemas/dressing-item.schema.json. NICHT solver-/ | |
| * normrelevant – erscheint nie in placements/constraintReport/LV. */ | |
| export interface DressingItem { | |
| id: string; | |
| schemaVersion: string; | |
| name: string; | |
| roomTypes: string[]; | |
| /** B leicht kollisionsrelevant · C an Wand/Möbel · D Mikro-Deko auf Oberfläche. */ | |
| klasse: "B" | "C" | "D"; | |
| funktionsTyp: string; | |
| /** funktionsTypen aus dem Plan ODER die Schlüsselworte "wand"/"ecke". */ | |
| anchorTypes: string[]; | |
| platzierung: "auf_oberflaeche" | "an_wand" | "freie_ecke" | "an_moebel" | "an_decke"; | |
| masse: { w: number; d: number; h: number }; | |
| achsenTags: Record<string, number>; | |
| attributTags: string[]; | |
| assetStatus: "placeholder" | "modeled"; | |
| /** Dateiname (ohne Endung) unter public/assets/dressing/<gltfRef>.glb. */ | |
| gltfRef?: string; | |
| modell3d?: string; | |
| } | |
| export interface KV { | |
| raumName: string; | |
| mengen: { bodenflaeche_m2: number; wandflaeche_m2: number; objekte: number }; | |
| positionen: { | |
| bezeichnung: string; | |
| gewerk: string; | |
| menge: number; | |
| einheit: string; | |
| einzelpreis_chf: number; | |
| total_chf: number; | |
| }[]; | |
| summe_chf: number; | |
| bandbreitePct: number; | |
| von_chf: number; | |
| bis_chf: number; | |
| nextSteps: string[]; | |
| hinweis: string; | |
| } | |
| /** Optionen für /solve – Küche braucht normProfile/form/zoneId, sonst Kurator. */ | |
| export interface SolveOpts { | |
| kurator?: KuratorAntwort; | |
| stilprofilRef?: string; | |
| stilprofil?: unknown | null; | |
| normProfile?: string; | |
| form?: string; | |
| zoneId?: string; | |
| /** Flächen-Wünsche des Kurators (Call C); der Server reicht sie unverändert | |
| * in der Antwort zurück (der Client rendert daraus die Optik). */ | |
| flaechen?: FlaechenKonzept | null; | |
| /** Farbwahl je Item (Welle 3): itemId→Slug → placement.farbe im Plan. */ | |
| farben?: Record<string, FarbSlug> | null; | |
| /** K-Varianten (Welle 5): true → Server erzeugt K=3 Varianten und liefert die | |
| * beste (+ varianteInfo). Nur Nicht-Küche. Default false. */ | |
| varianten?: boolean; | |
| /** «3 Vorschläge» (Welle C): true → Response zusätzlich `variantenPlaene` | |
| * (ALLE K Pläne best-first). Nur zusammen mit `varianten` wirksam. */ | |
| variantenDetails?: boolean; | |
| } | |
| /** Auswahl-Spur der K-Varianten (Welle 5), additiv in der /solve-Response-Hülle. | |
| * Rein informativ – der `plan` ist bereits die gewählte beste Variante. */ | |
| export interface VarianteInfo { | |
| /** Index der gewählten Variante in `varianten`. */ | |
| gewaehlt: number; | |
| anzahl: number; | |
| varianten: { | |
| index: number; | |
| seed: number; | |
| /** Anzahl platzierter Items (Überlebensrate). */ | |
| platziert: number; | |
| /** Anzahl «knappe» harte Regeln (weniger = mehr Norm-Luft). */ | |
| knapp: number; | |
| /** Weiche Relations-/Stil-Zufriedenheit (höher = besser). */ | |
| relationScore: number; | |
| }[]; | |
| } | |
| /** Ein Vorschlag der «3 Vorschläge»-Ansicht (Welle C): kompletter Plan + die | |
| * zugehörige Score-Zeile aus varianteInfo. Liste kommt best-first vom Server. */ | |
| export interface VariantenPlan { | |
| plan: Plan; | |
| info: VarianteInfo["varianten"][number]; | |
| } | |
| export class ApiFehler extends Error { | |
| constructor( | |
| public code: string, | |
| message: string, | |
| ) { | |
| super(message); | |
| } | |
| } | |
| /** Fehlercode, wenn das Backend auch nach dem Wecken nicht antwortet. */ | |
| export const NICHT_ERREICHBAR = "BACKEND_NICHT_ERREICHBAR"; | |
| const TEXT_NICHT_ERREICHBAR = | |
| "Der Server ist gerade nicht erreichbar. Bitte in einigen Minuten erneut versuchen."; | |
| let statusHoerer: ((s: BackendStatus) => void) | null = null; | |
| /** App-weiter Beobachter des Backend-Zustands (für den «wird geweckt»-Hinweis). */ | |
| export function beobachteBackend(hoerer: ((s: BackendStatus) => void) | null): void { | |
| statusHoerer = hoerer; | |
| } | |
| async function pingHealth(): Promise<boolean> { | |
| try { | |
| const res = await fetch("/api/health", { | |
| cache: "no-store", | |
| signal: AbortSignal.timeout(20_000), | |
| }); | |
| if (!res.ok || !istJsonAntwort(res)) return false; | |
| return ((await res.json()) as { status?: string }).status === "ok"; | |
| } catch { | |
| return false; | |
| } | |
| } | |
| let laufendesWecken: Promise<boolean> | null = null; | |
| /** Genau EIN Weckvorgang, auch wenn mehrere Aufrufe gleichzeitig warten | |
| * (z.B. die fünf Stammdaten-Abrufe nach der Raumwahl). */ | |
| function weckeBackend(): Promise<boolean> { | |
| if (laufendesWecken === null) { | |
| statusHoerer?.("wacht"); | |
| laufendesWecken = warteAufBackend({ | |
| ping: pingHealth, | |
| schlafe: (ms) => new Promise((ok) => setTimeout(ok, ms)), | |
| jetzt: () => Date.now(), | |
| }) | |
| .then((bereit) => { | |
| statusHoerer?.(bereit ? "bereit" : "nicht-erreichbar"); | |
| return bereit; | |
| }) | |
| .finally(() => { | |
| laufendesWecken = null; | |
| }); | |
| } | |
| return laufendesWecken; | |
| } | |
| async function versuche(pfad: string, init?: RequestInit): Promise<Response | null> { | |
| try { | |
| return await fetch(pfad, init); | |
| } catch { | |
| return null; // Netzfehler: wie «Backend nicht bereit» behandeln | |
| } | |
| } | |
| /** fetch, der «Backend schläft/startet» erkennt (HTML-Ladeseite, Proxy- | |
| * Fehlerseite, Netzfehler), das Backend weckt und die Anfrage EINMAL | |
| * wiederholt. Wiederholen ist unbedenklich: alle Endpunkte sind reine | |
| * Berechnungen ohne Server-Zustand. */ | |
| async function holeAntwort( | |
| pfad: string, | |
| init: RequestInit | undefined, | |
| binaer: boolean, | |
| ): Promise<Response> { | |
| const erste = await versuche(pfad, init); | |
| if (erste !== null && istBackendAntwort(erste, binaer)) return erste; | |
| if (!(await weckeBackend())) throw new ApiFehler(NICHT_ERREICHBAR, TEXT_NICHT_ERREICHBAR); | |
| const zweite = await versuche(pfad, init); | |
| if (zweite === null) throw new ApiFehler(NICHT_ERREICHBAR, TEXT_NICHT_ERREICHBAR); | |
| if (istBackendAntwort(zweite, binaer)) return zweite; | |
| throw new ApiFehler( | |
| "UNERWARTETE_ANTWORT", | |
| `Der Server hat unerwartet geantwortet (HTTP ${zweite.status}). Bitte erneut versuchen.`, | |
| ); | |
| } | |
| /** Fehler-Envelope der API ({code, message}) in einen ApiFehler übersetzen. */ | |
| async function envelopeFehler(res: Response, codeFallback: string): Promise<ApiFehler> { | |
| const body = istJsonAntwort(res) | |
| ? ((await res.json().catch(() => ({}))) as { code?: string; message?: string }) | |
| : {}; | |
| return new ApiFehler(body.code ?? codeFallback, body.message ?? res.statusText); | |
| } | |
| async function call<T>(pfad: string, init?: RequestInit): Promise<T> { | |
| const res = await holeAntwort( | |
| `/api${pfad}`, | |
| { headers: { "Content-Type": "application/json" }, ...init }, | |
| false, | |
| ); | |
| if (!res.ok) throw await envelopeFehler(res, "UNBEKANNT"); | |
| return (await res.json()) as T; | |
| } | |
| export interface KuratorAntwort { | |
| auswahl: string[]; | |
| relationaleAbsichten: { itemId: string; relation: string }[]; | |
| /** Raumprägende Haupt-Objekte (Objekt-Ebenen-Modell, ADR-0014), zuerst gewählt. */ | |
| hauptObjekte?: string[]; | |
| /** Ergänzungen mit Anzahl (Stühle zum Esstisch …). Grundlage für `mengen`. */ | |
| ergaenzungen?: { itemId: string; anzahl: number }[]; | |
| /** Flächen-Konzept (Boden-/Wand-Material je Wand). Fehlt bei Teil-Fallback. */ | |
| flaechen?: FlaechenKonzept | null; | |
| /** Design-Leitidee aus Call A (roter Faden), optional. */ | |
| konzept?: string | null; | |
| /** KI-Farbwahl je Item (itemId→Slug), Welle 3. Fehlt/leer = Default-Optik. */ | |
| farben?: Record<string, FarbSlug> | null; | |
| begruendung?: string; | |
| } | |
| /** Instanz-Mengen (itemId→anzahl) aus den Kurator-Ergänzungen für /solve. | |
| * Nur Einträge mit anzahl > 1 (Default 1 bleibt implizit) – ADR-0014. */ | |
| export function mengenAusKurator(kurator?: KuratorAntwort): Record<string, number> | undefined { | |
| const erg = kurator?.ergaenzungen?.filter((e) => e.anzahl > 1) ?? []; | |
| return erg.length ? Object.fromEntries(erg.map((e) => [e.itemId, e.anzahl])) : undefined; | |
| } | |
| /** Gemessenes AMK-Arbeitsdreieck eines Küchenplans (server-berechnet, M6-Politur). */ | |
| export interface Arbeitsdreieck { | |
| /** Die drei Seitenlängen Spüle–Kochfeld–Kühlschrank (m). */ | |
| seiten_m: number[]; | |
| /** Summe der drei Seiten (m); AMK-effizient bei ~4–8 m. */ | |
| summe_m: number; | |
| /** Ergonomie-Score in [0,1] (= constraintReport.softScore.ergonomie). */ | |
| score: number; | |
| bewertung: "effizient" | "akzeptabel" | "beengt" | "weitläufig"; | |
| } | |
| /** Eine Küchenform-Empfehlung (Formwahl, M6). */ | |
| export interface KuechenForm { | |
| form: "i" | "l" | "u" | "galley" | "insel"; | |
| score: number; | |
| begruendung: string; | |
| anchorWallIds: string[]; | |
| nutzlaenge_m: number; | |
| } | |
| export const api = { | |
| rooms: () => call<Room[]>("/samples/rooms"), | |
| /** Scan-Bundle (vorberechnetes layout.txt, optional .zip mit poses.json) → Raummodell. | |
| * FormData statt JSON – daher eigener fetch (nicht der json-`call`-Helfer). */ | |
| async scan( | |
| bundle: File, | |
| roomType: string, | |
| name: string, | |
| ): Promise<{ room: Room; warnungen: string[] }> { | |
| const fd = new FormData(); | |
| fd.append("bundle", bundle); | |
| fd.append("roomType", roomType); | |
| fd.append("name", name); | |
| const res = await holeAntwort("/api/scan", { method: "POST", body: fd }, false); | |
| if (!res.ok) throw await envelopeFehler(res, "SCAN"); | |
| return (await res.json()) as { room: Room; warnungen: string[] }; | |
| }, | |
| images: (roomType: string) => call<import("./Stil").BildItem[]>(`/images/${roomType}`), | |
| taxonomy: () => call<{ achsen: import("./Stil").Achse[] }>("/taxonomy"), | |
| styleProfile: (roomType: string, likes: string[], dislikes: string[], presetId: string | null) => | |
| call<import("./Stil").Stilprofil>("/style/profile", { | |
| method: "POST", | |
| body: JSON.stringify({ roomType, likes, dislikes, presetId }), | |
| }), | |
| curate: (room: Room, stilprofil: unknown, seed: number) => | |
| call<{ kurator: KuratorAntwort; port: string }>("/curate", { | |
| method: "POST", | |
| body: JSON.stringify({ room, stilprofil, seed }), | |
| }), | |
| catalog: (roomType: string) => call<KatalogItem[]>(`/catalog/${roomType}`), | |
| /** Scene-Dressing-Stammdaten je Raumtyp (rein visuelle Deko-Ebene, read-only). */ | |
| dressing: (roomType: string) => call<DressingItem[]>(`/dressing/${roomType}`), | |
| rules: (roomType: string) => call<unknown[]>(`/rules/${roomType}`), | |
| /** Top-3 Küchenformen (Formwahl) für einen Küchen- oder Grossraum. */ | |
| kuecheFormen: (room: Room, stilprofil: unknown | null, normProfile: string, zoneId?: string) => | |
| call<{ formen: KuechenForm[] }>("/kueche/formen", { | |
| method: "POST", | |
| body: JSON.stringify({ room, styleProfile: stilprofil ?? undefined, normProfile, zoneId }), | |
| }), | |
| solve: (room: Room, seed: number, opts: SolveOpts = {}) => | |
| call<{ | |
| plan: Plan; | |
| room: Room; | |
| hinweis?: string; | |
| arbeitsdreieck?: Arbeitsdreieck; | |
| flaechen?: FlaechenKonzept | null; | |
| varianteInfo?: VarianteInfo; | |
| variantenPlaene?: VariantenPlan[]; | |
| }>("/solve", { | |
| method: "POST", | |
| body: JSON.stringify({ | |
| room, | |
| seed, | |
| auswahl: opts.kurator?.auswahl, | |
| relationaleAbsichten: opts.kurator?.relationaleAbsichten ?? [], | |
| // Mehrfach-Instanzen (ADR-0014): itemId→anzahl aus den Kurator-Ergänzungen. | |
| mengen: mengenAusKurator(opts.kurator), | |
| stilprofilRef: opts.stilprofilRef, | |
| stilprofil: opts.stilprofil ?? undefined, | |
| normProfile: opts.normProfile, | |
| form: opts.form, | |
| zoneId: opts.zoneId, | |
| flaechen: opts.flaechen ?? undefined, | |
| farben: opts.farben ?? undefined, | |
| varianten: opts.varianten ?? undefined, | |
| variantenDetails: opts.variantenDetails ?? undefined, | |
| }), | |
| }), | |
| /** Manuelle Flächen-Wahl (Welle 3) gegen die Norm prüfen + korrigieren lassen. | |
| * Quelle bleibt Python (kein TS-Nachbau der Regeln → kein Drift). */ | |
| pruefeFlaechen: (room: Room, flaechen: FlaechenKonzept) => | |
| call<{ verstoesse: string[]; korrigiert: FlaechenKonzept }>("/flaechen/pruefen", { | |
| method: "POST", | |
| body: JSON.stringify({ room, flaechen }), | |
| }), | |
| evaluate: (room: Room, plan: Plan) => | |
| call<KV>("/evaluate", { method: "POST", body: JSON.stringify({ room, plan }) }), | |
| /** Dokument vom Export-Endpunkt herunterladen (Blob → Browser-Download). */ | |
| async dokument(pfad: string, dateiname: string, room: Room, plan: Plan): Promise<void> { | |
| const res = await holeAntwort( | |
| `/api/export/${pfad}`, | |
| { | |
| method: "POST", | |
| headers: { "Content-Type": "application/json" }, | |
| body: JSON.stringify({ room, plan }), | |
| }, | |
| true, | |
| ); | |
| if (!res.ok) throw await envelopeFehler(res, "EXPORT"); | |
| const url = URL.createObjectURL(await res.blob()); | |
| const a = document.createElement("a"); | |
| a.href = url; | |
| a.download = dateiname; | |
| a.click(); | |
| URL.revokeObjectURL(url); | |
| }, | |
| }; | |