@pascal-app/core 1.0.4 → 1.0.5

package/dist/lib/exterior-wall-loops.js

@@ -0,0 +1,334 @@
+import { getWallCurveFrameAt, isCurvedWall } from '../systems/wall/wall-curve.js';
+import { dedupeSequentialPoints, pointFromTuple, pointToTuple, polygonArea, polygonSignature, sampleWallPointsForRoomDetection, } from './room-graph.js';
+import { distanceToSegment } from './room-topology-index.js';
+const WALL_JUNCTION_TOLERANCE = 0.08;
+// Endpoints closer than this are one graph node, whatever their rounding: a millimetre, as the
+// room kernel's keys (a wall posed by hand 0.65 mm short of its neighbour left the loop open).
+// A gap past it stays open, as a real opening may; a caller may join wider (`joinTolerance`).
+const WALL_ENDPOINT_TOLERANCE = 1e-3;
+function samePointWithinTolerance(a, b, tolerance = 1e-4) {
+    return Math.hypot(a.x - b.x, a.y - b.y) <= tolerance;
+}
+function pointInPolygon(point, polygon) {
+    if (polygon.length < 3)
+        return false;
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const xi = polygon[i]?.x ?? 0;
+        const yi = polygon[i]?.y ?? 0;
+        const xj = polygon[j]?.x ?? 0;
+        const yj = polygon[j]?.y ?? 0;
+        const intersect = yi > point.y !== yj > point.y &&
+            point.x < ((xj - xi) * (point.y - yi)) / (yj - yi + 1e-12) + xi;
+        if (intersect)
+            inside = !inside;
+    }
+    return inside;
+}
+function pointDistanceToPolygonBoundary(point, polygon) {
+    let minDistance = Number.POSITIVE_INFINITY;
+    for (let index = 0; index < polygon.length; index += 1) {
+        const start = polygon[index];
+        const end = polygon[(index + 1) % polygon.length];
+        if (!(start && end))
+            continue;
+        minDistance = Math.min(minDistance, distanceToSegment(pointToTuple(point), pointToTuple(start), pointToTuple(end)));
+    }
+    return minDistance;
+}
+function segmentProjection(point, start, end) {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared < 1e-12) {
+        return { t: 0, distance: Math.hypot(point.x - start.x, point.y - start.y) };
+    }
+    const t = ((point.x - start.x) * dx + (point.y - start.y) * dy) / lengthSquared;
+    const clampedT = Math.max(0, Math.min(1, t));
+    const projX = start.x + clampedT * dx;
+    const projY = start.y + clampedT * dy;
+    return { t, distance: Math.hypot(point.x - projX, point.y - projY) };
+}
+function splitStraightWallAtVertices(start, end, vertices) {
+    const length = Math.hypot(end.x - start.x, end.y - start.y);
+    if (length < 1e-9)
+        return [start, end];
+    const interior = [];
+    for (const vertex of vertices) {
+        const { t, distance } = segmentProjection(vertex, start, end);
+        if (distance > WALL_JUNCTION_TOLERANCE)
+            continue;
+        const along = t * length;
+        if (along <= WALL_JUNCTION_TOLERANCE || along >= length - WALL_JUNCTION_TOLERANCE)
+            continue;
+        interior.push({ point: vertex, t });
+    }
+    interior.sort((a, b) => a.t - b.t);
+    const ordered = [start];
+    for (const { point } of interior) {
+        if (samePointWithinTolerance(point, ordered[ordered.length - 1], WALL_ENDPOINT_TOLERANCE))
+            continue;
+        ordered.push(point);
+    }
+    if (!samePointWithinTolerance(ordered[ordered.length - 1], end, WALL_ENDPOINT_TOLERANCE))
+        ordered.push(end);
+    return ordered;
+}
+function exteriorFaces(walls, joinTolerance) {
+    if (walls.length < 3)
+        return [];
+    const graph = new Map();
+    const halfEdges = new Map();
+    const endpointBuckets = new Map();
+    const upsertNode = (point) => {
+        // Rounded coordinate strings can split coincident SVG endpoints on a cell
+        // boundary. Buckets only narrow the search; distance establishes identity.
+        const x = Math.floor(point.x / joinTolerance);
+        const y = Math.floor(point.y / joinTolerance);
+        let nearest;
+        let nearestDistance = Number.POSITIVE_INFINITY;
+        for (let dx = -1; dx <= 1; dx += 1) {
+            for (let dy = -1; dy <= 1; dy += 1) {
+                for (const key of endpointBuckets.get(`${x + dx},${y + dy}`) ?? []) {
+                    const candidate = graph.get(key).point;
+                    const distance = Math.hypot(point.x - candidate.x, point.y - candidate.y);
+                    if (distance <= joinTolerance && distance < nearestDistance) {
+                        nearest = key;
+                        nearestDistance = distance;
+                    }
+                }
+            }
+        }
+        if (nearest !== undefined)
+            return nearest;
+        const key = String(graph.size);
+        graph.set(key, { point: { ...point }, outgoing: [] });
+        const bucketKey = `${x},${y}`;
+        const bucket = endpointBuckets.get(bucketKey) ?? [];
+        bucket.push(key);
+        endpointBuckets.set(bucketKey, bucket);
+        return key;
+    };
+    // Planarize first: collect every wall endpoint as a candidate graph vertex so
+    // straight walls can be split at T-junctions where another wall ends mid-span.
+    // Without this the touching wall's endpoint is a dangling degree-1 node and the
+    // enclosed area (e.g. a room added against the middle of an existing wall)
+    // never forms a cycle.
+    for (const wall of walls) {
+        upsertNode(pointFromTuple(wall.start));
+        upsertNode(pointFromTuple(wall.end));
+    }
+    const vertices = [...graph.values()].map((node) => node.point);
+    for (const wall of walls) {
+        const start = pointFromTuple(wall.start);
+        const end = pointFromTuple(wall.end);
+        if (samePointWithinTolerance(start, end))
+            continue;
+        // Curved walls keep their sampled polyline as one edge; straight walls split
+        // into consecutive sub-edges at their interior junction vertices.
+        const subPolylines = isCurvedWall(wall)
+            ? [sampleWallPointsForRoomDetection(wall)]
+            : (() => {
+                const ordered = splitStraightWallAtVertices(start, end, vertices);
+                const parts = [];
+                for (let index = 0; index < ordered.length - 1; index += 1) {
+                    parts.push([ordered[index], ordered[index + 1]]);
+                }
+                return parts;
+            })();
+        subPolylines.forEach((points, subIndex) => {
+            const from = points[0];
+            const to = points[points.length - 1];
+            const fromKey = upsertNode(from);
+            const toKey = upsertNode(to);
+            if (fromKey === toKey)
+                return;
+            const reversePoints = [...points].reverse();
+            const forwardId = `${wall.id}#${subIndex}:f`;
+            const reverseId = `${wall.id}#${subIndex}:r`;
+            halfEdges.set(forwardId, {
+                id: forwardId,
+                reverseId,
+                fromKey,
+                toKey,
+                angle: Math.atan2(points[1].y - from.y, points[1].x - from.x),
+                points,
+                wallId: wall.id,
+                face: 'front',
+            });
+            halfEdges.set(reverseId, {
+                id: reverseId,
+                reverseId: forwardId,
+                fromKey: toKey,
+                toKey: fromKey,
+                angle: Math.atan2(reversePoints[1].y - to.y, reversePoints[1].x - to.x),
+                points: reversePoints,
+                wallId: wall.id,
+                face: 'back',
+            });
+            graph.get(fromKey)?.outgoing.push(forwardId);
+            graph.get(toKey)?.outgoing.push(reverseId);
+        });
+    }
+    const sortedOutgoing = new Map();
+    for (const [key, node] of graph.entries()) {
+        const outgoing = [...node.outgoing];
+        outgoing.sort((a, b) => (halfEdges.get(a)?.angle ?? 0) - (halfEdges.get(b)?.angle ?? 0));
+        sortedOutgoing.set(key, outgoing);
+    }
+    const nextEdge = (edgeId) => {
+        const edge = halfEdges.get(edgeId);
+        if (!edge)
+            return null;
+        const outgoing = sortedOutgoing.get(edge.toKey);
+        if (!outgoing || outgoing.length === 0)
+            return null;
+        const idx = outgoing.indexOf(edge.reverseId);
+        if (idx === -1)
+            return null;
+        const nextIdx = (idx - 1 + outgoing.length) % outgoing.length;
+        return outgoing[nextIdx] ?? null;
+    };
+    const splitIntoSimpleCycles = (walkEdgeIds) => {
+        const cycles = [];
+        const firstEdge = halfEdges.get(walkEdgeIds[0] ?? '');
+        if (!firstEdge)
+            return cycles;
+        const pathEdges = [];
+        const pathVertices = [firstEdge.fromKey];
+        const vertexIndex = new Map([[firstEdge.fromKey, 0]]);
+        for (const edgeId of walkEdgeIds) {
+            const edge = halfEdges.get(edgeId);
+            if (!edge || edge.fromKey !== pathVertices[pathVertices.length - 1])
+                return [];
+            pathEdges.push(edgeId);
+            const repeatedIndex = vertexIndex.get(edge.toKey);
+            if (repeatedIndex === undefined) {
+                pathVertices.push(edge.toKey);
+                vertexIndex.set(edge.toKey, pathVertices.length - 1);
+                continue;
+            }
+            const cycle = pathEdges.slice(repeatedIndex);
+            if (cycle.length >= 3)
+                cycles.push(cycle);
+            for (let index = repeatedIndex + 1; index < pathVertices.length; index += 1) {
+                vertexIndex.delete(pathVertices[index]);
+            }
+            pathVertices.length = repeatedIndex + 1;
+            pathEdges.length = repeatedIndex;
+        }
+        return pathEdges.length === 0 && pathVertices.length === 1 ? cycles : [];
+    };
+    const visitedDirected = new Set();
+    const rooms = [];
+    // A face walk cannot revisit a half-edge, so the half-edge count bounds its
+    // length. It can revisit a vertex when dangling walls or other graph bridges
+    // are traced out and back; those excursions are removed below.
+    const maxSteps = Math.min(2000, halfEdges.size + 10);
+    for (const edgeId of halfEdges.keys()) {
+        if (visitedDirected.has(edgeId))
+            continue;
+        const cycleEdgeIds = [];
+        let currentEdgeId = edgeId;
+        let valid = true;
+        let closed = false;
+        for (let step = 0; step < maxSteps; step += 1) {
+            const currentEdge = halfEdges.get(currentEdgeId);
+            if (!currentEdge) {
+                valid = false;
+                break;
+            }
+            visitedDirected.add(currentEdgeId);
+            cycleEdgeIds.push(currentEdgeId);
+            const next = nextEdge(currentEdgeId);
+            if (!next) {
+                valid = false;
+                break;
+            }
+            currentEdgeId = next;
+            if (currentEdgeId === edgeId) {
+                closed = true;
+                break;
+            }
+        }
+        if (!(valid && closed) || cycleEdgeIds.length < 3)
+            continue;
+        for (const simpleCycleEdgeIds of splitIntoSimpleCycles(cycleEdgeIds)) {
+            const polygon = dedupeSequentialPoints(simpleCycleEdgeIds.flatMap((id, index) => {
+                const points = halfEdges.get(id)?.points ?? [];
+                return index === simpleCycleEdgeIds.length - 1 ? points : points.slice(0, -1);
+            }));
+            if (polygon.length < 3)
+                continue;
+            const signedArea = polygonArea(polygon);
+            // Rooms wind one way; the outside of the walls is walked the other.
+            if (signedArea >= -1e-6)
+                continue;
+            const signature = polygonSignature(polygon);
+            if (rooms.some((room) => polygonSignature(room.polygon) === signature))
+                continue;
+            rooms.push({
+                polygon,
+                boundaryFaces: simpleCycleEdgeIds.flatMap((id) => {
+                    const edge = halfEdges.get(id);
+                    if (!edge)
+                        return [];
+                    return [
+                        {
+                            wallId: edge.wallId,
+                            face: edge.face,
+                            points: edge.points.map(pointToTuple),
+                        },
+                    ];
+                }),
+            });
+        }
+    }
+    rooms.sort((a, b) => Math.abs(polygonArea(b.polygon)) - Math.abs(polygonArea(a.polygon)));
+    return rooms;
+}
+/**
+ * The outside loops of a storey's walls. Wall ends within `joinTolerance` metres are one corner: a
+ * millimetre by default; a vectorised plan's near-miss corners may need a few centimetres.
+ */
+export function exteriorWallLoops(walls, joinTolerance = WALL_ENDPOINT_TOLERANCE) {
+    return outerFaces(walls, joinTolerance).map((loop) => loop.boundaryFaces);
+}
+/** The outlines of a storey's walls: each outside loop as a polygon on the walls' centrelines. */
+export function exteriorWallOutlines(walls, joinTolerance = WALL_ENDPOINT_TOLERANCE) {
+    return outerFaces(walls, joinTolerance).map((loop) => loop.polygon.map(pointToTuple));
+}
+/**
+ * The walls a closed circuit of walls encloses: not on the storey's outline and strictly inside one
+ * of its outside loops (a partition, as opposed to a wall that holds the outside back). A wall no
+ * closed circuit surrounds (an open run, the first walls of a plan, a wall drawn outside) is not
+ * enclosed.
+ */
+export function enclosedWallIds(walls, joinTolerance = WALL_ENDPOINT_TOLERANCE) {
+    const loops = outerFaces(walls, joinTolerance);
+    const enclosed = new Set();
+    if (loops.length === 0)
+        return enclosed;
+    const onOutline = new Set(loops.flatMap((loop) => loop.boundaryFaces.map((face) => face.wallId)));
+    for (const wall of walls) {
+        if (onOutline.has(wall.id))
+            continue;
+        const middle = getWallCurveFrameAt(wall, 0.5).point;
+        const point = { x: middle.x, y: middle.y };
+        if (loops.some((loop) => pointInPolygon(point, loop.polygon) &&
+            pointDistanceToPolygonBoundary(point, loop.polygon) >= 1e-4))
+            enclosed.add(wall.id);
+    }
+    return enclosed;
+}
+function outerFaces(walls, joinTolerance) {
+    const loops = exteriorFaces(walls, Math.max(WALL_ENDPOINT_TOLERANCE, joinTolerance));
+    return loops.filter((loop, index) => !loops.some((other, otherIndex) => {
+        if (otherIndex === index ||
+            Math.abs(polygonArea(other.polygon)) <= Math.abs(polygonArea(loop.polygon)))
+            return false;
+        // Use boundary points, not the centroid: concave footprints may have a centroid outside.
+        return loop.polygon.every((point) => pointInPolygon(point, other.polygon) ||
+            pointDistanceToPolygonBoundary(point, other.polygon) < 1e-4);
+    }));
+}

