@pascal-app/core 1.0.3 → 1.0.4

package/dist/lib/absorb-wall-separators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"absorb-wall-separators.d.ts","sourceRoot":"","sources":["../../src/lib/absorb-wall-separators.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAE/D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmE5F"}

package/dist/lib/absorb-wall-separators.js

@@ -0,0 +1,65 @@
+import { SeparatorNode } from '../schema/nodes/separator.js';
+import { omitUndefined } from '../utils/omit-undefined.js';
+import { sampleWallPointsForRoomDetection } from './room-graph.js';
+export function absorbWallSeparators(nodes, levelId, mintId) {
+    const walls = Object.values(nodes).filter((n) => n.type === 'wall' && n.parentId === levelId);
+    const lines = walls.flatMap((wall) => {
+        const points = sampleWallPointsForRoomDetection(wall);
+        return points.slice(1).map((end, i) => [points[i], end]);
+    });
+    const patches = [];
+    const next = { ...nodes };
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'separator' || node.parentId !== levelId)
+            continue;
+        const [x, y] = node.start, dx = node.end[0] - x, dy = node.end[1] - y;
+        const length = Math.hypot(dx, dy);
+        if (length < 1e-7)
+            continue;
+        let ranges = [[0, 1]];
+        for (const [a, b] of lines) {
+            if ([a, b].some((p) => Math.abs((p.x - x) * dy - (p.y - y) * dx) / length > 1e-6))
+                continue;
+            const ts = [a, b].map((p) => ((p.x - x) * dx + (p.y - y) * dy) / (length * length));
+            const lo = Math.min(...ts), hi = Math.max(...ts);
+            ranges = ranges.flatMap(([start, end]) => {
+                if (hi <= start + 1e-7 || lo >= end - 1e-7)
+                    return [[start, end]];
+                return [
+                    ...(lo > start + 1e-7 ? [[start, lo]] : []),
+                    ...(hi < end - 1e-7 ? [[hi, end]] : []),
+                ];
+            });
+        }
+        if (ranges.length === 1 && ranges[0][0] === 0 && ranges[0][1] === 1)
+            continue;
+        if (!ranges.length) {
+            delete next[node.id];
+            patches.push({ op: 'delete', id: node.id });
+        }
+        for (const [i, [a, b]] of ranges.entries()) {
+            const separator = omitUndefined(SeparatorNode.parse({
+                ...node,
+                id: i ? mintId() : node.id,
+                start: [x + dx * a, y + dy * a],
+                end: [x + dx * b, y + dy * b],
+            }));
+            next[separator.id] = separator;
+            patches.push(i
+                ? { op: 'create', node: separator }
+                : { op: 'update', id: node.id, data: { start: separator.start, end: separator.end } });
+        }
+    }
+    if (patches.length) {
+        const level = next[levelId];
+        if (level?.type === 'level') {
+            const children = [
+                ...level.children.filter((id) => !!next[id]),
+                ...patches.flatMap((p) => p.op === 'create' && p.node.type === 'separator' ? [p.node.id] : []),
+            ];
+            next[levelId] = { ...level, children };
+            patches.push({ op: 'update', id: level.id, data: { children } });
+        }
+    }
+    return { nodes: patches.length ? next : nodes, patches };
+}

package/dist/lib/angle-accumulator.d.ts

@@ -0,0 +1,3 @@
+/** Unwrap consecutive pointer bearings into a continuous gesture angle. */
+export declare function createAngleAccumulator(initialAngle: number): (angle: number) => number;
+//# sourceMappingURL=angle-accumulator.d.ts.map

package/dist/lib/angle-accumulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angle-accumulator.d.ts","sourceRoot":"","sources":["../../src/lib/angle-accumulator.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,IAGjD,OAAO,MAAM,YAOtB"}

package/dist/lib/angle-accumulator.js

@@ -0,0 +1,13 @@
+/** Unwrap consecutive pointer bearings into a continuous gesture angle. */
+export function createAngleAccumulator(initialAngle) {
+    let previous = initialAngle;
+    let total = 0;
+    return (angle) => {
+        if (!Number.isFinite(angle))
+            return total;
+        const change = angle - previous;
+        total += Math.atan2(Math.sin(change), Math.cos(change));
+        previous = angle;
+        return total;
+    };
+}

