@osamash/floor-planner 1.2.3 → 1.2.5

package/dist/types/index.d.ts

@@ -2,5 +2,7 @@ import ReactPlanner from "./react-planner/ReactPlanner";
 import ReactPlannerLoader from "./react-planner/ReactPlannerLoader";
 import convertUnits, { type Unit } from "./react-planner/utils/convert-units";
 import Catalog, { AreaFactory, ItemFactory, WallFactory, SurfaceFactory } from "./react-planner/catalog";
-export { Catalog, AreaFactory, ItemFactory, WallFactory, SurfaceFactory, convertUnits, type Unit, ReactPlannerLoader, };
+import type { AIRequestHandler, AIResponse, AIStreamContext, ChatMessage, PlanSummary, PlannerAction } from "./react-planner/ai-chat/aiService";
+import { createStreamingAIHandler, type StreamingAIHandlerOptions } from "./react-planner/ai-chat/streamingClient";
+export { Catalog, AreaFactory, ItemFactory, WallFactory, SurfaceFactory, convertUnits, type Unit, ReactPlannerLoader, createStreamingAIHandler, type StreamingAIHandlerOptions, type AIRequestHandler, type AIResponse, type AIStreamContext, type ChatMessage, type PlanSummary, type PlannerAction, };
 export default ReactPlanner;

package/dist/types/react-planner/ReactPlanner.d.ts

@@ -1,11 +1,13 @@
 import { type Plan as PlanType } from "../store/ReactPlannerStore";
 import "./react-planner.css";
+import type { AIRequestHandler } from "./ai-chat/aiService";
 interface ReactPlannerProps {
     catalog: any;
     plan: PlanType;
     has3dView?: boolean;
     onBack?: () => void;
     onSave?: (data: any) => void;
+    onAIMessage?: AIRequestHandler;
 }
-declare const ReactPlanner: ({ plan, catalog, onSave, onBack, has3dView, }: ReactPlannerProps) => import("react/jsx-runtime").JSX.Element;
+declare const ReactPlanner: ({ plan, catalog, onSave, onBack, has3dView, onAIMessage, }: ReactPlannerProps) => import("react/jsx-runtime").JSX.Element;
 export default ReactPlanner;

package/dist/types/react-planner/ReactPlannerLoader.d.ts

@@ -1,2 +1,21 @@
-declare const ReactPlannerLoader: () => import("react/jsx-runtime").JSX.Element;
+import "./react-planner.css";
+interface ReactPlannerLoaderProps {
+    /** Defaults to the theme the planner itself is about to open in, so the
+     *  hand-off from skeleton to real UI doesn't flash. */
+    theme?: "light" | "dark";
+}
+/** Skeleton of the planner's chrome, shown while the plan and catalog load.
+ *
+ *  It reuses the real layout classes — `.floor_planner-headerbar`,
+ *  `.fp-toolbar-rail`, `.fp-toolbar-subpanel`, `.fp-toolbar-utility`,
+ *  `.fp-zoom-controls` — instead of restating their geometry, so the
+ *  placeholder keeps lining up with the real UI when that chrome moves. Only
+ *  the grey blocks and the few `.fp-loader__*` rules are its own.
+ *
+ *  What it mirrors is the planner's *opening* state: header, the three-item
+ *  tool rail, the Build sub-panel the toolbar starts on, zoom controls
+ *  shifted clear of that panel, the utility bar and the AI bubble. No
+ *  properties sidebar — that only appears once something is selected — and no
+ *  footer, which renders nothing today. */
+declare const ReactPlannerLoader: ({ theme }: ReactPlannerLoaderProps) => import("react/jsx-runtime").JSX.Element;
 export default ReactPlannerLoader;

package/dist/types/react-planner/ai-chat/AIChatBubble.d.ts

@@ -0,0 +1,6 @@
+import type { AIRequestHandler } from "./aiService";
+interface AIChatBubbleProps {
+    onAIMessage?: AIRequestHandler;
+}
+declare const AIChatBubble: ({ onAIMessage }: AIChatBubbleProps) => import("react/jsx-runtime").JSX.Element;
+export default AIChatBubble;