package/dist/lib/finish-script.d.ts

@@ -0,0 +1,61 @@
+import type { AnyNode, CompiledGeometryScript, GeometryScriptParamValue, WallFaceScript, ZoneFloorScript } from '../schema/index.js';
+import type { WallFace } from '../schema/nodes/wall.js';
+import { type FloorScriptInputs } from './floor-script.js';
+import { type WallFaceScriptInputs } from './wall-face-script.js';
+type SceneNodes = Readonly<Record<string, AnyNode>>;
+/**
+ * A finish a script builds for its host: a room's floor (`nodeId` a zone) or one face of a wall
+ * (`nodeId` a wall, with `face`).
+ */
+export type FinishScriptTarget = {
+    nodeId: string;
+    face?: WallFace;
+};
+export type FinishScriptInputs = FloorScriptInputs | WallFaceScriptInputs;
+type FinishScript = ZoneFloorScript | WallFaceScript;
+export type StaleFinishScript = FinishScriptTarget & {
+    script: FinishScript;
+    /** Its floor or face now, which the script runs again for. */
+    inputs: FinishScriptInputs;
+};
+/**
+ * The finish scripts whose floor or face is no longer the one they were built for: the structure
+ * reconcile re-derived a room (a wall moved, an edge pushed, a floor raised), or a wall changed
+ * length, height or openings, so the key differs. A host with nothing to build on now (a room with
+ * no floor, a wall turned curved) keeps its script as it was.
+ */
+export declare function staleFinishScripts(nodes: SceneNodes): StaleFinishScript[];
+/**
+ * How a host runs a finish script: reads its module back by hash, and compiles and stores it for
+ * its floor or face (`@pascal-app/geometry-script`'s `compileGeometryScript` with `inputs`, then the
+ * artifact store), answering the compile with the stored hashes.
+ */
+export type FinishScriptHost = {
+    readScript(sha256: string): Promise<string | null>;
+    build(input: FinishScriptTarget & {
+        code: string;
+        params: Record<string, GeometryScriptParamValue>;
+        inputs: FinishScriptInputs;
+    }): Promise<CompiledGeometryScript>;
+};
+export type FinishScriptRefresh = {
+    rebuilt: (FinishScriptTarget & {
+        script: FinishScript;
+    })[];
+    failed: (FinishScriptTarget & {
+        error: string;
+    })[];
+};
+/** Runs every stale finish script again for its floor or face now, with its stored params. */
+export declare function refreshFinishScripts(nodes: SceneNodes, host: FinishScriptHost): Promise<FinishScriptRefresh>;
+/**
+ * The writes that put rebuilt finish scripts on `nodes`: each only while its host still has the
+ * script and its floor or face is still the one it was rebuilt for (else a newer refresh follows),
+ * over what the host holds now, so a wall's other face and a room's other floor fields are kept.
+ */
+export declare function finishScriptWrites(nodes: SceneNodes, rebuilt: FinishScriptRefresh['rebuilt']): {
+    id: string;
+    data: Partial<AnyNode>;
+}[];
+export {};
+//# sourceMappingURL=finish-script.d.ts.map