package/dist/lib/artifact-store.d.ts

@@ -0,0 +1,31 @@
+import type { GeometryArtifactMetadata } from '../schema/geometry-metadata.js';
+/**
+ * Content-addressed geometry artifacts. Nodes reference an artifact as
+ * `artifact://<sha256>` and never by URL, so where the bytes live is the
+ * host's choice: the hosted app stores them per project behind an access
+ * check; the default keeps them in memory for the session.
+ */
+export declare const ARTIFACT_URL_PREFIX = "artifact://";
+export type ArtifactStore = {
+    /** A loadable URL for a stored artifact, or null when this store does not have it. */
+    url: (sha256: string) => string | null;
+    /** Stores bytes and returns their stored hash, which may change if the host compresses them. */
+    put: (sha256: string, bytes: ArrayBuffer | Uint8Array, mimeType: string, context?: {
+        nodeId: string;
+        metadata: GeometryArtifactMetadata;
+    }) => Promise<string>;
+    /** A stored text artifact (an authored object's script), or null when it is missing or unreadable here. */
+    text: (sha256: string) => Promise<string | null>;
+    /**
+     * Brings artifacts another project holds into this store's project (a paste
+     * from that project), under the reader's access there. Resolves to the
+     * hashes it could not bring. Absent where artifacts are not kept per project.
+     */
+    copyFrom?: (projectId: string, sha256s: string[]) => Promise<string[]>;
+};
+export declare function configureArtifactStore(next: ArtifactStore | null): void;
+export declare function getArtifactStore(): ArtifactStore;
+export declare const artifactUrl: (sha256: string) => string;
+export declare function artifactHash(url: string): string | null;
+export declare function resolveArtifactUrl(url: string): string | null;
+//# sourceMappingURL=artifact-store.d.ts.map

package/dist/lib/artifact-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-store.d.ts","sourceRoot":"","sources":["../../src/lib/artifact-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAA;AAE3E;;;;;GAKG;AAEH,eAAO,MAAM,mBAAmB,gBAAgB,CAAA;AAEhD,MAAM,MAAM,aAAa,GAAG;IAC1B,sFAAsF;IACtF,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IACtC,gGAAgG;IAChG,GAAG,EAAE,CACH,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,WAAW,GAAG,UAAU,EAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,wBAAwB,CAAA;KAAE,KAC7D,OAAO,CAAC,MAAM,CAAC,CAAA;IACpB,2GAA2G;IAC3G,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAChD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;CACvE,CAAA;AAsBD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,IAAI,CAEvE;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAED,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,WAAsC,CAAA;AAEhF,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIvD;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG7D"}

package/dist/lib/artifact-store.js

@@ -0,0 +1,42 @@
+/**
+ * Content-addressed geometry artifacts. Nodes reference an artifact as
+ * `artifact://<sha256>` and never by URL, so where the bytes live is the
+ * host's choice: the hosted app stores them per project behind an access
+ * check; the default keeps them in memory for the session.
+ */
+export const ARTIFACT_URL_PREFIX = 'artifact://';
+const memory = new Map();
+const memoryStore = {
+    url: (sha256) => memory.get(sha256)?.url ?? null,
+    put: async (sha256, bytes, mimeType) => {
+        if (memory.has(sha256))
+            return sha256;
+        memory.set(sha256, {
+            url: URL.createObjectURL(new Blob([bytes], { type: mimeType })),
+            bytes,
+        });
+        return sha256;
+    },
+    text: async (sha256) => {
+        const stored = memory.get(sha256);
+        return stored ? new TextDecoder().decode(stored.bytes) : null;
+    },
+};
+let store = memoryStore;
+export function configureArtifactStore(next) {
+    store = next ?? memoryStore;
+}
+export function getArtifactStore() {
+    return store;
+}
+export const artifactUrl = (sha256) => `${ARTIFACT_URL_PREFIX}${sha256}`;
+export function artifactHash(url) {
+    if (!url.startsWith(ARTIFACT_URL_PREFIX))
+        return null;
+    const sha = url.slice(ARTIFACT_URL_PREFIX.length);
+    return /^[0-9a-f]{64}$/.test(sha) ? sha : null;
+}
+export function resolveArtifactUrl(url) {
+    const sha = artifactHash(url);
+    return sha ? store.url(sha) : null;
+}