package/dist/types/react-planner/ai-chat/AIChatPanel.d.ts

@@ -0,0 +1,8 @@
+import { type AIRequestHandler } from "./aiService";
+interface AIChatPanelProps {
+    open: boolean;
+    onClose: () => void;
+    onAIMessage?: AIRequestHandler;
+}
+declare const AIChatPanel: ({ open, onClose, onAIMessage }: AIChatPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default AIChatPanel;

package/dist/types/react-planner/ai-chat/SelectionChips.d.ts

@@ -0,0 +1,2 @@
+declare const SelectionChips: () => import("react/jsx-runtime").JSX.Element | null;
+export default SelectionChips;

package/dist/types/react-planner/ai-chat/ThinkingIndicator.d.ts

@@ -0,0 +1,5 @@
+interface ThinkingIndicatorProps {
+    label?: string;
+}
+declare const ThinkingIndicator: ({ label }: ThinkingIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+export default ThinkingIndicator;

package/dist/types/react-planner/ai-chat/aiService.d.ts

@@ -0,0 +1,340 @@
+export interface ChatMessage {
+    role: "user" | "assistant";
+    content: string;
+    /**
+     * Photos attached to a user message — e.g. a scan/photo of a paper floor
+     * plan the AI should interpret and turn into `add-room`/`add-wall`/etc.
+     * actions. `data` is raw base64 (no `data:...;base64,` prefix). Assistant
+     * messages never carry this.
+     */
+    images?: {
+        mediaType: string;
+        data: string;
+    }[];
+    /**
+     * True for the library's own "keep going" turn inserted between
+     * `done: false` continuation calls — never something the user typed.
+     * Several current models (Sonnet 5 and the whole Opus 4.6+/Fable 5
+     * family) reject a request whose message list ends on an `assistant`
+     * turn ("assistant message prefill" is no longer supported), so a
+     * continuation can't just resend the conversation as-is after appending
+     * the assistant's own reply — it needs a trailing `user` turn too. This
+     * flag exists so the chat UI can skip rendering that turn as if the user
+     * had sent it, while it's still included in what's sent to the backend.
+     */
+    synthetic?: boolean;
+}
+export interface WallInfo {
+    id: string;
+    v0: string;
+    v1: string;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    length: number;
+    orientation: "horizontal" | "vertical" | "diagonal";
+    holeCount: number;
+    /** cm. */
+    thickness: number | null;
+    height: number | null;
+    /** The wall's two faces. Which one looks into a given room is geometric. */
+    textureA: string | null;
+    textureB: string | null;
+}
+export interface HoleInfo {
+    id: string;
+    type: string;
+    lineID: string;
+    offset: number;
+    /** Mirrored ALONG its wall — for a door, which end the hinge is at. */
+    flipAlongWall: boolean;
+    /** Mirrored ACROSS its wall — for a door, which side it opens into. */
+    flipAcrossWall: boolean;
+}
+export interface AreaInfo {
+    id: string;
+    /** "room" = enclosed by walls, "surface" = a free-standing polygon (grass,
+     *  patio, driveway…). A room's corners are shared with the walls around it,
+     *  so the two are not interchangeable targets for anything that reshapes. */
+    kind: "room" | "surface" | "area";
+    vertices: {
+        id: string;
+        x: number;
+        y: number;
+    }[];
+    color: string | null;
+    /** Floor fill/texture. Mutually exclusive; "none" means unset. */
+    pattern: string | null;
+    texture: string | null;
+    customName: string | null;
+    roomCategory: string | null;
+    roomType: string | null;
+    showName: boolean;
+    showSurfaceArea: boolean;
+}
+export interface RoomTypeOption {
+    value: string;
+    label: string;
+    color?: string;
+}
+export interface RoomCategoryOption {
+    value: string;
+    label: string;
+    types: RoomTypeOption[];
+}
+export interface PlanSelection {
+    walls: string[];
+    holes: string[];
+    items: string[];
+    areas: string[];
+    vertices: string[];
+}
+export interface ItemInfo {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+    /** Degrees. Positive reads counter-clockwise in the 2D view. */
+    rotation: number;
+    /** Uniform size multiplier on the catalog element's own dimensions. */
+    scale: number;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+}
+export interface PlanSummary {
+    layerName: string;
+    wallCount: number;
+    itemCount: number;
+    holeCount: number;
+    areaCount: number;
+    walls: WallInfo[];
+    holes: HoleInfo[];
+    areas: AreaInfo[];
+    items: ItemInfo[];
+    mode: string;
+    is3D: boolean;
+    showDimensions: boolean;
+    sceneWidth: number;
+    sceneHeight: number;
+    unit: string;
+    catalogItemTypes: string[];
+    catalogHoleTypes: string[];
+    catalogSurfaceTypes: string[];
+    /** Fill patterns (hatch styles) available for areas — pass in
+     *  `set-area-properties.pattern`. Also "none" is always accepted. */
+    catalogAreaPatterns: string[];
+    /** Textures registered on the current area catalog element — pass in
+     *  `set-area-properties.texture`. Also "none" is always accepted. */
+    catalogAreaTextures: string[];
+    /** Textures registered on the current wall catalog element — pass in
+     *  `set-wall-properties.textureA` / `textureB`. Also "none" is always
+     *  accepted. */
+    catalogWallTextures: string[];
+    roomTypes: RoomCategoryOption[];
+    selection: PlanSelection;
+}
+/**
+ * Which side of an existing room a new one goes on. Screen-relative, matching
+ * how a user says it; note the scene's +y is UP, so "below" is smaller y.
+ */
+export type RoomSide = "left" | "right" | "above" | "below";
+/**
+ * An action the agent may emit for the planner to apply.
+ *
+ * **No action carries coordinates, and none ever should.** The agent says what
+ * to build and which existing room it relates to; every number describing a
+ * POSITION is computed by `applyPlannerActions`. Rooms live at 5-digit scene
+ * coordinates, and a room whose edge is a few centimetres off its neighbour
+ * draws as an unreachable void in 2D and a hole in the floor in 3D — so that
+ * arithmetic belongs where it can be exact.
+ *
+ * The set is being rebuilt one action at a time; the previous 23-variant
+ * union is on the `pre-rewrite-backup` branch. Each new variant needs three
+ * things moving together: this type (what may arrive), the backend's
+ * `ACTION_SPECS` (what the model may say), and a branch in
+ * `applyPlannerActions` (what actually happens).
+ */
+export type PlannerAction = AddRoomAction | SetRoomPropertiesAction | AddHoleAction | AddItemAction | SetWallPropertiesAction | SetItemPropertiesAction | AddSurfaceAction | DeleteAction | SetSurfacePropertiesAction;
+export type AddRoomAction = {
+    type: "add-room";
+    /**
+     * Shown on the plan, and how a later `of` refers to this room — so it has to
+     * be unique within the scene ("Bedroom 1", "Bedroom 2").
+     */
+    name: string;
+    /** cm. Defaults are applied backend-side, so these arrive populated. */
+    width: number;
+    height: number;
+    /**
+     * The NAME of the room this one sits against — either already in the scene
+     * or created earlier in this same batch. Omitted together with `side` for
+     * the first room of a plan, which is centered in the scene instead.
+     */
+    of?: string;
+    side?: RoomSide;
+    /** Catalog room type; also sets the floor color to that type's own color. */
+    roomCategory?: string;
+    roomType?: string;
+    /** Explicit floor color. Wins over the room type's default when both are set. */
+    color?: string;
+};
+export type SetRoomPropertiesAction = {
+    type: "set-room-properties";
+    /** A room name, or the literal "selected" for the room highlighted in the canvas. */
+    room: string;
+    /** Renames the room. */
+    name?: string;
+    roomCategory?: string;
+    roomType?: string;
+    color?: string;
+    pattern?: string;
+    texture?: string;
+};
+export type AddHoleAction = {
+    type: "add-hole";
+    /** Verbatim from PlanSummary.catalogHoleTypes. */
+    holeType: string;
+    /**
+     * The two rooms this opening connects; the shared wall is found here. One
+     * opening has one representation, so it cannot be described from both sides
+     * and land as two doors. Mutually exclusive with room/side.
+     */
+    between?: [string, string];
+    /** A particular wall — the only way to reach an exterior one. */
+    room?: string;
+    side?: RoomSide;
+};
+export type AddItemAction = {
+    type: "add-item";
+    /** Verbatim from PlanSummary.catalogItemTypes. */
+    itemType: string;
+    /** A room name, or "selected". */
+    room: string;
+    /** 1-8. col 1 is the left eighth of the room, row 1 the top. */
+    col: number;
+    row: number;
+    /** 0, 90, 180 or 270. */
+    rotation?: number;
+};
+export type SetWallPropertiesAction = {
+    type: "set-wall-properties";
+    /** A room name, or "selected". All four of its walls unless `side` is given. */
+    room: string;
+    side?: RoomSide;
+    /** Applied to the wall face looking into `room`. */
+    color?: string;
+    texture?: string;
+    /** cm. Whole-wall, so a shared wall changes for both rooms. */
+    thickness?: number;
+    height?: number;
+};
+export type SetItemPropertiesAction = {
+    type: "set-item-properties";
+    /** A room name, or "selected". */
+    room: string;
+    /** The furniture's catalog name, e.g. "macheroni sofa". */
+    item: string;
+    /** Move it to this cell of the room's 8x8 grid. Both or neither. */
+    col?: number;
+    row?: number;
+    /** The new angle, not a turn to add. */
+    rotation?: number;
+    /** Multiplier on the catalog size; the only sizing an item has. */
+    scale?: number;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+};
+export type AddSurfaceAction = {
+    type: "add-surface";
+    /** The room whose wall it lies against, and which side. Must face outdoors. */
+    of: string;
+    side: RoomSide;
+    name?: string;
+    /** cm away from the wall; it runs that wall's full width. */
+    depth?: number;
+    texture?: string;
+    color?: string;
+};
+export type DeleteAction = {
+    type: "delete";
+    /** A room name, a surface name, or "selected". */
+    room: string;
+    /** Present to delete one piece of furniture inside it instead of the room. */
+    item?: string;
+};
+export type SetSurfacePropertiesAction = {
+    type: "set-surface-properties";
+    /** Its name from the Outdoor surfaces list. */
+    surface: string;
+    name?: string;
+    /** cm out from the wall it lies against; same wall, same width. */
+    depth?: number;
+    texture?: string;
+    pattern?: string;
+    color?: string;
+};
+export interface AIResponse {
+    reply: string;
+    actions: PlannerAction[];
+    /**
+     * Multi-step continuation. Building something big (a whole multi-room
+     * floor plan) can need more actions than fit in one well-grounded
+     * response — e.g. you want to see a room's real wall IDs (from a fresh
+     * `PlanSummary`) before placing doors on it. Real IDs are random and only
+     * exist once the library has created the element, so anything that needs one
+     * has to wait for the next call.
+     *
+     * Set `done: false` to have the library apply this response's `actions`,
+     * take a fresh `summarizePlan()` of the result, and call your handler
+     * again — same `messages` array with this response's own `reply` appended
+     * as an assistant turn, no synthetic "continue" message injected — so you
+     * see your own last reply plus the updated plan and pick up from there.
+     * Each intermediate `reply` is shown in the chat as its own message, so
+     * narrate what that step did (e.g. "Built the room shells, adding doors
+     * next…").
+     *
+     * Omit, or set `true`, once you're finished — this is also the default
+     * for backends that don't implement this field, so single-response
+     * behavior is unchanged. The library caps continuations at 8 steps
+     * regardless, in case of a backend bug that never stops; don't rely on
+     * more than that for one user request.
+     */
+    done?: boolean;
+    /**
+     * Actions the backend rejected, with the reason. Fed back to the agent on the
+     * next continuation so it can correct itself instead of repeating the
+     * mistake — see the "Continue." turn in AIChatPanel.
+     */
+    dropped?: {
+        reason: string;
+        action: unknown;
+    }[];
+}
+/**
+ * Extras the library hands a handler on every call. Optional on purpose: a
+ * handler written against the original two-argument signature keeps working
+ * untouched — it just never streams and never gets cancelled.
+ */
+export interface AIStreamContext {
+    /**
+     * Aborted when the planner unmounts mid-request. Pass it to `fetch` so a
+     * closed tab stops the backend generating (and billing) into a dead socket.
+     */
+    signal?: AbortSignal;
+    /**
+     * Call with each incremental chunk of reply text as it arrives, in order.
+     * The chat paints the accumulated text live while the request is still in
+     * flight.
+     *
+     * The deltas are a *preview*, not the result: when the promise resolves,
+     * the chat throws the accumulated text away and renders `AIResponse.reply`
+     * instead. The two legitimately differ (a backend that re-parses its own
+     * output can correct or replace what it streamed), so a handler must still
+     * resolve with the complete, authoritative reply — never with `""` on the
+     * grounds that it already streamed the text.
+     */
+    onReplyDelta?: (delta: string) => void;
+}
+export type AIRequestHandler = (messages: ChatMessage[], plan: PlanSummary, ctx?: AIStreamContext) => Promise<AIResponse>;
+export declare function getAIResponse(messages: ChatMessage[], _plan: PlanSummary): Promise<AIResponse>;

package/dist/types/react-planner/ai-chat/imageUpload.d.ts

@@ -0,0 +1,6 @@
+export interface PendingImage {
+    mediaType: string;
+    data: string;
+    previewUrl: string;
+}
+export declare function fileToChatImage(file: File): Promise<PendingImage>;

package/dist/types/react-planner/ai-chat/plannerActions.d.ts

@@ -0,0 +1,20 @@
+import type { PlanSummary, PlannerAction } from "./aiService";
+export declare function summarizePlan(planner: any): PlanSummary;
+/**
+ * Applies a batch of actions from the agent to the planner.
+ *
+ * The agent never sends coordinates. It says how big a room is, what to call
+ * it, and which existing room it sits next to — every number describing a
+ * POSITION is worked out here, where it can be exact. A room with no `of` /
+ * `side` is centered in the scene, which is only ever right for the first room.
+ *
+ * Rooms created earlier in this same batch are valid anchors: each one is
+ * looked up by name from live state after it is created, so a five-room plan
+ * arrives as five actions that chain off each other.
+ *
+ * @returns `skipped` — human-readable reasons anything was not applied, shown
+ *   to the user by the caller.
+ */
+export declare function applyPlannerActions(actions: PlannerAction[]): {
+    skipped: string[];
+};

package/dist/types/react-planner/ai-chat/streamingClient.d.ts

@@ -0,0 +1,31 @@
+import type { AIRequestHandler } from "./aiService";
+/**
+ * Client for a backend that speaks the streaming variant of the chat contract
+ * (`floor-planner-ai-backend`'s `POST /ai/chat/stream`). Lives in the library
+ * so every consumer doesn't hand-roll an SSE parser; the URL and any auth
+ * headers still belong to the consuming app — the library never holds a key.
+ *
+ * Wire format (Server-Sent Events, POST — so NOT `EventSource`-compatible):
+ *
+ *   event: reply  data: { delta }                     zero or more, in order
+ *   event: final  data: { reply, actions, done, … }   authoritative, terminal
+ *   event: error  data: { error, type }               terminal
+ *
+ * Only the reply text streams. Actions arrive whole in `final` because a
+ * half-parsed action isn't something the planner can apply.
+ *
+ * Failures *before* the first token (bad key, rate limit, an image sent to a
+ * text-only model) come back as an ordinary JSON error with a real status
+ * code. Once the stream has started the status line is spent, so anything
+ * after that arrives as an `error` frame — hence both paths below.
+ */
+export interface StreamingAIHandlerOptions {
+    /** Full URL of the streaming endpoint, e.g. `http://host:3001/ai/chat/stream`. */
+    url: string;
+    /**
+     * Extra request headers (auth, tenant id…). A function is re-invoked per
+     * request, so a token that rotates doesn't go stale.
+     */
+    headers?: Record<string, string> | (() => Record<string, string>);
+}
+export declare const createStreamingAIHandler: ({ url, headers, }: StreamingAIHandlerOptions) => AIRequestHandler;

package/dist/types/react-planner/ai-chat/useTypewriter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Paces streamed text into the UI at frame rate instead of at network rate.
+ *
+ * Deltas off an SSE stream don't arrive one token at a time — TCP and any
+ * proxy in between coalesce them, so what lands is a few characters, then 80,
+ * then nothing for 300ms. Rendering each delta the moment it arrives makes the
+ * text jump in uneven blocks. Buffering here and draining a slice per animation
+ * frame turns the same bytes into steady output.
+ *
+ * The drain is proportional (a fixed chars-per-frame rate would fall further
+ * and further behind a fast model), so a big burst catches up in a handful of
+ * frames rather than trickling out for seconds after the response is done.
+ */
+export declare const useTypewriter: () => {
+    text: string;
+    push: (delta: string) => void;
+    reset: () => void;
+    getFullText: () => string;
+};

package/dist/types/react-planner/catalog/catalog.d.ts

@@ -47,9 +47,33 @@ export default class Catalog {
     private elements;
     categories: Record<string, CatalogCategory>;
     private propertyTypes;
+    /**
+     * Placeholders handed out for types the plan references and this catalog
+     * doesn't have. Cached so a type resolves to the same object every render,
+     * and so the warning about it is printed once.
+     */
+    private missingElements;
     unit: Unit;
     constructor(unit?: Unit);
+    /**
+     * The element `type` names, or a placeholder if the catalog has no such
+     * element.
+     *
+     * Deliberately total. Every renderer and editor reaches an element through
+     * here, and a plan can legitimately outlive the catalog it was drawn with —
+     * an item renamed, dropped, or opened by an app carrying a different subset.
+     * Throwing meant one stale `type` in a saved plan took down the render of
+     * everything around it; the placeholder keeps the rest of the plan on screen
+     * and keeps the offending element selectable, movable and — because nothing
+     * rewrites its `type` — able to come back intact against the right catalog.
+     * Callers that need to know whether something is really registered ask
+     * `hasElement`.
+     */
     getElement(type: string): CatalogElement;
+    /** Every registered element of a prototype ("items", "holes", "lines"),
+     *  regardless of the category it was filed under. Backs the sidebar's
+     *  "similar items" list, which matches on tags rather than category. */
+    getElementsOfPrototype(prototype: string): CatalogElement[];
     getCategory(categoryName: string): CatalogCategory;
     getPropertyType(type: string): any;
     registerElement(json: any): void;

package/dist/types/react-planner/catalog/factories/AreaFactory.d.ts

@@ -1,24 +1 @@
-export default function AreaFactory(name: string, info: any, textures: any): {
-    name: string;
-    prototype: string;
-    info: any;
-    properties: {
-        patternColor: {
-            label: string;
-            type: string;
-            defaultValue: string;
-        };
-        thickness: {
-            label: string;
-            type: string;
-            defaultValue: {
-                length: number;
-                _length: number;
-                _unit: string;
-            };
-        };
-    };
-    render2D: (element: any, layer: any, scene: any) => import("react/jsx-runtime").JSX.Element;
-    render3D: (element: any, layer: any, scene: any) => Promise<import("three").Mesh<import("three").ShapeGeometry, import("three").MeshPhongMaterial, import("three").Object3DEventMap>>;
-    updateRender3D: (element: any, layer: any, scene: any, mesh: any, oldElement: any, differences: any, selfDestroy: any, selfBuild: any) => Promise<import("three").Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>;
-};
+export default function AreaFactory(name: string, info: any, textures: any): any;

package/dist/types/react-planner/catalog/factories/ItemFactory.d.ts

@@ -12,6 +12,8 @@ export default function (json: any): {
         tag: any;
         description: any;
         image: any;
+        width: any;
+        depth: any;
     };
     properties: any;
     render2D: (element: any, layer: any, scene: any) => import("react/jsx-runtime").JSX.Element;

package/dist/types/react-planner/catalog/factories/WallFactory.d.ts

@@ -1,26 +1 @@
-export default function WallFactory(name: string, info: any, textures: any): {
-    name: string;
-    prototype: string;
-    info: any;
-    properties: {
-        height: {
-            label: string;
-            type: string;
-            defaultValue: {
-                length: number;
-            };
-        };
-        thickness: {
-            label: string;
-            type: string;
-            defaultValue: {
-                length: number;
-                _length: number;
-                _unit: string;
-            };
-        };
-    };
-    render2D: (element: any, layer: any, scene: any, mode: string) => import("react/jsx-runtime").JSX.Element;
-    render3D: (element: any, layer: any, scene: any) => Promise<import("three").Group<import("three").Object3DEventMap>>;
-    updateRender3D: (element: any, layer: any, scene: any, mesh: any, oldElement: any, differences: any, selfDestroy: any, selfBuild: any) => any;
-};
+export default function WallFactory(name: string, info: any, textures: any): any;

package/dist/types/react-planner/catalog/factories/area-factory-3d.d.ts

@@ -1,4 +1,4 @@
-import { MeshPhongMaterial, ShapeGeometry, Mesh } from "three";
+import { MeshStandardMaterial, ShapeGeometry, Mesh } from "three";
 import * as THREE from "three";
 import type { Layer, Scene } from "../../models";
 type TextureData = {
@@ -13,6 +13,6 @@ type TextureData = {
         heightRepeatScale: number;
     };
 };
-export declare function createArea(element: any, layer: Layer, scene: Scene, textures: Record<string, TextureData>): Promise<Mesh<ShapeGeometry, MeshPhongMaterial, THREE.Object3DEventMap>>;
+export declare function createArea(element: any, layer: Layer, scene: Scene, textures: Record<string, TextureData>): Promise<Mesh<ShapeGeometry, MeshStandardMaterial, THREE.Object3DEventMap>>;
 export declare function updatedArea(element: any, layer: Layer, scene: Scene, textures: Record<string, TextureData>, mesh: Mesh, oldElement: any, differences: string[], selfDestroy: () => void, selfBuild: () => Promise<Mesh>): Promise<Mesh>;
 export {};

package/dist/types/react-planner/catalog/factories/area-patterns.d.ts

@@ -0,0 +1,42 @@
+export interface AreaPattern {
+    key: string;
+    name: string;
+    size: number;
+    /**
+     * Degrees the whole tiling lattice is turned by, SVG-style (positive =
+     * clockwise on screen). Only 45° is periodic under square tiling — see
+     * `patternTileDataURI` — so stick to that or leave it out.
+     */
+    rotation?: number;
+    /**
+     * The tile's contents as raw SVG markup rather than JSX, because the same
+     * string has to serve two very different consumers: React, for the 2D
+     * viewer, and a standalone `<svg>` document rasterized into a Three.js
+     * texture for the 3D viewer. Anything expressible only as React elements
+     * would have to be written twice and would drift.
+     */
+    marks: (color: string) => string;
+}
+export declare function darkenHex(hex: string, factor?: number): string;
+export declare const AREA_PATTERNS: AreaPattern[];
+export declare function getAreaPattern(key: string | undefined): AreaPattern | undefined;
+/** `patternTransform` for the SVG `<pattern>`, or undefined when unrotated. */
+export declare function patternTransform(pattern: AreaPattern): string | undefined;
+/** The marks, for any React consumer that is building an SVG `<pattern>`. */
+export declare function PatternMarks({ pattern, color, }: {
+    pattern: AreaPattern;
+    color: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * One tile of `pattern` as an `<svg>` data URI, background included.
+ *
+ * The 3D floor can't hatch a mesh the way SVG hatches a path, so it gets a
+ * texture instead — and the texture is produced by handing the browser the
+ * *same* `<pattern>` element the 2D viewer uses. Rotation, stroke widths and
+ * spacing therefore come out of one renderer, not two approximations of each
+ * other, and the mesh only has to tile the result.
+ */
+export declare function patternTileDataURI(pattern: AreaPattern, background: string, markColor: string): {
+    uri: string;
+    tileSize: number;
+};