package/dist/lib/finish-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finish-script.d.ts","sourceRoot":"","sources":["../../src/lib/finish-script.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,sBAAsB,EACtB,wBAAwB,EACxB,cAAc,EAEd,eAAe,EAChB,MAAM,WAAW,CAAA;AAClB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EACL,KAAK,iBAAiB,EAIvB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,KAAK,oBAAoB,EAI1B,MAAM,oBAAoB,CAAA;AAE3B,KAAK,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAEnD;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,QAAQ,CAAA;CAAE,CAAA;AACpE,MAAM,MAAM,kBAAkB,GAAG,iBAAiB,GAAG,oBAAoB,CAAA;AACzE,KAAK,YAAY,GAAG,eAAe,GAAG,cAAc,CAAA;AA0BpD,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,GAAG;IACnD,MAAM,EAAE,YAAY,CAAA;IACpB,8DAA8D;IAC9D,MAAM,EAAE,kBAAkB,CAAA;CAC3B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,iBAAiB,EAAE,CAOzE;AAED;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAClD,KAAK,CACH,KAAK,EAAE,kBAAkB,GAAG;QAC1B,IAAI,EAAE,MAAM,CAAA;QACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAA;QAChD,MAAM,EAAE,kBAAkB,CAAA;KAC3B,GACA,OAAO,CAAC,sBAAsB,CAAC,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,CAAC,kBAAkB,GAAG;QAAE,MAAM,EAAE,YAAY,CAAA;KAAE,CAAC,EAAE,CAAA;IAC1D,MAAM,EAAE,CAAC,kBAAkB,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,CAAA;CACnD,CAAA;AAED,8FAA8F;AAC9F,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,mBAAmB,CAAC,CA4B9B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,mBAAmB,CAAC,SAAS,CAAC,GACtC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,CAoB1C"}