package/dist/lib/assembly-stack.d.ts

@@ -0,0 +1,54 @@
+import { type Assembly, type LayerRole } from '../schema/assembly.js';
+export type AssemblyDiagnosticCode = 
+/**
+ * The host's stored thickness is not the sum of its layers (a stale or
+ * hand-edited value). The stack wins; hosts that draw from the stored
+ * thickness keep their plain body until a writer re-derives it.
+ */
+'assembly.thickness-mismatch'
+/** Nothing to stack: body and backing both sum to 0. */
+ | 'assembly.empty'
+/** `backing` on a host that refuses it: ignored. */
+ | 'assembly.backing-refused';
+export type AssemblyDiagnostic = {
+    code: AssemblyDiagnosticCode;
+    message: string;
+};
+export type ResolvedAssemblyLayer = {
+    id: string;
+    role: LayerRole;
+    /** Depth of the layer's reference-side face below the stack's first face, metres. */
+    depth: number;
+    thickness: number;
+    core: boolean;
+    material?: string;
+    slot?: string;
+    src?: string;
+    /** Backing only: as declared (`inset`, `bottom`, `lift`). */
+    inset?: number;
+    bottom?: number;
+    lift?: number;
+};
+export type ResolvedAssembly = {
+    layers: ResolvedAssemblyLayer[];
+    /** Σ layer thickness: the host's body, which a wall stores as `thickness`. */
+    total: number;
+    /**
+     * Backing layers on a host that accepts them, `depth` measured from the
+     * body's far face outward; empty otherwise.
+     */
+    backing: ResolvedAssemblyLayer[];
+    diagnostics: AssemblyDiagnostic[];
+};
+/**
+ * Resolves the body stack of `assembly`, in the order it lists its layers.
+ * The stack sets the body, so `total` is the thickness the host must store;
+ * `host.body` is the value it stores today (`null` when it stores none, as a
+ * roof) and only produces a diagnostic when it disagrees. Pure and total: it
+ * never throws and never changes a declared thickness.
+ */
+export declare function resolveAssemblyStack(assembly: Assembly, host: {
+    body: number | null;
+    backing?: boolean;
+}): ResolvedAssembly;
+//# sourceMappingURL=assembly-stack.d.ts.map

package/dist/lib/assembly-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembly-stack.d.ts","sourceRoot":"","sources":["../../src/lib/assembly-stack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAEtF,MAAM,MAAM,sBAAsB;AAChC;;;;GAIG;AACD,6BAA6B;AAC/B,wDAAwD;GACtD,gBAAgB;AAClB,oDAAoD;GAClD,0BAA0B,CAAA;AAE9B,MAAM,MAAM,kBAAkB,GAAG;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAElF,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,SAAS,CAAA;IACf,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,qBAAqB,EAAE,CAAA;IAC/B,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAA;IACb;;;OAGG;IACH,OAAO,EAAE,qBAAqB,EAAE,CAAA;IAChC,WAAW,EAAE,kBAAkB,EAAE,CAAA;CAClC,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAC/C,gBAAgB,CAyBlB"}

package/dist/lib/assembly-stack.js

