@ubuilder-ai/workspace 0.0.1

package/dist/floorplan-geometry-renderer.d.ts

@@ -0,0 +1,56 @@
+import { type FloorplanGeometry } from '@ubuilder-ai/core';
+export declare const FLOORPLAN_INTERACTION_POINTER_EVENTS_VARIABLE = "--pascal-floorplan-interaction-pointer-events";
+export declare function controlledFloorplanPointerEvents(pointerEvents: string): string;
+type FloorplanRenderMode = 'screen' | 'pdf';
+/**
+ * Pure-data → SVG converter. Walks a `FloorplanGeometry` tree returned by
+ * `def.floorplan(node, ctx)` and emits the matching React-SVG nodes.
+ *
+ * Coordinates are level-local meters. The wrapping floor-plan panel
+ * applies the world→SVG transform via its viewBox, so kinds emit
+ * geometry in the same units they reason about in 3D.
+ *
+ * Group transforms compose: `transform={translate(x y) rotate(deg)}`.
+ * Rotations are radians at the data layer (consistent with three.js
+ * conventions used by `def.geometry`) and converted to degrees for SVG
+ * here — kinds never touch units.
+ *
+ * Styling props map straight onto SVG attributes. Builders that need
+ * theme colors should declare them inline or expose them as registry
+ * tokens later (deferred until a real need surfaces — AI-authored kinds
+ * can pick safe defaults today).
+ */
+export declare const FloorplanGeometryRenderer: import("react").MemoExoticComponent<({ geometry, pointerEventsOverride, sceneRotationDeg, annotationUnitsPerPoint, screenUnitsPerPixel, renderMode, }: {
+    geometry: FloorplanGeometry;
+    pointerEventsOverride?: string;
+    sceneRotationDeg?: number;
+    annotationUnitsPerPoint?: number;
+    screenUnitsPerPixel?: number;
+    renderMode?: FloorplanRenderMode;
+}) => import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null>;
+export declare function resolveDocumentFloorplanAnnotationStyle(geometry: FloorplanGeometry & {
+    kind: Exclude<FloorplanGeometry['kind'], 'group'>;
+}, annotationUnitsPerPoint?: number): {
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    vectorEffect?: 'non-scaling-stroke';
+};
+export declare function documentRectGeometryAttrs(geometry: Extract<FloorplanGeometry, {
+    kind: 'rect';
+}>, annotationUnitsPerPoint?: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rx: number | undefined;
+    ry: number | undefined;
+};
+export declare function documentCircleGeometryAttrs(geometry: Extract<FloorplanGeometry, {
+    kind: 'circle';
+}>, annotationUnitsPerPoint?: number): {
+    r: number;
+};
+export declare function resolveDocumentAnnotationGroupChildren(children: FloorplanGeometry[], annotationUnitsPerPoint?: number): FloorplanGeometry[];
+export {};
+//# sourceMappingURL=floorplan-geometry-renderer.d.ts.map

package/dist/floorplan-geometry-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-geometry-renderer.d.ts","sourceRoot":"","sources":["../src/floorplan-geometry-renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAgB,MAAM,mBAAmB,CAAA;AAwBxE,eAAO,MAAM,6CAA6C,kDACT,CAAA;AAEjD,wBAAgB,gCAAgC,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED,KAAK,mBAAmB,GAAG,QAAQ,GAAG,KAAK,CAAA;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,yBAAyB,yJAOnC;IACD,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,UAAU,CAAC,EAAE,mBAAmB,CAAA;CACjC,uGAUC,CAAA;AAyDF,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,iBAAiB,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAA;CAAE,EACnF,uBAAuB,CAAC,EAAE,MAAM,GAC/B;IACD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,oBAAoB,CAAA;CACpC,CA6BA;AA8BD,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,OAAO,CAAC,iBAAiB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EACtD,uBAAuB,CAAC,EAAE,MAAM;;;;;;;EAyBjC;AAMD,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,OAAO,CAAC,iBAAiB,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,EACxD,uBAAuB,CAAC,EAAE,MAAM;;EAMjC;AAMD,wBAAgB,sCAAsC,CACpD,QAAQ,EAAE,iBAAiB,EAAE,EAC7B,uBAAuB,CAAC,EAAE,MAAM,GAC/B,iBAAiB,EAAE,CA0BrB"}

package/dist/floorplan-geometry-renderer.js