package/dist/lib/finish-script.js

@@ -0,0 +1,86 @@
+import { floorScriptInputs, floorScriptInputsKey, floorScriptRecord, } from './floor-script.js';
+import { wallFaceScriptInputs, wallFaceScriptInputsKey, wallFaceScriptRecord, } from './wall-face-script.js';
+function finishScriptsOf(node) {
+    if (node.type === 'zone')
+        return node.floor?.script ? [{ nodeId: node.id, script: node.floor.script }] : [];
+    if (node.type !== 'wall')
+        return [];
+    return ['a', 'b'].flatMap((face) => {
+        const script = node.finishScripts?.[face];
+        return script ? [{ nodeId: node.id, face, script }] : [];
+    });
+}
+/** What a finish script is built for now, with its key; null when its host has nothing to build on. */
+function currentInputs(nodes, { nodeId, face }, script) {
+    if (face) {
+        const inputs = wallFaceScriptInputs(nodes, nodeId, face, script.toHeight);
+        return inputs && { inputs, key: wallFaceScriptInputsKey(inputs) };
+    }
+    const inputs = floorScriptInputs(nodes, nodeId);
+    return inputs && { inputs, key: floorScriptInputsKey(inputs) };
+}
+/**
+ * The finish scripts whose floor or face is no longer the one they were built for: the structure
+ * reconcile re-derived a room (a wall moved, an edge pushed, a floor raised), or a wall changed
+ * length, height or openings, so the key differs. A host with nothing to build on now (a room with
+ * no floor, a wall turned curved) keeps its script as it was.
+ */
+export function staleFinishScripts(nodes) {
+    return Object.values(nodes).flatMap((node) => finishScriptsOf(node).flatMap((entry) => {
+        const now = currentInputs(nodes, entry, entry.script);
+        return now && now.key !== entry.script.inputs ? [{ ...entry, inputs: now.inputs }] : [];
+    }));
+}
+/** Runs every stale finish script again for its floor or face now, with its stored params. */
+export async function refreshFinishScripts(nodes, host) {
+    const refresh = { rebuilt: [], failed: [] };
+    await Promise.all(staleFinishScripts(nodes).map(async ({ script, inputs, ...target }) => {
+        try {
+            const code = await host.readScript(script.script);
+            if (code === null)
+                throw new Error('its module could not be read');
+            const compiled = await host.build({ ...target, code, params: script.params, inputs });
+            refresh.rebuilt.push({
+                ...target,
+                script: target.face
+                    ? wallFaceScriptRecord(compiled, inputs, script.toHeight, script)
+                    : floorScriptRecord(compiled, inputs, script),
+            });
+        }
+        catch (error) {
+            refresh.failed.push({
+                ...target,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }));
+    return refresh;
+}
+/**
+ * The writes that put rebuilt finish scripts on `nodes`: each only while its host still has the
+ * script and its floor or face is still the one it was rebuilt for (else a newer refresh follows),
+ * over what the host holds now, so a wall's other face and a room's other floor fields are kept.
+ */
+export function finishScriptWrites(nodes, rebuilt) {
+    const writes = new Map();
+    for (const { script, ...target } of rebuilt) {
+        const node = nodes[target.nodeId];
+        const held = node && finishScriptsOf(node).find((entry) => entry.face === target.face);
+        if (!held || currentInputs(nodes, target, held.script)?.key !== script.inputs)
+            continue;
+        if (node.type === 'zone') {
+            writes.set(node.id, { floor: { ...node.floor, script: script } });
+        }
+        else if (node.type === 'wall' && target.face) {
+            const earlier = writes.get(node.id);
+            writes.set(node.id, {
+                finishScripts: {
+                    ...node.finishScripts,
+                    ...(earlier?.finishScripts ?? {}),
+                    [target.face]: script,
+                },
+            });
+        }
+    }
+    return [...writes].map(([id, data]) => ({ id, data }));
+}

package/dist/lib/floor-intent-changes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floor-intent-changes.d.ts","sourceRoot":"","sources":["../../src/lib/floor-intent-changes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EAOV,MAAM,WAAW,CAAA;AAuBlB,OAAO,EAGL,KAAK,iBAAiB,EAEvB,MAAM,0BAA0B,CAAA;AAEjC,KAAK,MAAM,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAkCvD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,MAAM,EAAE,CA6IV;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,OAAO,GAAE,SAAS,OAAO,EAAO,EAChC,OAAO,GAAE,SAAS,MAAM,EAAO,uBA2VhC"}
+{"version":3,"file":"floor-intent-changes.d.ts","sourceRoot":"","sources":["../../src/lib/floor-intent-changes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EAOV,MAAM,WAAW,CAAA;AAsBlB,OAAO,EAGL,KAAK,iBAAiB,EAEvB,MAAM,0BAA0B,CAAA;AAEjC,KAAK,MAAM,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAkCvD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,MAAM,EAAE,CA6IV;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,OAAO,GAAE,SAAS,OAAO,EAAO,EAChC,OAAO,GAAE,SAAS,MAAM,EAAO,uBAoVhC"}

package/dist/lib/floor-intent-changes.js

@@ -1,7 +1,6 @@
 import { boundaries, roomFace } from '../commands/structure/shared.js';
 import { DEFAULT_SLAB_ELEVATION } from '../schema/nodes/slab.js';
-import { findLevelBelowId, getLevelElevations, getWallCoveringSlabUnderside, getWallPlaneTop, } from '../services/storey.js';
-import { resolveWallTop } from '../systems/wall/wall-top.js';
+import { findLevelBelowId, getLevelElevations, getWallCoveringSlabUnderside, getWallTop, } from '../services/storey.js';
 import { automaticFloorHeight, floorPlateAtGroundContact, floorPlateHoldsUnderside, footprintSupportsNode, supportDerivedFloorHeight, } from './floor-foundation-datum.js';
 import { changedLevelConstructionDisplacements, footprintStackChanges, } from './floor-foundation-stack.js';
 import { floorRoomFaces } from './floor-room-faces.js';
@@ -422,7 +421,7 @@ export function floorIntentConflicts(nodes, updates, created = [], deleted = [])
             return (getOpeningFloorTarget(host, opening, graph) +
                 opening.position[1] +
                 opening.height / 2 -
-                resolveWallTop(host, getWallPlaneTop(host, host.parentId, graph), wallSupportForNodes(host, graph).elevation));
+                getWallTop(host, host.parentId, graph, wallSupportForNodes(host, graph).elevation));
         };
         const after = excess(draft, node);
         const previous = nodes[node.id] ?? copiedOpening(nodes, draft, node);
@@ -444,7 +443,8 @@ export function floorIntentConflicts(nodes, updates, created = [], deleted = [])
             !levels.has(node.parentId) ||
             !loweringPlates.some(({ plate }) => footprintSupportsNode(plate, node, draft)))
             continue;
-        const excess = (graph, wall) => resolveWallTop(wall, getWallPlaneTop(wall, wall.parentId, graph), wallSupportForNodes(wall, graph).elevation) - (getWallCoveringSlabUnderside(wall, wall.parentId, graph) ?? Infinity);
+        const excess = (graph, wall) => getWallTop(wall, wall.parentId, graph, wallSupportForNodes(wall, graph).elevation) -
+            (getWallCoveringSlabUnderside(wall, wall.parentId, graph) ?? Infinity);
         const after = excess(draft, node);
         const previous = nodes[node.id];
         const before = previous?.type === 'wall' ? excess(nodes, previous) : -Infinity;

package/dist/lib/floor-plate-paint.d.ts

@@ -1,8 +1,10 @@
 import type { AnyNode } from '../schema/index.js';
 export type FloorPlatePaintRefusal = {
     status: 'refused';
-    code: 'floor-surface-without-room';
+    code: 'floor-surface-without-room' | 'floor-built-by-script';
     message: string;
 };
+/** Why a room's floor cannot be painted: a script builds it, and the script owns its colours. */
+export declare function floorScriptPaintRefusal(zone: AnyNode | undefined): FloorPlatePaintRefusal | undefined;
 export declare function floorPlatePaintRefusal(nodes: Readonly<Record<string, AnyNode>>, node: AnyNode, role: string): FloorPlatePaintRefusal | undefined;
 //# sourceMappingURL=floor-plate-paint.d.ts.map

package/dist/lib/floor-plate-paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floor-plate-paint.d.ts","sourceRoot":"","sources":["../../src/lib/floor-plate-paint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAExC,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,SAAS,CAAA;IACjB,IAAI,EAAE,4BAA4B,CAAA;IAClC,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,MAAM,GACX,sBAAsB,GAAG,SAAS,CAYpC"}
+{"version":3,"file":"floor-plate-paint.d.ts","sourceRoot":"","sources":["../../src/lib/floor-plate-paint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGxC,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,SAAS,CAAA;IACjB,IAAI,EAAE,4BAA4B,GAAG,uBAAuB,CAAA;IAC5D,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,iGAAiG;AACjG,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,GAAG,SAAS,GACxB,sBAAsB,GAAG,SAAS,CAOpC;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,MAAM,GACX,sBAAsB,GAAG,SAAS,CAgBpC"}

package/dist/lib/floor-plate-paint.js

@@ -1,11 +1,31 @@
+import { parseRoomFinishRole } from './plate-surface.js';
+/** Why a room's floor cannot be painted: a script builds it, and the script owns its colours. */
+export function floorScriptPaintRefusal(zone) {
+    if (zone?.type === 'zone' && zone.floor?.script)
+        return {
+            status: 'refused',
+            code: 'floor-built-by-script',
+            message: `${zone.name?.trim() || 'This room'}'s floor is built by a script, which owns its colours. Remove the script to paint the floor.`,
+        };
+}
 export function floorPlatePaintRefusal(nodes, node, role) {
-    if (node.type === 'slab' &&
-        node.plateRole === 'base' &&
-        role === 'surface' &&
-        !node.zoneIds?.some((id) => nodes[id]?.type === 'zone' && nodes[id].hasFloor !== false))
+    if (node.type !== 'slab')
+        return;
+    const room = parseRoomFinishRole(role);
+    if (room)
+        return floorScriptPaintRefusal(nodes[room.zoneId]);
+    if (node.plateRole !== 'base' || role !== 'surface')
+        return;
+    const zones = (node.zoneIds ?? []).map((id) => nodes[id]);
+    if (!zones.some((zone) => zone?.type === 'zone' && zone.hasFloor !== false))
         return {
             status: 'refused',
             code: 'floor-surface-without-room',
             message: 'This structural floor band has no room finish to paint. Paint its edge instead.',
         };
+    for (const zone of zones) {
+        const refusal = floorScriptPaintRefusal(zone);
+        if (refusal)
+            return refusal;
+    }
 }