@@ -0,0 +1,52 @@
+import { ASSEMBLY_TOLERANCE } from '../schema/assembly.js';
+/**
+ * Resolves the body stack of `assembly`, in the order it lists its layers.
+ * The stack sets the body, so `total` is the thickness the host must store;
+ * `host.body` is the value it stores today (`null` when it stores none, as a
+ * roof) and only produces a diagnostic when it disagrees. Pure and total: it
+ * never throws and never changes a declared thickness.
+ */
+export function resolveAssemblyStack(assembly, host) {
+    const diagnostics = [];
+    if (assembly.backing?.length && !host.backing) {
+        diagnostics.push({
+            code: 'assembly.backing-refused',
+            message: 'This host has no backing; its backing layers are ignored.',
+        });
+    }
+    const layers = stackLayers(assembly.layers);
+    const total = layers.reduce((sum, layer) => sum + layer.thickness, 0);
+    const backing = host.backing ? stackLayers(assembly.backing ?? []) : [];
+    const backingTotal = backing.reduce((sum, layer) => sum + layer.thickness, 0);
+    if (!(total > 0) && !(backingTotal > 0)) {
+        diagnostics.push({ code: 'assembly.empty', message: 'The layers sum to 0.' });
+        return { layers: [], total: 0, backing: [], diagnostics };
+    }
+    if (host.body !== null && Math.abs(host.body - total) > ASSEMBLY_TOLERANCE) {
+        diagnostics.push({
+            code: 'assembly.thickness-mismatch',
+            message: `The layers sum to ${total} m but the host stores ${host.body} m.`,
+        });
+    }
+    return { layers, total, backing, diagnostics };
+}
+function stackLayers(layers) {
+    let depth = 0;
+    return layers.map((layer) => {
+        const resolved = {
+            id: layer.id,
+            role: layer.role,
+            depth,
+            thickness: layer.thickness,
+            core: layer.core === true,
+            ...(layer.material === undefined ? {} : { material: layer.material }),
+            ...(layer.slot === undefined ? {} : { slot: layer.slot }),
+            ...(layer.src === undefined ? {} : { src: layer.src }),
+            ...(layer.inset === undefined ? {} : { inset: layer.inset }),
+            ...(layer.bottom === undefined ? {} : { bottom: layer.bottom }),
+            ...(layer.lift === undefined ? {} : { lift: layer.lift }),
+        };
+        depth += layer.thickness;
+        return resolved;
+    });
+}

package/dist/lib/asset-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asset-storage.d.ts","sourceRoot":"","sources":["../../src/lib/asset-storage.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,gBAAgB,CAAA;AAQzC;;GAEG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAI3D;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkCtE"}
+{"version":3,"file":"asset-storage.d.ts","sourceRoot":"","sources":["../../src/lib/asset-storage.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,gBAAgB,CAAA;AAQzC;;GAEG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAI3D;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAoCtE"}

package/dist/lib/asset-storage.js

@@ -1,5 +1,6 @@
 import { get, set } from 'idb-keyval';
 import { customAlphabet } from 'nanoid';
+import { ARTIFACT_URL_PREFIX, resolveArtifactUrl } from './artifact-store.js';
 export const ASSET_PREFIX = 'asset_data:';
 // Cache for active object URLs to prevent leaks and flickering
 const urlCache = new Map();
@@ -24,6 +25,8 @@ export async function loadAssetUrl(url) {
     if (url.startsWith('blob:') || url.startsWith('http')) {
         return url;
     }
+    if (url.startsWith(ARTIFACT_URL_PREFIX))
+        return resolveArtifactUrl(url);
     // Handle our custom asset protocol
     if (url.startsWith('asset://')) {
         const id = url.replace('asset://', '');

package/dist/lib/canonical-opening-ring.d.ts

@@ -0,0 +1,3 @@
+import type { Ring } from './polygon-boolean.js';
+export declare function canonicalOpeningRing(polygon: Ring): Ring;
+//# sourceMappingURL=canonical-opening-ring.d.ts.map

package/dist/lib/canonical-opening-ring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-opening-ring.d.ts","sourceRoot":"","sources":["../../src/lib/canonical-opening-ring.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAE7C,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,CAkBxD"}

package/dist/lib/canonical-opening-ring.js

@@ -0,0 +1,14 @@
+export function canonicalOpeningRing(polygon) {
+    const ring = polygon.map(([x, z]) => [
+        Math.round(x * 10_000) / 10_000,
+        Math.round(z * 10_000) / 10_000,
+    ]);
+    if (ring.length > 1 &&
+        ring[0][0] === ring[ring.length - 1][0] &&
+        ring[0][1] === ring[ring.length - 1][1])
+        ring.pop();
+    if (ring.length < 3)
+        return ring;
+    const rotations = [ring, [...ring].reverse()].flatMap((points) => points.map((_, index) => [...points.slice(index), ...points.slice(0, index)]));
+    return rotations.sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)))[0];
+}

package/dist/lib/ceiling-children.d.ts