@@ -0,0 +1,319 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { loadAssetUrl } from '@ubuilder-ai/core';
+import { readFloorplanGeometryMetadata } from '@ubuilder-ai/floorplan-contract';
+import { memo, useEffect, useState } from 'react';
+import { floorplanAnnotationObstacleMode, isFloorplanAnnotationObstacleGeometry, } from './floorplan-annotation-obstacles';
+import { FloorplanDimensionRenderer, FloorplanDimensionStringRenderer, } from './floorplan-dimension-renderer';
+import { resolveFloorplanLabelAngle } from './floorplan-label-angle';
+const STATIC_LABEL_UNITS_PER_PIXEL = 0.01;
+const DOCUMENT_DEFAULT_TEXT_SIZE_PT = 8;
+const DOCUMENT_ROOM_NAME_TEXT_SIZE_PT = 8;
+const DOCUMENT_ROOM_NUMBER_TEXT_SIZE_PT = 7;
+const DOCUMENT_ROOM_DETAIL_TEXT_SIZE_PT = 5.5;
+const DOCUMENT_COLUMN_MARK_TEXT_SIZE_PT = 7;
+const DOCUMENT_DEFAULT_STROKE_WIDTH_PT = 0.5;
+const DOCUMENT_TEXT_OUTLINE_MIN_WIDTH_PT = 0.75;
+const DOCUMENT_MARK_HEIGHT_PT = 14;
+const PDF_ANNOTATION_STROKE_WIDTH_PT = 0.5;
+export const FLOORPLAN_INTERACTION_POINTER_EVENTS_VARIABLE = '--pascal-floorplan-interaction-pointer-events';
+export function controlledFloorplanPointerEvents(pointerEvents) {
+    return `var(${FLOORPLAN_INTERACTION_POINTER_EVENTS_VARIABLE}, ${pointerEvents})`;
+}
+/**
+ * Pure-data → SVG converter. Walks a `FloorplanGeometry` tree returned by
+ * `def.floorplan(node, ctx)` and emits the matching React-SVG nodes.
+ *
+ * Coordinates are level-local meters. The wrapping floor-plan panel
+ * applies the world→SVG transform via its viewBox, so kinds emit
+ * geometry in the same units they reason about in 3D.
+ *
+ * Group transforms compose: `transform={translate(x y) rotate(deg)}`.
+ * Rotations are radians at the data layer (consistent with three.js
+ * conventions used by `def.geometry`) and converted to degrees for SVG
+ * here — kinds never touch units.
+ *
+ * Styling props map straight onto SVG attributes. Builders that need
+ * theme colors should declare them inline or expose them as registry
+ * tokens later (deferred until a real need surfaces — AI-authored kinds
+ * can pick safe defaults today).
+ */
+export const FloorplanGeometryRenderer = memo(function FloorplanGeometryRenderer({ geometry, pointerEventsOverride, sceneRotationDeg = 0, annotationUnitsPerPoint, screenUnitsPerPixel, renderMode = 'screen', }) {
+    return renderNode(geometry, 0, pointerEventsOverride, sceneRotationDeg, annotationUnitsPerPoint, screenUnitsPerPixel, renderMode);
+});
+function styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode = 'screen') {
+    // Shared SVG attribute mapping for any styled primitive. Keeps the per-
+    // primitive switch arms terse and ensures new style fields land
+    // everywhere at once. `as any` avoids re-asserting every variant
+    // includes the style fields — they all do, except `group` (which is
+    // filtered out by the caller's type bound).
+    const s = g;
+    const annotationMetadata = readFloorplanGeometryMetadata(g);
+    const documentStyle = resolveDocumentFloorplanAnnotationStyle(g, annotationUnitsPerPoint);
+    const vectorEffect = documentStyle.vectorEffect ?? s.vectorEffect;
+    const resolvedStrokeWidth = documentStyle.strokeWidth ?? s.strokeWidth;
+    const strokeWidth = renderMode === 'pdf' &&
+        vectorEffect === 'non-scaling-stroke' &&
+        resolvedStrokeWidth !== undefined
+        ? Math.min(PDF_ANNOTATION_STROKE_WIDTH_PT, resolvedStrokeWidth)
+        : resolvedStrokeWidth;
+    return {
+        'data-floorplan-annotation-obstacle': floorplanAnnotationObstacleMode(g),
+        'data-floorplan-annotation-role': annotationMetadata.annotationRole,
+        fill: documentStyle.fill ?? s.fill ?? 'none',
+        fillOpacity: s.fillOpacity,
+        stroke: documentStyle.stroke ?? s.stroke,
+        strokeWidth,
+        strokeDasharray: s.strokeDasharray,
+        strokeLinecap: s.strokeLinecap,
+        strokeLinejoin: s.strokeLinejoin,
+        strokeOpacity: s.strokeOpacity,
+        opacity: s.opacity,
+        vectorEffect,
+        pointerEvents: pointerEventsOverride ??
+            (s.pointerEvents ? controlledFloorplanPointerEvents(s.pointerEvents) : undefined),
+        style: s.cursor ? { cursor: s.cursor } : undefined,
+    };
+}
+export function resolveDocumentFloorplanAnnotationStyle(geometry, annotationUnitsPerPoint) {
+    if (annotationUnitsPerPoint === undefined)
+        return {};
+    const styled = geometry;
+    if (!styled.stroke && geometry.kind !== 'text')
+        return {};
+    if (geometry.kind === 'text') {
+        const sourceFontSize = Math.max(geometry.fontSize, 1e-6);
+        const sourceStrokeWidth = geometry.strokeWidth ?? 0;
+        const outlineRatio = sourceStrokeWidth > 0 ? sourceStrokeWidth / sourceFontSize : 0;
+        const fontSize = documentTextFontSize(geometry, annotationUnitsPerPoint);
+        return {
+            strokeWidth: geometry.stroke && outlineRatio > 0
+                ? Math.max(DOCUMENT_TEXT_OUTLINE_MIN_WIDTH_PT * annotationUnitsPerPoint, fontSize * outlineRatio)
+                : undefined,
+        };
+    }
+    return {
+        strokeWidth: documentStrokeWidth(styled, annotationUnitsPerPoint),
+        vectorEffect: 'non-scaling-stroke',
+    };
+}
+function documentTextFontSize(geometry, annotationUnitsPerPoint) {
+    return documentTextSizePt(geometry) * annotationUnitsPerPoint;
+}
+function documentTextSizePt(geometry) {
+    switch (readFloorplanGeometryMetadata(geometry).annotationRole) {
+        case 'room-label':
+            if (geometry.fontSize >= 0.18)
+                return DOCUMENT_ROOM_NAME_TEXT_SIZE_PT;
+            if (geometry.fontSize >= 0.145)
+                return DOCUMENT_ROOM_NUMBER_TEXT_SIZE_PT;
+            return DOCUMENT_ROOM_DETAIL_TEXT_SIZE_PT;
+        case 'column-center':
+        case 'stair-annotation':
+            return DOCUMENT_COLUMN_MARK_TEXT_SIZE_PT;
+        default:
+            return DOCUMENT_DEFAULT_TEXT_SIZE_PT;
+    }
+}
+function documentStrokeWidth(geometry, annotationUnitsPerPoint) {
+    return Math.max(DOCUMENT_DEFAULT_STROKE_WIDTH_PT, Math.min(1.2, geometry.strokeWidth ?? 0.5));
+}
+export function documentRectGeometryAttrs(geometry, annotationUnitsPerPoint) {
+    if (annotationUnitsPerPoint === undefined || !isAnnotationMarkRect(geometry)) {
+        return {
+            x: geometry.x,
+            y: geometry.y,
+            width: geometry.width,
+            height: geometry.height,
+            rx: geometry.rx,
+            ry: geometry.ry,
+        };
+    }
+    const centerX = geometry.x + geometry.width / 2;
+    const centerY = geometry.y + geometry.height / 2;
+    const height = DOCUMENT_MARK_HEIGHT_PT * annotationUnitsPerPoint;
+    const width = Math.max(height * 1.6, (geometry.width / Math.max(geometry.height, 1e-6)) * height);
+    return {
+        x: centerX - width / 2,
+        y: centerY - height / 2,
+        width,
+        height,
+        rx: height / 2,
+        ry: height / 2,
+    };
+}
+function isAnnotationMarkRect(geometry) {
+    return geometry.fill === '#ffffff' && !!geometry.stroke && geometry.height <= 0.5;
+}
+export function documentCircleGeometryAttrs(geometry, annotationUnitsPerPoint) {
+    if (annotationUnitsPerPoint === undefined || !isAnnotationMarkCircle(geometry)) {
+        return { r: geometry.r };
+    }
+    return { r: Math.max(geometry.r, (DOCUMENT_MARK_HEIGHT_PT / 2) * annotationUnitsPerPoint) };
+}
+function isAnnotationMarkCircle(geometry) {
+    return geometry.fill === '#ffffff' && !!geometry.stroke && geometry.r <= 0.25;
+}
+export function resolveDocumentAnnotationGroupChildren(children, annotationUnitsPerPoint) {
+    if (annotationUnitsPerPoint === undefined)
+        return children;
+    const next = [...children];
+    let start = 0;
+    while (start < next.length) {
+        const first = next[start];
+        if (!isDocumentTextLine(first)) {
+            start++;
+            continue;
+        }
+        let end = start + 1;
+        while (end < next.length && isSameDocumentTextRun(first, next[end]))
+            end++;
+        if (end - start > 1) {
+            const run = next.slice(start, end);
+            const adjusted = positionDocumentTextRun(run, annotationUnitsPerPoint);
+            for (let index = 0; index < adjusted.length; index++) {
+                const line = adjusted[index];
+                if (line)
+                    next[start + index] = line;
+            }
+        }
+        start = end;
+    }
+    return next;
+}
+function isDocumentTextLine(geometry) {
+    return geometry?.kind === 'text' && geometry.upright === true;
+}
+function isSameDocumentTextRun(first, candidate) {
+    return (isDocumentTextLine(candidate) &&
+        Math.abs(candidate.x - first.x) < 1e-6 &&
+        candidate.textAnchor === first.textAnchor &&
+        readFloorplanGeometryMetadata(candidate).annotationRole ===
+            readFloorplanGeometryMetadata(first).annotationRole);
+}
+function positionDocumentTextRun(run, annotationUnitsPerPoint) {
+    const centerY = run.reduce((sum, line) => sum + line.y, 0) / run.length;
+    const steps = run.slice(0, -1).map((line, index) => {
+        const next = run[index + 1] ?? line;
+        const largerFontPt = Math.max(documentTextSizePt(line), documentTextSizePt(next));
+        return largerFontPt * 1.25 * annotationUnitsPerPoint;
+    });
+    const totalHeight = steps.reduce((sum, step) => sum + step, 0);
+    let y = centerY - totalHeight / 2;
+    return run.map((line, index) => {
+        if (index > 0)
+            y += steps[index - 1] ?? 0;
+        return { ...line, y };
+    });
+}
+function renderNode(g, keyHint, pointerEventsOverride, sceneRotationDeg = 0, annotationUnitsPerPoint, screenUnitsPerPixel, renderMode = 'screen') {
+    switch (g.kind) {
+        case 'path':
+            return (_jsx("path", { d: g.d, ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        case 'polygon':
+            return (_jsx("polygon", { points: pointsToAttr(g.points), ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        case 'polyline':
+            return (_jsx("polyline", { points: pointsToAttr(g.points), ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        case 'rect': {
+            const attrs = documentRectGeometryAttrs(g, annotationUnitsPerPoint);
+            return (_jsx("rect", { height: attrs.height, rx: attrs.rx, ry: attrs.ry, width: attrs.width, x: attrs.x, y: attrs.y, ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        }
+        case 'circle': {
+            const attrs = documentCircleGeometryAttrs(g, annotationUnitsPerPoint);
+            return (_jsx("circle", { cx: g.cx, cy: g.cy, r: attrs.r, ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        }
+        case 'line':
+            return (_jsx("line", { x1: g.x1, x2: g.x2, y1: g.y1, y2: g.y2, ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        case 'text': {
+            const fontSize = annotationUnitsPerPoint !== undefined
+                ? documentTextFontSize(g, annotationUnitsPerPoint)
+                : g.fontSize;
+            const textStyle = resolveDocumentFloorplanAnnotationStyle(g, annotationUnitsPerPoint);
+            const pdfOutlinedText = renderMode === 'pdf' && g.paintOrder === 'stroke' && !!g.stroke;
+            const fill = pdfOutlinedText && g.fill?.toLocaleLowerCase() === '#ffffff'
+                ? g.stroke
+                : (g.fill ?? '#171717');
+            if (g.upright) {
+                return (_jsx("g", { "data-floorplan-annotation-obstacle": floorplanAnnotationObstacleMode(g), transform: `translate(${g.x} ${g.y}) rotate(${-sceneRotationDeg})`, children: _jsx("text", { dominantBaseline: g.dominantBaseline ?? 'middle', fill: fill, fontFamily: g.fontFamily, fontSize: fontSize, fontWeight: g.fontWeight, opacity: g.opacity, paintOrder: pdfOutlinedText ? undefined : g.paintOrder, pointerEvents: pointerEventsOverride, stroke: pdfOutlinedText ? undefined : g.stroke, strokeLinecap: !pdfOutlinedText && g.stroke ? 'round' : undefined, strokeLinejoin: !pdfOutlinedText && g.stroke ? 'round' : undefined, strokeWidth: pdfOutlinedText ? undefined : (textStyle.strokeWidth ?? g.strokeWidth), textAnchor: g.textAnchor ?? 'start', x: 0, y: 0, children: g.text }) }, keyHint));
+            }
+            return (_jsx("text", { "data-floorplan-annotation-obstacle": floorplanAnnotationObstacleMode(g), dominantBaseline: g.dominantBaseline ?? 'middle', fill: fill, fontFamily: g.fontFamily, fontSize: fontSize, fontWeight: g.fontWeight, opacity: g.opacity, paintOrder: pdfOutlinedText ? undefined : g.paintOrder, stroke: pdfOutlinedText ? undefined : g.stroke, strokeLinecap: !pdfOutlinedText && g.stroke ? 'round' : undefined, strokeLinejoin: !pdfOutlinedText && g.stroke ? 'round' : undefined, strokeWidth: pdfOutlinedText ? undefined : (textStyle.strokeWidth ?? g.strokeWidth), textAnchor: g.textAnchor ?? 'start', pointerEvents: pointerEventsOverride, x: g.x, y: g.y, children: g.text }, keyHint));
+        }
+        case 'dimension':
+            return (_jsx(FloorplanDimensionRenderer, { geometry: g, sceneRotationDeg: sceneRotationDeg, annotationUnitsPerPoint: annotationUnitsPerPoint, renderMode: renderMode }, keyHint));
+        case 'dimension-string':
+            return (_jsx(FloorplanDimensionStringRenderer, { annotationUnitsPerPoint: annotationUnitsPerPoint, geometry: g, renderMode: renderMode, sceneRotationDeg: sceneRotationDeg }, keyHint));
+        case 'dimension-label': {
+            const unitsPerPixel = annotationUnitsPerPoint ?? screenUnitsPerPixel ?? STATIC_LABEL_UNITS_PER_PIXEL;
+            const documentMode = annotationUnitsPerPoint !== undefined;
+            const outlined = g.appearance === 'outlined';
+            const pdfOutlined = outlined && renderMode === 'pdf';
+            const padX = unitsPerPixel * 6;
+            const padY = unitsPerPixel * 3;
+            const fontSize = unitsPerPixel * (documentMode ? 8 : outlined ? 12 : 10);
+            const textWidth = g.text.length * unitsPerPixel * 6.2;
+            const plateW = textWidth + padX * 2;
+            const plateH = fontSize + padY * 2;
+            const degrees = resolveFloorplanLabelAngle(g.angle, sceneRotationDeg, g.screenUpright);
+            const labelTransform = `translate(${g.cx} ${g.cy}) rotate(${degrees}) translate(0 ${-(g.offsetPx ?? 0) * unitsPerPixel})`;
+            return (_jsxs("g", { "data-floorplan-annotation-angle-radians": g.angle, "data-floorplan-annotation-default-transform": labelTransform, "data-floorplan-annotation-label": "", "data-floorplan-annotation-priority": "20", "data-floorplan-annotation-screen-upright": g.screenUpright ? 'true' : undefined, "data-floorplan-annotation-transform-after-rotation": `translate(0 ${-(g.offsetPx ?? 0) * unitsPerPixel})`, "data-floorplan-annotation-transform-before-rotation": `translate(${g.cx} ${g.cy})`, pointerEvents: "none", transform: labelTransform, children: [outlined && !pdfOutlined ? null : (_jsx("rect", { "data-floorplan-dimension-label-plate": pdfOutlined ? '' : undefined, fill: "#ffffff", height: plateH, opacity: 0.92, rx: unitsPerPixel * 3, ry: unitsPerPixel * 3, stroke: pdfOutlined ? undefined : '#334155', strokeWidth: pdfOutlined ? undefined : unitsPerPixel * 0.5, width: plateW, x: -plateW / 2, y: -plateH / 2 })), _jsx("text", { dominantBaseline: "middle", fill: pdfOutlined ? '#111827' : outlined ? '#ffffff' : '#111827', fontFamily: outlined && !pdfOutlined
+                            ? 'system-ui, -apple-system, sans-serif'
+                            : 'ui-monospace, SFMono-Regular, Menlo, monospace', fontSize: fontSize, fontWeight: outlined ? 500 : 600, paintOrder: outlined && !pdfOutlined ? 'stroke' : undefined, stroke: outlined && !pdfOutlined ? '#334155' : undefined, strokeLinecap: outlined && !pdfOutlined ? 'round' : undefined, strokeLinejoin: outlined && !pdfOutlined ? 'round' : undefined, strokeWidth: outlined && !pdfOutlined ? fontSize * 0.35 : undefined, textAnchor: "middle", x: 0, y: 0, children: g.text })] }, keyHint));
+        }
+        case 'image':
+            return (_jsx(FloorplanImage, { center: g.center, height: g.height, opacity: g.opacity, preserveAspectRatio: g.preserveAspectRatio ?? 'xMidYMid meet', rotation: g.rotation ?? 0, url: g.url, width: g.width }, keyHint));
+        case 'group': {
+            const transform = formatTransform(g.transform);
+            const children = resolveDocumentAnnotationGroupChildren(g.children, annotationUnitsPerPoint);
+            return (_jsx("g", { "data-floorplan-annotation-obstacle": isFloorplanAnnotationObstacleGeometry(g) ? '' : undefined, transform: transform, children: children.map((child, i) => renderNode(child, i, pointerEventsOverride, sceneRotationDeg, annotationUnitsPerPoint, screenUnitsPerPixel, renderMode)) }, keyHint));
+        }
+        // The remaining interactive primitives (hatch / hit-line / endpoint-handle)
+        // need the SVG context + theme palette + units-per-
+        // pixel that only the registry layer has access to. They're rendered
+        // by `floorplan-registry-layer.tsx`'s interactive walker instead. If
+        // a caller routes one of these through this pure renderer it
+        // silently drops — the static renderer is for static output.
+        default:
+            return null;
+    }
+}
+function pointsToAttr(points) {
+    return points.map(([x, y]) => `${x},${y}`).join(' ');
+}
+function formatTransform(t) {
+    if (!t)
+        return undefined;
+    const parts = [];
+    if (t.translate)
+        parts.push(`translate(${t.translate[0]} ${t.translate[1]})`);
+    if (t.rotate !== undefined)
+        parts.push(`rotate(${(t.rotate * 180) / Math.PI})`);
+    return parts.length > 0 ? parts.join(' ') : undefined;
+}
+/**
+ * `image` primitive renderer. Resolves the URL asynchronously via
+ * `loadAssetUrl` (handles CDN / Supabase storage) and renders an SVG
+ * `<image>` centered at `center`, rotated around it, sized in plan-local
+ * metres. While the resolution is in flight, renders nothing.
+ */
+function FloorplanImage({ url, center, width, height, rotation, preserveAspectRatio, opacity, }) {
+    const [resolvedUrl, setResolvedUrl] = useState(null);
+    useEffect(() => {
+        if (!url) {
+            setResolvedUrl(null);
+            return;
+        }
+        let cancelled = false;
+        setResolvedUrl(null);
+        loadAssetUrl(url).then((next) => {
+            if (!cancelled)
+                setResolvedUrl(next);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [url]);
+    if (!resolvedUrl)
+        return null;
+    const rotationDeg = (rotation * 180) / Math.PI;
+    return (_jsx("g", { pointerEvents: "none", transform: `translate(${center[0]} ${center[1]}) rotate(${rotationDeg})`, children: _jsx("image", { height: height, href: resolvedUrl, opacity: opacity, preserveAspectRatio: preserveAspectRatio, width: width, x: -width / 2, y: -height / 2 }) }));
+}

package/dist/floorplan-initial-view.d.ts

@@ -0,0 +1,29 @@
+export type FloorplanViewPoint = {
+    x: number;
+    y: number;
+};
+export type FloorplanSyncedView = {
+    localCenter: FloorplanViewPoint;
+    userRotationDeg: number;
+    viewWidth: number;
+};
+/**
+ * Gives a blank level a room-scale viewport on every screen shape. Wide
+ * desktop canvases keep more horizontal context, but never inherit a
+ * city/GIS-scale camera width; narrow/mobile canvases retain at least 12 m.
+ */
+export declare function resolveEmptyFloorplanViewWidth(aspectRatio: number): number;
+/**
+ * A linked 3D camera is authoritative once a level contains authored content.
+ * For a genuinely blank level it may still carry the Site/GIS camera pose from
+ * the preceding workflow, so use the fitted room-scale origin instead.
+ */
+export declare function resolveFloorplanSyncedView(input: {
+    emptyLocalCenter: FloorplanViewPoint;
+    emptyViewWidth: number;
+    hasAuthoredContent: boolean;
+    navigationLocalCenter: FloorplanViewPoint;
+    navigationUserRotationDeg: number;
+    navigationViewWidth: number;
+}): FloorplanSyncedView;
+//# sourceMappingURL=floorplan-initial-view.d.ts.map

package/dist/floorplan-initial-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-initial-view.d.ts","sourceRoot":"","sources":["../src/floorplan-initial-view.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,kBAAkB,CAAA;IAC/B,eAAe,EAAE,MAAM,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAKD;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAM1E;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,gBAAgB,EAAE,kBAAkB,CAAA;IACpC,cAAc,EAAE,MAAM,CAAA;IACtB,kBAAkB,EAAE,OAAO,CAAA;IAC3B,qBAAqB,EAAE,kBAAkB,CAAA;IACzC,yBAAyB,EAAE,MAAM,CAAA;IACjC,mBAAmB,EAAE,MAAM,CAAA;CAC5B,GAAG,mBAAmB,CActB"}

package/dist/floorplan-initial-view.js

@@ -0,0 +1,30 @@
+const EMPTY_FLOORPLAN_MIN_VIEW_WIDTH = 12;
+const EMPTY_FLOORPLAN_MAX_VIEW_WIDTH = 20;
+/**
+ * Gives a blank level a room-scale viewport on every screen shape. Wide
+ * desktop canvases keep more horizontal context, but never inherit a
+ * city/GIS-scale camera width; narrow/mobile canvases retain at least 12 m.
+ */
+export function resolveEmptyFloorplanViewWidth(aspectRatio) {
+    const safeAspectRatio = Number.isFinite(aspectRatio) && aspectRatio > 0 ? aspectRatio : 1;
+    return Math.min(EMPTY_FLOORPLAN_MAX_VIEW_WIDTH, Math.max(EMPTY_FLOORPLAN_MIN_VIEW_WIDTH, EMPTY_FLOORPLAN_MIN_VIEW_WIDTH * safeAspectRatio));
+}
+/**
+ * A linked 3D camera is authoritative once a level contains authored content.
+ * For a genuinely blank level it may still carry the Site/GIS camera pose from
+ * the preceding workflow, so use the fitted room-scale origin instead.
+ */
+export function resolveFloorplanSyncedView(input) {
+    if (input.hasAuthoredContent) {
+        return {
+            localCenter: input.navigationLocalCenter,
+            userRotationDeg: input.navigationUserRotationDeg,
+            viewWidth: input.navigationViewWidth,
+        };
+    }
+    return {
+        localCenter: input.emptyLocalCenter,
+        userRotationDeg: 0,
+        viewWidth: input.emptyViewWidth,
+    };
+}

package/dist/floorplan-label-angle.d.ts

@@ -0,0 +1,24 @@
+export declare function resolveFloorplanLabelAngle(angleRadians: number, sceneRotationDeg: number, screenUpright?: boolean): number;
+export declare function shouldUpdateFloorplanLabelRotation(previousRotationDeg: number | null, nextRotationDeg: number, minimumDeltaDeg?: number): boolean;
+export declare function resolveFloorplanAnnotationUpdate({ layoutInputsChanged, previousRotationDeg, nextRotationDeg, }: {
+    layoutInputsChanged: boolean;
+    previousRotationDeg: number | null;
+    nextRotationDeg: number;
+}): {
+    resolveCollisions: boolean;
+    updateLabelPresentation: boolean;
+};
+export declare function resolveFloorplanAnnotationLabelTransform({ angleRadians, sceneRotationDeg, screenUpright, beforeRotation, afterRotation, layoutDx, layoutDy, }: {
+    angleRadians: number;
+    sceneRotationDeg: number;
+    screenUpright: boolean;
+    beforeRotation: string;
+    afterRotation: string;
+    layoutDx?: number;
+    layoutDy?: number;
+}): {
+    defaultTransform: string;
+    transform: string;
+};
+export declare function updateSvgFloorplanLabelOrientations(labels: Iterable<SVGGElement>, sceneRotationDeg: number): number;
+//# sourceMappingURL=floorplan-label-angle.d.ts.map

package/dist/floorplan-label-angle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-label-angle.d.ts","sourceRoot":"","sources":["../src/floorplan-label-angle.ts"],"names":[],"mappings":"AAAA,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,aAAa,UAAQ,GACpB,MAAM,CASR;AAED,wBAAgB,kCAAkC,CAChD,mBAAmB,EAAE,MAAM,GAAG,IAAI,EAClC,eAAe,EAAE,MAAM,EACvB,eAAe,SAAI,GAClB,OAAO,CAIT;AAED,wBAAgB,gCAAgC,CAAC,EAC/C,mBAAmB,EACnB,mBAAmB,EACnB,eAAe,GAChB,EAAE;IACD,mBAAmB,EAAE,OAAO,CAAA;IAC5B,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,eAAe,EAAE,MAAM,CAAA;CACxB,GAAG;IACF,iBAAiB,EAAE,OAAO,CAAA;IAC1B,uBAAuB,EAAE,OAAO,CAAA;CACjC,CAOA;AAED,wBAAgB,wCAAwC,CAAC,EACvD,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,aAAa,EACb,QAAY,EACZ,QAAY,GACb,EAAE;IACD,YAAY,EAAE,MAAM,CAAA;IACpB,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,OAAO,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,GAAG;IACF,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;CAClB,CAYA;AAED,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,EAC7B,gBAAgB,EAAE,MAAM,GACvB,MAAM,CAwBR"}

package/dist/floorplan-label-angle.js

@@ -0,0 +1,60 @@
+export function resolveFloorplanLabelAngle(angleRadians, sceneRotationDeg, screenUpright = false) {
+    if (screenUpright)
+        return -sceneRotationDeg;
+    let localAngleDeg = (angleRadians * 180) / Math.PI;
+    let screenAngleDeg = localAngleDeg + sceneRotationDeg;
+    screenAngleDeg = ((((screenAngleDeg + 180) % 360) + 360) % 360) - 180;
+    if (screenAngleDeg > 90)
+        localAngleDeg -= 180;
+    else if (screenAngleDeg <= -90)
+        localAngleDeg += 180;
+    return ((((localAngleDeg + 180) % 360) + 360) % 360) - 180;
+}
+export function shouldUpdateFloorplanLabelRotation(previousRotationDeg, nextRotationDeg, minimumDeltaDeg = 1) {
+    if (previousRotationDeg === null)
+        return true;
+    const deltaDeg = ((((nextRotationDeg - previousRotationDeg + 180) % 360) + 360) % 360) - 180;
+    return Math.abs(deltaDeg) >= minimumDeltaDeg;
+}
+export function resolveFloorplanAnnotationUpdate({ layoutInputsChanged, previousRotationDeg, nextRotationDeg, }) {
+    return {
+        resolveCollisions: layoutInputsChanged,
+        updateLabelPresentation: layoutInputsChanged ||
+            shouldUpdateFloorplanLabelRotation(previousRotationDeg, nextRotationDeg),
+    };
+}
+export function resolveFloorplanAnnotationLabelTransform({ angleRadians, sceneRotationDeg, screenUpright, beforeRotation, afterRotation, layoutDx = 0, layoutDy = 0, }) {
+    const degrees = resolveFloorplanLabelAngle(angleRadians, sceneRotationDeg, screenUpright);
+    const defaultTransform = [beforeRotation, `rotate(${degrees})`, afterRotation]
+        .filter(Boolean)
+        .join(' ');
+    return {
+        defaultTransform,
+        transform: layoutDx === 0 && layoutDy === 0
+            ? defaultTransform
+            : `${defaultTransform} translate(${layoutDx} ${layoutDy})`,
+    };
+}
+export function updateSvgFloorplanLabelOrientations(labels, sceneRotationDeg) {
+    let updated = 0;
+    for (const label of labels) {
+        const angleRadians = Number(label.dataset.floorplanAnnotationAngleRadians);
+        if (!Number.isFinite(angleRadians))
+            continue;
+        const { defaultTransform, transform } = resolveFloorplanAnnotationLabelTransform({
+            angleRadians,
+            sceneRotationDeg,
+            screenUpright: label.dataset.floorplanAnnotationScreenUpright === 'true',
+            beforeRotation: label.dataset.floorplanAnnotationTransformBeforeRotation ?? '',
+            afterRotation: label.dataset.floorplanAnnotationTransformAfterRotation ?? '',
+            layoutDx: Number(label.dataset.floorplanAnnotationLayoutDx ?? 0),
+            layoutDy: Number(label.dataset.floorplanAnnotationLayoutDy ?? 0),
+        });
+        if (label.getAttribute('transform') === transform)
+            continue;
+        label.dataset.floorplanAnnotationDefaultTransform = defaultTransform;
+        label.setAttribute('transform', transform);
+        updated += 1;
+    }
+    return updated;
+}

package/dist/floorplan-navigation-presentation.d.ts

@@ -0,0 +1,57 @@
+export type FloorplanPresentationViewBox = {
+    minX: number;
+    minY: number;
+    width: number;
+    height: number;
+};
+export declare function setFloorplanCompassRotation(compass: {
+    style: {
+        transform: string;
+    };
+} | null, rotationDeg: number): void;
+type FloorplanRotationPresentation = {
+    svg: {
+        style: {
+            transform: string;
+            transformOrigin: string;
+            willChange: string;
+        };
+    };
+    svgStyle: {
+        transform: string;
+        transformOrigin: string;
+        willChange: string;
+    };
+};
+export declare function queueFloorplanRotationPresentationRestore<Presentation extends FloorplanRotationPresentation>(pending: {
+    current: Presentation | null;
+}, presentation: Presentation): void;
+export declare function flushFloorplanRotationPresentationRestore<Presentation extends FloorplanRotationPresentation>(pending: {
+    current: Presentation | null;
+}): void;
+export declare function getFloorplanRotationOverscanViewBox(viewBox: FloorplanPresentationViewBox): FloorplanPresentationViewBox;
+export declare function resolveFloorplanPresentationViewBox(reactViewBox: FloorplanPresentationViewBox, imperativeViewBox: FloorplanPresentationViewBox | null, interactionInProgress: boolean): FloorplanPresentationViewBox;
+export declare function canZoomFloorplanDuringNavigation(rotationInProgress: boolean): boolean;
+export declare function canApplyFloorplanNavigationSync(interactionInProgress: boolean): boolean;
+export type FloorplanNavigationSyncScheduler<Pose> = {
+    update: (pose: Pose) => void;
+    flush: () => void;
+    discard: () => void;
+};
+export declare function createFloorplanNavigationSyncScheduler<Pose>({ applyPresentation, commit, settleMs, schedule, cancel, }: {
+    applyPresentation: (pose: Pose) => void;
+    commit: (pose: Pose) => void;
+    settleMs?: number;
+    schedule?: (callback: () => void, delay: number) => ReturnType<typeof globalThis.setTimeout>;
+    cancel?: (timer: ReturnType<typeof globalThis.setTimeout>) => void;
+}): FloorplanNavigationSyncScheduler<Pose>;
+export declare function finalizeFloorplanNavigation<RotationState>({ zoomPending, panActive, rotationState, commitZoom, commitPan, commitRotation, }: {
+    zoomPending: boolean;
+    panActive: boolean;
+    rotationState: RotationState | null;
+    commitZoom: () => void;
+    commitPan: () => void;
+    commitRotation: (rotationState: RotationState) => void;
+}): void;
+export {};
+//# sourceMappingURL=floorplan-navigation-presentation.d.ts.map

package/dist/floorplan-navigation-presentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-navigation-presentation.d.ts","sourceRoot":"","sources":["../src/floorplan-navigation-presentation.ts"],"names":[],"mappings":"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"}