@pascal-app/core 1.0.3 → 1.0.5

package/dist/commands/structure/set-floor-foundation.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import type { StructureNodes, StructurePlan } from './shared.js';
+export declare const FloorFoundationPatch: z.ZodObject<{
+    thickness: z.ZodOptional<z.ZodNumber>;
+    foundationHeight: z.ZodOptional<z.ZodNumber>;
+    floorHeight: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    foundation: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            none: "none";
+            solid: "solid";
+        }>;
+        material: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
+                brick: "brick";
+                concrete: "concrete";
+                custom: "custom";
+                glass: "glass";
+                marble: "marble";
+                metal: "metal";
+                plaster: "plaster";
+                tile: "tile";
+                white: "white";
+                wood: "wood";
+            }>>>;
+            properties: z.ZodOptional<z.ZodObject<{
+                color: z.ZodDefault<z.ZodString>;
+                roughness: z.ZodDefault<z.ZodNumber>;
+                metalness: z.ZodDefault<z.ZodNumber>;
+                opacity: z.ZodDefault<z.ZodNumber>;
+                transparent: z.ZodDefault<z.ZodBoolean>;
+                side: z.ZodDefault<z.ZodEnum<{
+                    back: "back";
+                    double: "double";
+                    front: "front";
+                }>>;
+            }, z.core.$strip>>;
+            texture: z.ZodOptional<z.ZodObject<{
+                url: z.ZodString;
+                repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                scale: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>;
+    slots: z.ZodOptional<z.ZodObject<{
+        edge: z.ZodOptional<z.ZodString>;
+        riser: z.ZodOptional<z.ZodString>;
+        underside: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FloorFoundationPatch = z.infer<typeof FloorFoundationPatch>;
+/** A new solid foundation's finish: mid grey, apart from the white edge band and the walls. */
+export declare const DEFAULT_FOUNDATION_MATERIAL = "library:preset-midgrey";
+/** A footprint switched to "Raised on a foundation" without a height starts this high. */
+export declare const DEFAULT_FOUNDATION_HEIGHT = 0.3;
+export declare function setFloorFoundation(nodes: StructureNodes, input: {
+    slabId?: string;
+    slabIds?: string[];
+    patch: FloorFoundationPatch;
+    sameConstruction?: boolean;
+}): StructurePlan;
+//# sourceMappingURL=set-floor-foundation.d.ts.map

package/dist/commands/structure/set-floor-foundation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-floor-foundation.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-floor-foundation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiC/B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE,+FAA+F;AAC/F,eAAO,MAAM,2BAA2B,2BAA2B,CAAA;AAEnE,0FAA0F;AAC1F,eAAO,MAAM,yBAAyB,MAAM,CAAA;AAoD5C,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,KAAK,EAAE,oBAAoB,CAAA;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,GACA,aAAa,CA2Ff"}

package/dist/commands/structure/set-floor-foundation.js

@@ -0,0 +1,162 @@
+import { z } from 'zod';
+import { floorPlateHoldsUnderside, groundFloorConstruction, supportDerivedFloorHeight, upperFloorHeightControl, } from '../../lib/floor-foundation-datum.js';
+import { expandFloorIntentChanges, floorIntentConflicts } from '../../lib/floor-intent-changes.js';
+import { roundFloorElevation } from '../../lib/room-floor-feasibility.js';
+import { SlabNode } from '../../schema/index.js';
+import { MIN_GROUND_FLOOR_THICKNESS, MIN_SLAB_THICKNESS } from '../../schema/nodes/slab.js';
+export const FloorFoundationPatch = z.strictObject({
+    thickness: z
+        .number()
+        .finite()
+        .min(0)
+        .optional()
+        .describe('Slab thickness in meters. On the ground it sits on the foundation (or the ground) and grows upward: a thicker slab raises the floor top and everything on it. Never below 0.01 m (smaller values are clamped). Upstairs the underside stays on the walls below.'),
+    foundationHeight: z
+        .number()
+        .finite()
+        .min(0)
+        .optional()
+        .describe('Ground-bearing floors only: height of the foundation under the slab, in meters. 0 = on the ground (no foundation); > 0 = raised on a solid foundation. The floor top is derived: grade + foundationHeight + thickness.'),
+    floorHeight: z
+        .number()
+        .finite()
+        .nullable()
+        .optional()
+        .describe('Legacy: a target floor top in level-local meters. On the ground it is mapped to foundationHeight = top - grade - thickness (never below 0); null = on the ground. Prefer thickness and foundationHeight.'),
+    foundation: SlabNode.shape.foundation,
+    slots: z
+        .strictObject({
+        edge: z.string().optional(),
+        riser: z.string().optional(),
+        underside: z.string().optional(),
+    })
+        .optional(),
+});
+/** A new solid foundation's finish: mid grey, apart from the white edge band and the walls. */
+export const DEFAULT_FOUNDATION_MATERIAL = 'library:preset-midgrey';
+/** A footprint switched to "Raised on a foundation" without a height starts this high. */
+export const DEFAULT_FOUNDATION_HEIGHT = 0.3;
+/** Foundations this low count as on the ground. */
+const ON_GROUND = 0.0005;
+const touchesGroundConstruction = (patch) => patch.thickness !== undefined ||
+    patch.foundationHeight !== undefined ||
+    Object.hasOwn(patch, 'floorHeight') ||
+    patch.foundation !== undefined;
+/**
+ * A ground-bearing plate's write, bottom up: the foundation stands on the
+ * grade, the slab on the foundation, so the top is always
+ * grade + foundationHeight + thickness and nothing floats or sinks. The top is
+ * written explicitly, so a plate that followed the automatic top keeps its
+ * underside on the foundation when its thickness changes.
+ */
+function groundPatch(nodes, plate, patch) {
+    const { floorHeight, foundationHeight: requestedHeight, ...rest } = patch;
+    if (!touchesGroundConstruction(patch))
+        return rest;
+    const current = groundFloorConstruction(nodes, plate);
+    const thickness = roundFloorElevation(Math.max(MIN_GROUND_FLOOR_THICKNESS, patch.thickness ?? plate.thickness));
+    const requested = requestedHeight ??
+        (Object.hasOwn(patch, 'floorHeight')
+            ? floorHeight == null
+                ? 0
+                : floorHeight - current.grade - thickness
+            : patch.foundation?.type === 'none'
+                ? 0
+                : patch.foundation?.type === 'solid' && current.foundationHeight <= ON_GROUND
+                    ? DEFAULT_FOUNDATION_HEIGHT
+                    : current.foundationHeight);
+    const foundationHeight = roundFloorElevation(Math.max(0, requested));
+    const solid = foundationHeight > ON_GROUND;
+    const foundation = { ...plate.foundation, ...patch.foundation, type: solid ? 'solid' : 'none' };
+    if (solid && !foundation.material)
+        foundation.material = DEFAULT_FOUNDATION_MATERIAL;
+    return {
+        ...rest,
+        thickness,
+        floorHeight: roundFloorElevation(current.grade + (solid ? foundationHeight : 0) + thickness),
+        foundation: foundation,
+    };
+}
+export function setFloorFoundation(nodes, input) {
+    if (!!input.slabId === !!input.slabIds?.length)
+        throw new Error('Supply slabId or a non-empty slabIds array.');
+    const plates = [...new Set(input.slabIds ?? [input.slabId])].map((id) => {
+        const plate = nodes[id];
+        if (plate?.type !== 'slab' || plate.plateRole !== 'base')
+            throw new Error(`Base plate not found: ${id}`);
+        return plate;
+    });
+    const requested = FloorFoundationPatch.parse(input.patch);
+    const primary = plates[0];
+    const topOf = (plate) => plate.floorHeight ?? plate.elevation;
+    const primarySupported = floorPlateHoldsUnderside(nodes, primary);
+    if (primarySupported && (requested.foundationHeight ?? 0) > ON_GROUND)
+        return {
+            changes: [],
+            conflicts: [
+                {
+                    code: 'floor-foundation-level',
+                    nodeIds: [primary.id],
+                    message: 'Only a plate at ground contact can have a solid foundation.',
+                },
+            ],
+        };
+    // How far the primary plate's top moves: every other plate of a group moves by as much.
+    const delta = primarySupported
+        ? Object.hasOwn(requested, 'floorHeight')
+            ? (requested.floorHeight ?? supportDerivedFloorHeight(nodes, primary)) - topOf(primary)
+            : requested.thickness === undefined
+                ? undefined
+                : requested.thickness - primary.thickness
+        : touchesGroundConstruction(requested)
+            ? groundPatch(nodes, primary, requested).floorHeight - topOf(primary)
+            : undefined;
+    const thin = plates.find((plate) => floorPlateHoldsUnderside(nodes, plate) &&
+        delta !== undefined &&
+        plate.thickness + delta < MIN_SLAB_THICKNESS - 1e-6);
+    if (thin)
+        return {
+            changes: [],
+            conflicts: [
+                {
+                    code: 'floor-plate-thickness',
+                    nodeIds: [thin.id],
+                    message: `The floor plate ${thin.id} cannot move that far: its thickness must remain at least ${MIN_SLAB_THICKNESS} m.`,
+                },
+            ],
+        };
+    const { floorHeight: _top, foundationHeight: _foundation, ...upperRequested } = requested;
+    const changes = plates.map((plate, index) => {
+        const supported = floorPlateHoldsUnderside(nodes, plate);
+        const own = index === 0 || input.sameConstruction;
+        let data;
+        if (supported) {
+            const patch = own ? { ...upperRequested } : {};
+            if (delta !== undefined)
+                patch.thickness = upperFloorHeightControl(nodes, plate, roundFloorElevation(topOf(plate) + delta)).write.thickness;
+            data = patch;
+        }
+        else
+            data = own
+                ? groundPatch(nodes, plate, requested)
+                : delta === undefined
+                    ? {}
+                    : groundPatch(nodes, plate, {
+                        foundationHeight: Math.max(0, groundFloorConstruction(nodes, plate).foundationHeight + delta),
+                    });
+        return {
+            id: plate.id,
+            data: {
+                ...data,
+                ...(data.foundation ? { foundation: { ...plate.foundation, ...data.foundation } } : {}),
+                ...(data.slots ? { slots: { ...plate.slots, ...data.slots } } : {}),
+            },
+        };
+    });
+    const updates = expandFloorIntentChanges(nodes, changes);
+    const conflicts = floorIntentConflicts(nodes, updates);
+    return {
+        changes: conflicts.length ? [] : updates.map((update) => ({ op: 'update', ...update })),
+        conflicts,
+    };
+}

package/dist/commands/structure/set-room-floor-construction.d.ts

@@ -0,0 +1,8 @@
+import { FloorFoundationPatch } from './set-floor-foundation.js';
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export declare function setRoomFloorConstruction(nodes: StructureNodes, input: {
+    zoneId: string;
+    slabId?: string;
+    patch: typeof FloorFoundationPatch._output;
+}): StructurePlan;
+//# sourceMappingURL=set-room-floor-construction.d.ts.map

package/dist/commands/structure/set-room-floor-construction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-room-floor-construction.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-room-floor-construction.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAsB,MAAM,wBAAwB,CAAA;AACjF,OAAO,EAAyB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAEzF,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,oBAAoB,CAAC,OAAO,CAAA;CAAE,GACrF,aAAa,CAkFf"}

package/dist/commands/structure/set-room-floor-construction.js

@@ -0,0 +1,72 @@
+import { roomDrawnFloor } from '../../lib/room-drawn-floor.js';
+import { MIN_SLAB_THICKNESS } from '../../schema/nodes/slab.js';
+import { FloorFoundationPatch, setFloorFoundation } from './set-floor-foundation.js';
+import { conflict, requireZone } from './shared.js';
+export function setRoomFloorConstruction(nodes, input) {
+    const zone = requireZone(nodes, input.zoneId);
+    // A drawn-slab floor is edited on the slab the room visibly stands on.
+    const drawn = roomDrawnFloor(nodes, zone.id);
+    const options = Object.values(nodes).filter((node) => node.type === 'slab' &&
+        node.parentId === zone.parentId &&
+        (node.id === zone.floor?.sourceSlabId ||
+            node.id === drawn?.slabId ||
+            (node.plateRole === 'base' && (node.zoneIds ?? []).includes(zone.id))));
+    const selected = input.slabId
+        ? options.find((plate) => plate.id === input.slabId)
+        : (options.find((plate) => plate.id === (drawn?.slabId ?? zone.floor?.sourceSlabId)) ??
+            (options.length === 1 ? options[0] : undefined));
+    if (!selected)
+        return conflict('room-floor-owner', [zone.id, ...options.map((plate) => plate.id)], options.length
+            ? `This room spans more than one floor construction. Choose slabId from: ${options.map((plate) => plate.id).join(', ')}.`
+            : 'This room has no associated floor construction.');
+    const patch = FloorFoundationPatch.parse(input.patch);
+    if (selected.plateRole === 'base') {
+        const key = zone.floor?.footprint;
+        if (!key)
+            return setFloorFoundation(nodes, { slabId: selected.id, patch });
+        const plates = Object.values(nodes).filter((node) => node.type === 'slab' &&
+            node.parentId === zone.parentId &&
+            node.plateRole === 'base' &&
+            !!node.zoneIds?.some((id) => {
+                const room = nodes[id];
+                return room?.type === 'zone' && room.floor?.footprint === key;
+            }));
+        return setFloorFoundation(nodes, {
+            slabIds: [
+                selected.id,
+                ...plates.filter((plate) => plate.id !== selected.id).map((plate) => plate.id),
+            ],
+            patch,
+            sameConstruction: true,
+        });
+    }
+    if (patch.foundation !== undefined ||
+        patch.foundationHeight !== undefined ||
+        patch.floorHeight === null)
+        return conflict('room-authored-floor-construction', [zone.id, selected.id], 'An authored slab has no foundation or automatic height to restore. Supply a numeric floorHeight to move its top, or edit thickness and finishes.');
+    const elevation = patch.floorHeight === undefined ? undefined : patch.floorHeight;
+    return {
+        changes: [
+            {
+                op: 'update',
+                id: selected.id,
+                data: {
+                    ...(elevation === undefined ? {} : { elevation }),
+                    ...(patch.thickness === undefined
+                        ? {}
+                        : { thickness: Math.max(MIN_SLAB_THICKNESS, patch.thickness) }),
+                    ...(patch.slots === undefined ? {} : { slots: { ...selected.slots, ...patch.slots } }),
+                },
+            },
+            ...(elevation !== undefined && zone.floor?.elevation !== undefined
+                ? [
+                    {
+                        op: 'update',
+                        id: zone.id,
+                        data: { floor: { ...zone.floor, elevation } },
+                    },
+                ]
+                : []),
+        ],
+    };
+}

package/dist/commands/structure/set-wall-geometry.d.ts

@@ -0,0 +1,10 @@
+import { type Point, type StructureMintId, type StructureNodes, type StructurePlan } from './shared.js';
+export declare function setWallGeometry(nodes: StructureNodes, input: {
+    wallId: string;
+    start?: Point;
+    end?: Point;
+    thickness?: number;
+    justification?: 'a' | 'b' | null;
+    mintId: StructureMintId;
+}): StructurePlan;
+//# sourceMappingURL=set-wall-geometry.d.ts.map

package/dist/commands/structure/set-wall-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-wall-geometry.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-wall-geometry.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAEjB,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,GAAG,CAAC,EAAE,KAAK,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,aAAa,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAA;IAChC,MAAM,EAAE,eAAe,CAAA;CACxB,GACA,aAAa,CA6Df"}

package/dist/commands/structure/set-wall-geometry.js

@@ -0,0 +1,52 @@
+import { WallNode } from '../../schema/index.js';
+import { planWallJustification } from '../../systems/wall/wall-frame.js';
+import { getPlannedLinkedWallUpdates, planWallMoveJunctions } from '../../systems/wall/wall-move.js';
+import { applyToScratch, conflict, diffStructure, } from './shared.js';
+export function setWallGeometry(nodes, input) {
+    const original = nodes[input.wallId];
+    if (original?.type !== 'wall')
+        throw Error('Select a wall.');
+    let scratch = { ...nodes };
+    if (input.justification !== undefined)
+        scratch = applyToScratch(scratch, {
+            create: [],
+            delete: [],
+            update: planWallJustification(nodes, original.id, input.justification ?? undefined),
+        });
+    const wall = scratch[original.id];
+    const start = input.start ?? wall.start, end = input.end ?? wall.end;
+    const next = WallNode.parse({
+        ...wall,
+        start,
+        end,
+        ...(input.thickness !== undefined ? { thickness: input.thickness } : {}),
+    });
+    if (!([...start, ...end].every(Number.isFinite) &&
+        Math.hypot(end[0] - start[0], end[1] - start[1]) >= 0.05 &&
+        (next.thickness ?? 0.1) > 0))
+        throw Error('Invalid wall geometry.');
+    if (input.start || input.end) {
+        const linked = Object.values(scratch).filter((n) => n.type === 'wall' && n.parentId === wall.parentId && n.id !== wall.id);
+        const plan = planWallMoveJunctions(linked, wall.start, wall.end, start, end);
+        const consumed = plan.wallsToDelete.map((n) => n.id);
+        const hosted = Object.values(scratch).filter((n) => consumed.includes(n.parentId));
+        if (hosted.length)
+            return conflict('hosted-openings', hosted.map((n) => n.id), 'Moving this junction would remove a wall with hosted objects.');
+        scratch = applyToScratch(scratch, {
+            update: getPlannedLinkedWallUpdates(plan, wall.start, wall.end, start, end).map(({ id, ...data }) => ({ id, data })),
+            delete: consumed,
+            create: plan.bridgePlans.map((bridge) => ({
+                node: WallNode.parse({
+                    ...bridge.wall,
+                    id: input.mintId('wall'),
+                    children: [],
+                    start: bridge.originalPoint,
+                    end: bridge.movedEndpoint === 'start' ? start : end,
+                }),
+                parentId: wall.parentId,
+            })),
+        });
+    }
+    scratch[wall.id] = next;
+    return { changes: diffStructure(nodes, scratch) };
+}

package/dist/commands/structure/set-zone-edges.d.ts

@@ -0,0 +1,14 @@
+import { type WallNode } from '../../schema/index.js';
+import { type MezzanineEdgeInput } from './resize-mezzanine.js';
+import { type SpanRef, type StructureMintId, type StructureNodes, type StructurePlan } from './shared.js';
+export declare function setZoneEdges(nodes: StructureNodes, input: MezzanineEdgeInput | {
+    zoneId: string;
+    edges: Array<{
+        spanRef: SpanRef;
+        kind: 'wall' | 'separator';
+        wall?: Pick<Partial<WallNode>, 'thickness' | 'height' | 'justification'>;
+    }>;
+    dropOpenings?: boolean;
+    mintId: StructureMintId;
+}): StructurePlan;
+//# sourceMappingURL=set-zone-edges.d.ts.map

package/dist/commands/structure/set-zone-edges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-zone-edges.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-zone-edges.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAA;AAI3E,OAAO,EAAE,KAAK,kBAAkB,EAAmB,MAAM,oBAAoB,CAAA;AAC7E,OAAO,EAOL,KAAK,OAAO,EACZ,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EAEnB,MAAM,UAAU,CAAA;AAEjB,wBAAgB,YAAY,CAC1B,KAAK,EAAE,cAAc,EACrB,KAAK,EACD,kBAAkB,GAClB;IACE,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,KAAK,CAAC;QACX,OAAO,EAAE,OAAO,CAAA;QAChB,IAAI,EAAE,MAAM,GAAG,WAAW,CAAA;QAC1B,IAAI,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,eAAe,CAAC,CAAA;KACzE,CAAC,CAAA;IACF,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,MAAM,EAAE,eAAe,CAAA;CACxB,GACJ,aAAa,CAiKf"}

package/dist/commands/structure/set-zone-edges.js

@@ -0,0 +1,143 @@
+import { sampleWallPointsForRoomDetection } from '../../lib/room-graph.js';
+import { SeparatorNode } from '../../schema/index.js';
+import { getWallCurveLength } from '../../systems/wall/wall-curve.js';
+import { planWallDivision } from '../../systems/wall/wall-operations.js';
+import { planWallInsertion } from '../../systems/wall/wall-topology.js';
+import { resizeMezzanine } from './resize-mezzanine.js';
+import { applyToScratch, at, conflict, diffStructure, requireZone, roomFace, sharedSpan, } from './shared.js';
+export function setZoneEdges(nodes, input) {
+    if ('edgeIndex' in input)
+        return resizeMezzanine(nodes, input);
+    const zone = requireZone(nodes, input.zoneId);
+    if (zone.floor?.support === 'open')
+        return conflict('invalid-edge', [zone.id], 'Use edgeIndex and distance to push a mezzanine edge.');
+    const face = roomFace(nodes, zone);
+    let scratch = { ...nodes };
+    const edges = [...input.edges].sort((a, b) => a.spanRef.boundaryId.localeCompare(b.spanRef.boundaryId) || b.spanRef.t0 - a.spanRef.t0);
+    for (let i = 1; i < edges.length; i++) {
+        const left = edges[i - 1].spanRef, right = edges[i].spanRef;
+        if (left.boundaryId === right.boundaryId && right.t1 > left.t0 + 1e-6)
+            return conflict('overlapping-spans', [left.boundaryId], 'Boundary edits must not overlap.');
+    }
+    for (const edge of edges) {
+        const span = edge.spanRef;
+        if (!face?.spans.some((s) => s.boundaryId === span.boundaryId &&
+            s.face === span.face &&
+            span.t0 >= s.t0 - 1e-6 &&
+            span.t1 <= s.t1 + 1e-6 &&
+            span.t1 > span.t0))
+            return conflict('invalid-span', [span.boundaryId], 'The span is not on this room boundary.');
+        const boundary = scratch[span.boundaryId];
+        if (boundary?.type !== 'wall' && boundary?.type !== 'separator')
+            return conflict('stale-span', [span.boundaryId], 'Replan against the current boundary.');
+        if (boundary.type === edge.kind)
+            continue;
+        const original = nodes[span.boundaryId];
+        if (original?.type !== 'wall' && original?.type !== 'separator')
+            throw Error('Missing boundary.');
+        const originalLength = original.type === 'wall'
+            ? getWallCurveLength(original)
+            : Math.hypot(original.end[0] - original.start[0], original.end[1] - original.start[1]);
+        const currentLength = boundary.type === 'wall'
+            ? getWallCurveLength(boundary)
+            : Math.hypot(boundary.end[0] - boundary.start[0], boundary.end[1] - boundary.start[1]);
+        const t0 = (span.t0 * originalLength) / currentLength, t1 = (span.t1 * originalLength) / currentLength;
+        if (boundary.type === 'separator') {
+            const start = at(boundary.start, boundary.end, t0), end = at(boundary.start, boundary.end, t1);
+            const inserted = planWallInsertion(scratch, {
+                levelId: zone.parentId,
+                start,
+                end,
+                joinRadius: 0.001,
+                wallDefaults: edge.wall,
+                mintId: () => input.mintId('wall'),
+            });
+            if (!inserted.ok)
+                return conflict(inserted.reason, [boundary.id], 'Cannot replace this separator with a wall.');
+            scratch = applyToScratch(scratch, inserted.plan.changes);
+            delete scratch[boundary.id];
+            for (const [from, to] of [
+                [0, t0],
+                [t1, 1],
+            ])
+                if (to - from > 1e-6) {
+                    const remainder = SeparatorNode.parse({
+                        ...boundary,
+                        id: from === 0 ? boundary.id : input.mintId('separator'),
+                        start: at(boundary.start, boundary.end, from),
+                        end: at(boundary.start, boundary.end, to),
+                    });
+                    scratch[remainder.id] = remainder;
+                }
+        }
+        else {
+            if (sharedSpan(nodes, zone, span))
+                continue;
+            const length = getWallCurveLength(boundary);
+            const attachments = Object.values(scratch).filter((n) => n.parentId === boundary.id || ('wallId' in n && n.wallId === boundary.id));
+            const removed = attachments.filter((n) => 'position' in n &&
+                Array.isArray(n.position) &&
+                n.position[0] +
+                    ('width' in n && typeof n.width === 'number'
+                        ? n.width / 2
+                        : n.type === 'item'
+                            ? (n.asset.dimensions[0] * n.scale[0]) / 2
+                            : 0) >=
+                    t0 * length &&
+                n.position[0] -
+                    ('width' in n && typeof n.width === 'number'
+                        ? n.width / 2
+                        : n.type === 'item'
+                            ? (n.asset.dimensions[0] * n.scale[0]) / 2
+                            : 0) <=
+                    t1 * length);
+            if (removed.length && !input.dropOpenings)
+                return conflict('hosted-openings', removed.map((n) => n.id), 'Removing this wall also removes its hosted openings and objects. Pass dropOpenings to confirm.');
+            const removedIds = new Set(removed.map((n) => n.id));
+            let found = true;
+            while (found) {
+                found = false;
+                for (const n of Object.values(scratch))
+                    if (n.parentId && removedIds.has(n.parentId) && !removedIds.has(n.id)) {
+                        removedIds.add(n.id);
+                        found = true;
+                    }
+            }
+            for (const id of removedIds)
+                delete scratch[id];
+            scratch[boundary.id] = {
+                ...boundary,
+                children: boundary.children.filter((id) => !removed.some((n) => n.id === id)),
+            };
+            let targetId = boundary.id;
+            try {
+                for (const t of [t1, t0])
+                    if (t > 1e-6 && t < 1 - 1e-6) {
+                        const division = planWallDivision(scratch, boundary.id, t * length, () => input.mintId('wall'));
+                        scratch = applyToScratch(scratch, division.changes);
+                        if (t === t0)
+                            targetId = division.changes.create[0].node.id;
+                    }
+            }
+            catch (error) {
+                return conflict('occupied-split', [boundary.id], String(error));
+            }
+            const target = scratch[targetId];
+            if (target?.type !== 'wall')
+                return conflict('invalid-span', [boundary.id], 'Could not isolate the wall span.');
+            delete scratch[target.id];
+            const points = sampleWallPointsForRoomDetection(target);
+            for (let i = 1; i < points.length; i++) {
+                const start = points[i - 1], end = points[i];
+                const separator = SeparatorNode.parse({
+                    id: input.mintId('separator'),
+                    parentId: zone.parentId,
+                    start: [start.x, start.y],
+                    end: [end.x, end.y],
+                });
+                scratch[separator.id] = separator;
+            }
+        }
+    }
+    return { changes: diffStructure(nodes, scratch) };
+}

package/dist/commands/structure/set-zone-intent.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export declare const ZoneIntentPatch: z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    floor: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        footprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        thickness: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        elevation: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        finish: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
+        regions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            finish: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strict>>>;
+    ceiling: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        regions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            finish: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strict>>>;
+    floorStepFinish: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    floorStepOverrides: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        step: z.ZodOptional<z.ZodNumber>;
+        finish: z.ZodString;
+    }, z.core.$strip>>>>;
+    floorEdgeFinish: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    wallMaterial: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    hasFloor: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    hasCeiling: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    daylight: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        artificialLight: z.ZodBoolean;
+        mechanicalVentilation: z.ZodBoolean;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ZoneIntentPatch = z.infer<typeof ZoneIntentPatch>;
+export declare function setZoneIntent(nodes: StructureNodes, input: {
+    zoneId: string;
+    patch: ZoneIntentPatch;
+}): StructurePlan;
+//# sourceMappingURL=set-zone-intent.d.ts.map

package/dist/commands/structure/set-zone-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-zone-intent.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-zone-intent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,OAAO,EAAe,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAI/E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+B1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D,wBAAgB,aAAa,CAC3B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,eAAe,CAAA;CAAE,GAChD,aAAa,CAkGf"}