@@ -0,0 +1,8 @@
+import type { AnyNodeId, CeilingNode as CeilingNodeType } from '../schema/index.js';
+import { type Ring } from './polygon-boolean.js';
+import { type Point2D } from './room-graph.js';
+export declare function partitionCeilingChildren(ceiling: CeilingNodeType, roomIndices: number[], detected: Array<{
+    poly: Point2D[];
+    holes: Ring[];
+}>, fallbackRoomIndex: number | undefined, childPosition: (childId: AnyNodeId) => [number, number] | undefined): Map<number, (`item_${string}` | `procedural-item_${string}`)[]>;
+//# sourceMappingURL=ceiling-children.d.ts.map

package/dist/lib/ceiling-children.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceiling-children.d.ts","sourceRoot":"","sources":["../../src/lib/ceiling-children.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,WAAW,CAAA;AAC1E,OAAO,EAAqC,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAChF,OAAO,EAAE,KAAK,OAAO,EAAgC,MAAM,cAAc,CAAA;AAEzE,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,MAAM,EAAE,EACrB,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAAC,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAAC,EACnD,iBAAiB,EAAE,MAAM,GAAG,SAAS,EACrC,aAAa,EAAE,CAAC,OAAO,EAAE,SAAS,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,mEA0CpE"}

package/dist/lib/ceiling-children.js

@@ -0,0 +1,36 @@
+import { containsPoint, distanceToBoundary } from './polygon-boolean.js';
+import { pointFromTuple, pointToTuple } from './room-graph.js';
+export function partitionCeilingChildren(ceiling, roomIndices, detected, fallbackRoomIndex, childPosition) {
+    const assignments = new Map();
+    for (const roomIndex of roomIndices)
+        assignments.set(roomIndex, []);
+    for (const childId of ceiling.children) {
+        const tuple = childPosition?.(childId);
+        const point = tuple ? pointFromTuple(tuple) : undefined;
+        const boundaryRoomIndices = point
+            ? roomIndices.filter((roomIndex) => {
+                const room = detected[roomIndex];
+                return room
+                    ? distanceToBoundary([{ outer: room.poly.map(pointToTuple), holes: room.holes }], pointToTuple(point)) <= 1e-7
+                    : false;
+            })
+            : [];
+        const interiorRoomIndex = point && boundaryRoomIndices.length === 0
+            ? roomIndices.find((roomIndex) => {
+                const room = detected[roomIndex];
+                return room
+                    ? containsPoint([{ outer: room.poly.map(pointToTuple), holes: room.holes }], pointToTuple(point))
+                    : false;
+            })
+            : undefined;
+        const roomIndex = interiorRoomIndex ??
+            (fallbackRoomIndex !== undefined && boundaryRoomIndices.includes(fallbackRoomIndex)
+                ? fallbackRoomIndex
+                : boundaryRoomIndices[0]) ??
+            fallbackRoomIndex ??
+            roomIndices[0];
+        if (roomIndex !== undefined)
+            assignments.get(roomIndex)?.push(childId);
+    }
+    return assignments;
+}

package/dist/lib/ceiling-surface.d.ts

@@ -0,0 +1,40 @@
+import type { AnyNode, CeilingNode } from '../schema/index.js';
+import type { SurfacePaintRegion } from '../schema/nodes/surface-paint-region.js';
+import { type MultiPolygon } from './polygon-boolean.js';
+/**
+ * Who paints which part of a ceiling's underside. A ceiling draws its own
+ * finish (`slots.surface`) except where a paint region covers it; regions later
+ * in the list win. An automatic ceiling is rebuilt from its room, so the room
+ * holds its regions (`zone.ceiling.regions`); a manual ceiling holds its own
+ * (`ceiling.regions`). Pure 2D in level XZ — the renderer triangulates the
+ * cells, the paint path reads the roles.
+ */
+export declare const CEILING_SURFACE_ROLE = "surface";
+export declare function ceilingRegionRole(regionId: string): string;
+export declare function parseCeilingRegionRole(role: string): string | null;
+/** Whether a ceiling's regions live on its room (an automatic ceiling) rather than on itself. */
+export declare function ceilingRegionsOwner(ceiling: Pick<CeilingNode, 'id' | 'boundary' | 'zoneId'>): {
+    kind: 'zone';
+    id: string;
+} | {
+    kind: 'ceiling';
+    id: string;
+};
+/** The paint regions a ceiling draws: its room's for an automatic ceiling, its own otherwise. */
+export declare function ceilingPaintRegions(ceiling: Pick<CeilingNode, 'id' | 'boundary' | 'zoneId' | 'regions'>, nodes: Readonly<Record<string, AnyNode | undefined>>): readonly SurfacePaintRegion[];
+export type CeilingSurfaceCell = {
+    /** `surface` (the ceiling's own finish) or `region:<id>`. */
+    role: string;
+    /** The region's finish; absent for the ceiling's own `surface`. */
+    finish?: SurfacePaintRegion['finish'];
+    polygons: MultiPolygon;
+};
+/**
+ * Disjoint cells covering the ceiling (outline minus `holes`): each region
+ * takes what the later ones left, and `surface` is the rest. Regions that miss
+ * the ceiling produce no cell.
+ */
+export declare function computeCeilingSurfaceCells(outline: readonly [number, number][], holes: readonly (readonly [number, number][])[], regions: readonly SurfacePaintRegion[]): CeilingSurfaceCell[];
+/** What the partition of one ceiling depends on — its outline, holes and regions. */
+export declare function ceilingSurfaceSignature(ceiling: Pick<CeilingNode, 'polygon' | 'holes'>, regions: readonly SurfacePaintRegion[]): string;
+//# sourceMappingURL=ceiling-surface.d.ts.map

package/dist/lib/ceiling-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceiling-surface.d.ts","sourceRoot":"","sources":["../../src/lib/ceiling-surface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAA;AAC9E,OAAO,EAIL,KAAK,YAAY,EAGlB,MAAM,mBAAmB,CAAA;AAE1B;;;;;;;GAOG;AAEH,eAAO,MAAM,oBAAoB,YAAY,CAAA;AAG7C,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIlE;AAED,iGAAiG;AACjG,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,UAAU,GAAG,QAAQ,CAAC,GACvD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAIhE;AAED,iGAAiG;AACjG,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC,EACpE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,GACnD,SAAS,kBAAkB,EAAE,CAK/B;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,MAAM,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAA;IACrC,QAAQ,EAAE,YAAY,CAAA;CACvB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EACpC,KAAK,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,EAC/C,OAAO,EAAE,SAAS,kBAAkB,EAAE,GACrC,kBAAkB,EAAE,CAoBtB;AAED,qFAAqF;AACrF,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,SAAS,GAAG,OAAO,CAAC,EAC/C,OAAO,EAAE,SAAS,kBAAkB,EAAE,GACrC,MAAM,CAER"}

package/dist/lib/ceiling-surface.js

@@ -0,0 +1,65 @@
+import { area, difference, intersection, union, } from './polygon-boolean.js';
+/**
+ * Who paints which part of a ceiling's underside. A ceiling draws its own
+ * finish (`slots.surface`) except where a paint region covers it; regions later
+ * in the list win. An automatic ceiling is rebuilt from its room, so the room
+ * holds its regions (`zone.ceiling.regions`); a manual ceiling holds its own
+ * (`ceiling.regions`). Pure 2D in level XZ — the renderer triangulates the
+ * cells, the paint path reads the roles.
+ */
+export const CEILING_SURFACE_ROLE = 'surface';
+const MIN_CELL_AREA = 1e-6;
+export function ceilingRegionRole(regionId) {
+    return `region:${regionId}`;
+}
+export function parseCeilingRegionRole(role) {
+    return role.startsWith('region:') && role.length > 'region:'.length
+        ? role.slice('region:'.length)
+        : null;
+}
+/** Whether a ceiling's regions live on its room (an automatic ceiling) rather than on itself. */
+export function ceilingRegionsOwner(ceiling) {
+    return ceiling.boundary === 'auto' && ceiling.zoneId
+        ? { kind: 'zone', id: ceiling.zoneId }
+        : { kind: 'ceiling', id: ceiling.id };
+}
+/** The paint regions a ceiling draws: its room's for an automatic ceiling, its own otherwise. */
+export function ceilingPaintRegions(ceiling, nodes) {
+    const owner = ceilingRegionsOwner(ceiling);
+    if (owner.kind === 'ceiling')
+        return ceiling.regions ?? [];
+    const zone = nodes[owner.id];
+    return zone?.type === 'zone' ? (zone.ceiling?.regions ?? []) : [];
+}
+/**
+ * Disjoint cells covering the ceiling (outline minus `holes`): each region
+ * takes what the later ones left, and `surface` is the rest. Regions that miss
+ * the ceiling produce no cell.
+ */
+export function computeCeilingSurfaceCells(outline, holes, regions) {
+    const surface = [
+        {
+            outer: outline.map(([x, z]) => [x, z]),
+            holes: holes.map((hole) => [...hole]),
+        },
+    ];
+    let remaining = holes.length ? union([surface]) : surface;
+    const cells = [];
+    for (let index = regions.length - 1; index >= 0; index -= 1) {
+        const region = regions[index];
+        if (region.polygon.length < 3 || !remaining.length)
+            continue;
+        const part = intersection(union([region.polygon]), remaining);
+        if (area(part) < MIN_CELL_AREA)
+            continue;
+        cells.push({ role: ceilingRegionRole(region.id), finish: region.finish, polygons: part });
+        remaining = difference(remaining, part);
+    }
+    if (area(remaining) >= MIN_CELL_AREA)
+        cells.push({ role: CEILING_SURFACE_ROLE, polygons: remaining });
+    return cells.reverse();
+}
+/** What the partition of one ceiling depends on — its outline, holes and regions. */
+export function ceilingSurfaceSignature(ceiling, regions) {
+    return JSON.stringify([ceiling.polygon, ceiling.holes ?? [], regions]);
+}

package/dist/lib/cutter-host.d.ts

@@ -0,0 +1,5 @@
+import type { AnyNode } from '../schema/index.js';
+export declare function isCutterName(name: string): boolean;
+/** A cutter can only remove its object's host, never an overlapping neighbour. */
+export declare function resolveCutterHost(node: AnyNode, name: string, nodes: Readonly<Record<string, AnyNode>>): AnyNode | undefined;
+//# sourceMappingURL=cutter-host.d.ts.map

package/dist/lib/cutter-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cutter-host.d.ts","sourceRoot":"","sources":["../../src/lib/cutter-host.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAY,MAAM,WAAW,CAAA;AAMlD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,OAAO,GAAG,SAAS,CAyBrB"}

package/dist/lib/cutter-host.js

@@ -0,0 +1,30 @@
+import { getScaledDimensions } from '../schema/nodes/item.js';
+import { liftedManualSlab } from './floor-construction-lift.js';
+import { selectSlabSupportForItem } from './item-slab-support.js';
+import { getRenderableSlabPolygon, slabPolygonContextForLevel } from './slab-polygon.js';
+export function isCutterName(name) {
+    return name === 'cutout' || name === 'cut:wall' || name === 'cut:ceiling' || name === 'cut:slab';
+}
+/** A cutter can only remove its object's host, never an overlapping neighbour. */
+export function resolveCutterHost(node, name, nodes) {
+    if (!isCutterName(name))
+        return;
+    const parentId = node.parentId ?? ('wallId' in node ? node.wallId : undefined);
+    const parent = parentId ? nodes[parentId] : undefined;
+    let host;
+    if (parent?.type === 'wall' || parent?.type === 'ceiling' || parent?.type === 'slab') {
+        host = parent;
+    }
+    else if (node.type === 'item' && !node.asset.attachTo && parent?.type === 'level') {
+        if (node.supportSlabId === 'ground')
+            return;
+        const context = slabPolygonContextForLevel(parent, (id) => nodes[id]);
+        const slabs = Object.values(nodes)
+            .filter((candidate) => candidate.type === 'slab' && candidate.parentId === parent.id)
+            .map((slab) => liftedManualSlab(nodes, slab));
+        host = selectSlabSupportForItem(slabs, { position: node.position, dimensions: getScaledDimensions(node), rotation: node.rotation }, (slab) => getRenderableSlabPolygon(slab, context), { preferredSlabId: node.supportSlabId });
+    }
+    if (name !== 'cutout' && host?.type !== name.slice(4))
+        return;
+    return host;
+}

package/dist/lib/floor-construction-lift.d.ts

@@ -0,0 +1,4 @@
+import type { AnyNode, SlabNode } from '../schema/index.js';
+export declare function floorConstructionLift(nodes: Readonly<Record<string, AnyNode>>, node: AnyNode): number;
+export declare function liftedManualSlab(nodes: Readonly<Record<string, AnyNode>>, slab: SlabNode): SlabNode;
+//# sourceMappingURL=floor-construction-lift.d.ts.map

package/dist/lib/floor-construction-lift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-construction-lift.d.ts","sourceRoot":"","sources":["../../src/lib/floor-construction-lift.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAWlD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,IAAI,EAAE,OAAO,GACZ,MAAM,CAyCR;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,IAAI,EAAE,QAAQ,GACb,QAAQ,CAIV"}

package/dist/lib/floor-construction-lift.js

@@ -0,0 +1,54 @@
+import { sampleFenceCenterline } from '../systems/fence/fence-centerline.js';
+import { getWallCurveFrameAt } from '../systems/wall/wall-curve.js';
+import { footprintLift } from './floor-foundation-datum.js';
+import { area, containsPoint, distanceToBoundary, intersection } from './polygon-boolean.js';
+const memo = new WeakMap();
+// Construction wholly inside a footprint keeps its authored ground-relative
+// height. Deriving this translation avoids feeding lifted decks or ground-pinned
+// walls back into the automatic datum that defines the footprint's lift.
+export function floorConstructionLift(nodes, node) {
+    let cache = memo.get(nodes);
+    if (!cache) {
+        cache = new WeakMap();
+        memo.set(nodes, cache);
+    }
+    const hit = cache.get(node);
+    if (hit !== undefined)
+        return hit;
+    let lift = 0;
+    for (const base of Object.values(nodes)) {
+        if (base.type !== 'slab' ||
+            base.plateRole !== 'base' ||
+            base.floorHeight === undefined ||
+            base.parentId !== node.parentId)
+            continue;
+        const polygon = [{ outer: base.polygon, holes: [] }];
+        const inside = (point) => containsPoint(polygon, point) || distanceToBoundary(polygon, point) < 1e-6;
+        let covered = false;
+        if (node.type === 'slab')
+            covered =
+                area(intersection(polygon, node.polygon)) >=
+                    area([{ outer: node.polygon, holes: [] }]) - 1e-6;
+        else if (node.type === 'wall')
+            covered = Array.from({ length: node.curveOffset ? 33 : 3 }, (_, i) => {
+                const p = getWallCurveFrameAt(node, i / (node.curveOffset ? 32 : 2)).point;
+                return inside([p.x, p.y]);
+            }).every(Boolean);
+        else if (node.type === 'fence')
+            covered = sampleFenceCenterline(node, 64).every((point) => inside([point.x, point.y]));
+        else if ('position' in node && Array.isArray(node.position))
+            covered = inside([node.position[0], node.position[2]]);
+        if (covered) {
+            lift = footprintLift(nodes, base);
+            break;
+        }
+    }
+    cache.set(node, lift);
+    return lift;
+}
+export function liftedManualSlab(nodes, slab) {
+    if (slab.plateRole || slab.autoFromWalls || slab.boundary === 'auto')
+        return slab;
+    const lift = floorConstructionLift(nodes, slab);
+    return lift ? { ...slab, elevation: slab.elevation + lift } : slab;
+}

package/dist/lib/floor-footprint-key.d.ts

@@ -0,0 +1,3 @@
+export declare function mintFloorFootprintKey(creatorId?: string): string;
+export declare function floorFootprintCreatorId(key: string): string | undefined;
+//# sourceMappingURL=floor-footprint-key.d.ts.map

package/dist/lib/floor-footprint-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-footprint-key.d.ts","sourceRoot":"","sources":["../../src/lib/floor-footprint-key.ts"],"names":[],"mappings":"AAEA,wBAAgB,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAIhE;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEvE"}

package/dist/lib/floor-footprint-key.js

@@ -0,0 +1,9 @@
+import { generateId } from '../schema/base.js';
+export function mintFloorFootprintKey(creatorId) {
+    // A room can create another floor while other rooms still use its previous key.
+    const key = generateId('floor');
+    return creatorId ? `${key}:${creatorId}` : key;
+}
+export function floorFootprintCreatorId(key) {
+    return /^floor_[^:]+:(zone_.+)$/.exec(key)?.[1];
+}