@pascal-app/core 1.0.1 → 1.0.4

package/dist/building/window-types.d.ts

@@ -0,0 +1,17 @@
+import type { WindowNode } from '../schema/index.js';
+import type { WindowType } from '../schema/nodes/opening-types.js';
+/** The window types whose top takes a shape (rounded, arch); the others are rectangular. */
+export declare const SHAPED_WINDOW_TYPES: ReadonlySet<WindowType>;
+/** The window types that project from the wall and have no sill. */
+export declare const SILLLESS_WINDOW_TYPES: ReadonlySet<WindowType>;
+/** A style shapes a Fixed window's panes; every other type draws its own sashes and ignores them. */
+export declare function windowTakesStyle(type: WindowType): boolean;
+/** What a window type writes, for the window panel's Type row and add_window alike. */
+export declare function windowTypeFields(type: WindowType): Partial<WindowNode>;
+/**
+ * What changing `window`'s type writes, for the window panel's Type row: the type's own fields, and
+ * the sill back when the window leaves Bay or Bow, which have none. A sill the person turned off on
+ * any other type stays off.
+ */
+export declare function windowTypeChange(window: Pick<WindowNode, 'windowType'>, type: WindowType): Partial<WindowNode>;
+//# sourceMappingURL=window-types.d.ts.map

package/dist/building/window-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-types.d.ts","sourceRoot":"","sources":["../../src/building/window-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAE/D,4FAA4F;AAC5F,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,UAAU,CAMtD,CAAA;AAEF,oEAAoE;AACpE,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,UAAU,CAA2B,CAAA;AAErF,qGAAqG;AACrG,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE1D;AAED,uFAAuF;AACvF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAMtE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,EACtC,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAIrB"}

package/dist/building/window-types.js

@@ -0,0 +1,31 @@
+/** The window types whose top takes a shape (rounded, arch); the others are rectangular. */
+export const SHAPED_WINDOW_TYPES = new Set([
+    'fixed',
+    'casement',
+    'awning',
+    'hopper',
+    'louvered',
+]);
+/** The window types that project from the wall and have no sill. */
+export const SILLLESS_WINDOW_TYPES = new Set(['bay', 'bow']);
+/** A style shapes a Fixed window's panes; every other type draws its own sashes and ignores them. */
+export function windowTakesStyle(type) {
+    return type === 'fixed';
+}
+/** What a window type writes, for the window panel's Type row and add_window alike. */
+export function windowTypeFields(type) {
+    return {
+        windowType: type,
+        ...(SHAPED_WINDOW_TYPES.has(type) ? {} : { openingShape: 'rectangle' }),
+        ...(SILLLESS_WINDOW_TYPES.has(type) ? { sill: false } : {}),
+    };
+}
+/**
+ * What changing `window`'s type writes, for the window panel's Type row: the type's own fields, and
+ * the sill back when the window leaves Bay or Bow, which have none. A sill the person turned off on
+ * any other type stays off.
+ */
+export function windowTypeChange(window, type) {
+    const leavesSillless = SILLLESS_WINDOW_TYPES.has(window.windowType) && !SILLLESS_WINDOW_TYPES.has(type);
+    return { ...windowTypeFields(type), ...(leavesSillless ? { sill: true } : {}) };
+}

package/dist/commands/structure/apply-zone-transform.d.ts

@@ -0,0 +1,23 @@
+import { type NodeChange, type StructureNodes, type StructurePlan } from './shared.js';
+export type CeilingHostAssignment = {
+    nodeId: string;
+    zoneId: string;
+    offsetY: number;
+};
+export type SupportHostAssignment = {
+    nodeId: string;
+    zoneId: string;
+    field: 'supportSlabId' | 'deckSlabId';
+};
+export type HostedZoneTransformPlan = StructurePlan & {
+    ceilingHosts?: CeilingHostAssignment[];
+    supportHosts?: SupportHostAssignment[];
+};
+export declare function resolveZoneTransformHosts(nodes: StructureNodes, plan: HostedZoneTransformPlan): NodeChange[];
+export declare function applyZoneTransformPlan(plan: HostedZoneTransformPlan, runtime?: {
+    getNodes: () => StructureNodes;
+    applyChanges: (changes: NodeChange[]) => void;
+    reconcile: () => void;
+    runAsSingleHistoryStep?: (run: () => void) => void;
+}): void;
+//# sourceMappingURL=apply-zone-transform.d.ts.map

package/dist/commands/structure/apply-zone-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-zone-transform.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/apply-zone-transform.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,aAAa,EAEnB,MAAM,UAAU,CAAA;AAEjB,MAAM,MAAM,qBAAqB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AACvF,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,eAAe,GAAG,YAAY,CAAA;CACtC,CAAA;AACD,MAAM,MAAM,uBAAuB,GAAG,aAAa,GAAG;IACpD,YAAY,CAAC,EAAE,qBAAqB,EAAE,CAAA;IACtC,YAAY,CAAC,EAAE,qBAAqB,EAAE,CAAA;CACvC,CAAA;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,uBAAuB,GAC5B,UAAU,EAAE,CAoCd;AAID,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,uBAAuB,EAC7B,OAAO,GAAE;IACP,QAAQ,EAAE,MAAM,cAAc,CAAA;IAC9B,YAAY,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,CAAA;IAC7C,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,sBAAsB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;CAMnD,QAcF"}

package/dist/commands/structure/apply-zone-transform.js

@@ -0,0 +1,55 @@
+import { containsPoint } from '../../lib/polygon-boolean.js';
+import { roomFloorPlate } from '../../lib/room-floor-plate.js';
+import { runAsSingleSceneHistoryStep } from '../../store/history-control.js';
+import useScene from '../../store/use-scene.js';
+import { structureChangeBatch, } from './shared.js';
+export function resolveZoneTransformHosts(nodes, plan) {
+    const changes = (plan.ceilingHosts ?? []).map(({ nodeId, zoneId, offsetY }) => {
+        const node = nodes[nodeId];
+        const rooms = Object.values(nodes).filter((candidate) => candidate.type === 'zone' &&
+            node &&
+            'position' in node &&
+            Array.isArray(node.position) &&
+            candidate.parentId === node.parentId &&
+            containsPoint([{ outer: candidate.polygon, holes: candidate.holes }], [node.position[0], node.position[2]]));
+        const room = rooms.find((room) => room.id === zoneId) ?? rooms[0];
+        const ceiling = Object.values(nodes).find((candidate) => candidate.type === 'ceiling' && candidate.zoneId === (room?.id ?? zoneId));
+        if (!node || !ceiling || !('position' in node) || !Array.isArray(node.position))
+            throw Error(`Reconcile the copied room before assigning ceiling fixture ${nodeId}.`);
+        return {
+            op: 'update',
+            id: node.id,
+            data: { parentId: ceiling.id, position: [node.position[0], offsetY, node.position[2]] },
+        };
+    });
+    for (const { nodeId, zoneId, field } of plan.supportHosts ?? []) {
+        const plate = roomFloorPlate(Object.values(nodes).filter((node) => node.type === 'slab'), zoneId);
+        if (plate && nodes[nodeId])
+            changes.push({ op: 'update', id: nodes[nodeId].id, data: { [field]: plate.id } });
+    }
+    return changes;
+}
+// The store's synchronous subscriber (or a headless caller's reconcile callback)
+// must create the ceiling before its copied fixtures can name that host.
+export function applyZoneTransformPlan(plan, runtime = {
+    getNodes: () => useScene.getState().nodes,
+    applyChanges: (changes) => useScene.getState().applyNodeChanges(structureChangeBatch(changes)),
+    reconcile: () => { },
+    runAsSingleHistoryStep: (run) => runAsSingleSceneHistoryStep(useScene, run),
+}) {
+    if (!plan.changes.length)
+        return;
+    const apply = () => {
+        runtime.applyChanges(plan.changes);
+        runtime.reconcile();
+        const hosts = resolveZoneTransformHosts(runtime.getNodes(), plan);
+        if (hosts.length) {
+            runtime.applyChanges(hosts);
+            runtime.reconcile();
+        }
+    };
+    if (runtime.runAsSingleHistoryStep)
+        runtime.runAsSingleHistoryStep(apply);
+    else
+        apply();
+}

package/dist/commands/structure/create-mezzanine.d.ts

@@ -0,0 +1,12 @@
+import { type Point, type StructureMintId, type StructureNodes, type StructurePlan } from './shared.js';
+export type CreateMezzanineInput = {
+    hostZoneId: string;
+    polygon: Point[];
+    elevation?: number;
+    thickness?: number;
+    mintId: StructureMintId;
+};
+export declare function createMezzanine(nodes: StructureNodes, input: CreateMezzanineInput): StructurePlan & {
+    zoneId: string;
+};
+//# sourceMappingURL=create-mezzanine.d.ts.map

package/dist/commands/structure/create-mezzanine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-mezzanine.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/create-mezzanine.ts"],"names":[],"mappings":"AAOA,OAAO,EAEL,KAAK,KAAK,EAEV,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAIjB,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,KAAK,EAAE,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,eAAe,CAAA;CACxB,CAAA;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,oBAAoB,GAC1B,aAAa,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CA4CpC"}

package/dist/commands/structure/create-mezzanine.js

@@ -0,0 +1,46 @@
+import { GROUND_SUPPORT_ID } from '../../hooks/spatial-grid/support-host-id.js';
+import { newZone } from '../../lib/new-zone.js';
+import { containsPoint } from '../../lib/polygon-boolean.js';
+import { polygonInteriorPoint } from '../../lib/polygon-label.js';
+import { getStoredLevelHeight } from '../../services/storey.js';
+import { isFloorPlacedIntent } from './mezzanine-content.js';
+import { requireZone, } from './shared.js';
+import { validateMezzanine } from './validate-mezzanine.js';
+export function createMezzanine(nodes, input) {
+    const host = requireZone(nodes, input.hostZoneId);
+    const level = host.parentId ? nodes[host.parentId] : undefined;
+    if (level?.type !== 'level' || host.floor?.support === 'open')
+        throw Error('A mezzanine needs a host room on a level.');
+    const polygon = input.polygon;
+    const zone = newZone({
+        id: input.mintId('zone'),
+        parentId: level.id,
+        name: 'Mezzanine',
+        spaceRole: 'room',
+        hostZoneId: host.id,
+        polygon,
+        seed: polygonInteriorPoint({ polygon }, true),
+        floor: {
+            support: 'open',
+            elevation: input.elevation ?? Math.round(getStoredLevelHeight(level) * 10) / 20,
+            thickness: input.thickness ?? 0.2,
+        },
+    });
+    const invalid = validateMezzanine(nodes, zone);
+    if (invalid)
+        return { zoneId: '', changes: [], conflicts: [invalid] };
+    if (nodes[zone.id])
+        throw Error(`Duplicate zone id: ${zone.id}`);
+    const hostPlates = Object.values(nodes).filter((node) => node.type === 'slab' && !!node.zoneIds?.includes(host.id));
+    hostPlates.sort((a, b) => b.elevation - a.elevation);
+    const pins = Object.values(nodes).flatMap((node) => {
+        if (!isFloorPlacedIntent(node) ||
+            node.parentId !== level.id ||
+            node.supportSlabId ||
+            !containsPoint([{ outer: polygon, holes: [] }], [node.position[0], node.position[2]]))
+            return [];
+        const plate = hostPlates.find((slab) => containsPoint([{ outer: slab.polygon, holes: slab.holes }], [node.position[0], node.position[2]]));
+        return [{ op: 'update', id: node.id, data: { supportSlabId: plate?.id ?? GROUND_SUPPORT_ID } }];
+    });
+    return { zoneId: zone.id, changes: [{ op: 'create', node: zone }, ...pins] };
+}

package/dist/commands/structure/create-zone.d.ts

@@ -0,0 +1,32 @@
+import { type WallNode } from '../../schema/index.js';
+import { type ZoneIntentPatch } from './set-zone-intent.js';
+import { type Point, type StructureMintId, type StructureNodes, type StructurePlan } from './shared.js';
+type Edge = {
+    wallId: string;
+    face: 'a' | 'b';
+    t0: number;
+    t1: number;
+} | {
+    separator: [Point, Point];
+};
+export type CreateZoneInput = {
+    levelId: string;
+    polygon?: Point[];
+    boundaryIds?: string[];
+    edges?: Edge[];
+    name?: string;
+    intent?: ZoneIntentPatch;
+    enclose?: boolean;
+    wall?: Pick<Partial<WallNode>, 'height' | 'thickness' | 'justification'>;
+    mintId: StructureMintId;
+};
+export declare function outdoorRoomConflicts(nodes: StructureNodes, levelId: string, polygon: Point[]): {
+    code: string;
+    nodeIds: `zone_${string}`[];
+    message: string;
+}[];
+export declare function createZone(nodes: StructureNodes, input: CreateZoneInput): StructurePlan & {
+    zoneId: string;
+};
+export {};
+//# sourceMappingURL=create-zone.d.ts.map

package/dist/commands/structure/create-zone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-zone.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/create-zone.ts"],"names":[],"mappings":"AAKA,OAAO,EAAiC,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAA;AAG3E,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACvE,OAAO,EAIL,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EAEnB,MAAM,UAAU,CAAA;AAEjB,KAAK,IAAI,GACL;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;CAAE,CAAA;AACjC,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,KAAK,EAAE,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,IAAI,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,WAAW,GAAG,eAAe,CAAC,CAAA;IACxE,MAAM,EAAE,eAAe,CAAA;CACxB,CAAA;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE;;;;IAiB5F;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,eAAe,GACrB,aAAa,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAiHpC"}

package/dist/commands/structure/create-zone.js

@@ -0,0 +1,126 @@
+import { newZone } from '../../lib/new-zone.js';
+import { area, intersection } from '../../lib/polygon-boolean.js';
+import { polygonInteriorPoint } from '../../lib/polygon-label.js';
+import { segmentsIntersect } from '../../lib/polygon-relations.js';
+import { extractRooms } from '../../lib/room-graph.js';
+import { SeparatorNode } from '../../schema/index.js';
+import { getWallCurveFrameAt } from '../../systems/wall/wall-curve.js';
+import { planWallInsertion, uncoveredWallSegments } from '../../systems/wall/wall-topology.js';
+import { setZoneIntent } from './set-zone-intent.js';
+import { applyToScratch, boundaries, diffStructure, structureChangeBatch, } from './shared.js';
+export function outdoorRoomConflicts(nodes, levelId, polygon) {
+    return Object.values(nodes).flatMap((node) => node.type === 'zone' &&
+        node.parentId === levelId &&
+        node.spaceRole === 'room' &&
+        node.enclosureStatus !== 'open' &&
+        node.floor?.support !== 'open' &&
+        area(intersection(polygon, { outer: node.polygon, holes: node.holes })) > 1e-6
+        ? [
+            {
+                code: 'outdoor-room-overlap',
+                nodeIds: [node.id],
+                message: `The terrace overlaps ${node.name || 'an existing room'}.`,
+            },
+        ]
+        : []);
+}
+export function createZone(nodes, input) {
+    if (nodes[input.levelId]?.type !== 'level')
+        throw Error('Select an editable floor.');
+    if ([input.polygon, input.boundaryIds, input.edges].filter(Boolean).length !== 1)
+        throw Error('Supply exactly one polygon, boundary set or edge list.');
+    let scratch = { ...nodes };
+    let polygon = input.polygon;
+    let segments = [];
+    if (input.boundaryIds) {
+        const selected = boundaries(nodes, input.levelId).filter((n) => input.boundaryIds.includes(n.id));
+        const faces = extractRooms(selected);
+        if (selected.length !== input.boundaryIds.length || faces.length !== 1)
+            throw Error('The boundary set must enclose one room.');
+        polygon = faces[0].referencePolygon;
+    }
+    else if (input.edges) {
+        const edges = input.edges.map((edge) => {
+            if ('separator' in edge) {
+                segments.push(edge.separator);
+                return edge.separator;
+            }
+            const wall = nodes[edge.wallId];
+            if (wall?.type !== 'wall' ||
+                wall.parentId !== input.levelId ||
+                !(edge.t0 >= 0 && edge.t1 <= 1 && edge.t0 < edge.t1))
+                throw Error('Invalid wall edge.');
+            const count = wall.curveOffset ? 64 : 1;
+            const points = Array.from({ length: count + 1 }, (_, i) => {
+                const t = edge.t0 + ((edge.t1 - edge.t0) * i) / count;
+                const { point } = getWallCurveFrameAt(wall, t);
+                return [point.x, point.y];
+            });
+            return edge.face === 'a' ? points : points.reverse();
+        });
+        segments.push(...edges.map((edge, i) => [edge.at(-1), edges[(i + 1) % edges.length][0]]));
+        polygon = edges.flat();
+    }
+    else if (polygon)
+        segments = polygon.map((p, i) => [p, polygon[(i + 1) % polygon.length]]);
+    polygon = polygon?.filter((point, i, points) => {
+        const next = points[(i + 1) % points.length];
+        return Math.hypot(point[0] - next[0], point[1] - next[1]) > 1e-8;
+    });
+    if (!polygon ||
+        polygon.length < 3 ||
+        !polygon.flat().every(Number.isFinite) ||
+        area([{ outer: polygon, holes: [] }]) < 0.01 ||
+        polygon.some((a, i) => polygon.some((b, j) => j > i + 1 &&
+            !(i === 0 && j === polygon.length - 1) &&
+            segmentsIntersect(a, polygon[(i + 1) % polygon.length], b, polygon[(j + 1) % polygon.length]))))
+        throw Error('A room needs a valid polygon.');
+    if (input.enclose === false) {
+        const conflicts = outdoorRoomConflicts(nodes, input.levelId, polygon);
+        if (conflicts.length)
+            return { changes: [], conflicts, zoneId: '' };
+    }
+    for (const [start, end] of segments) {
+        if (Math.hypot(end[0] - start[0], end[1] - start[1]) < 1e-8)
+            continue;
+        const walls = boundaries(scratch, input.levelId).filter((n) => n.type === 'wall');
+        for (const [a, b] of uncoveredWallSegments(start, end, walls)) {
+            if (input.enclose) {
+                const result = planWallInsertion(scratch, {
+                    levelId: input.levelId,
+                    start: a,
+                    end: b,
+                    joinRadius: 0.001,
+                    wallDefaults: input.wall,
+                    mintId: () => input.mintId('wall'),
+                });
+                if (!result.ok)
+                    throw Error(`Cannot enclose room: ${result.reason}`);
+                scratch = applyToScratch(scratch, result.plan.changes);
+            }
+            else {
+                const separator = SeparatorNode.parse({
+                    id: input.mintId('separator'),
+                    parentId: input.levelId,
+                    start: a,
+                    end: b,
+                });
+                scratch[separator.id] = separator;
+            }
+        }
+    }
+    const zone = newZone({
+        id: input.mintId('zone'),
+        parentId: input.levelId,
+        name: input.name ?? 'Room',
+        polygon,
+        seed: polygonInteriorPoint({ polygon }, true),
+        spaceRole: 'room',
+    });
+    if (scratch[zone.id])
+        throw Error(`Duplicate zone id: ${zone.id}`);
+    scratch[zone.id] = zone;
+    if (input.intent)
+        scratch = applyToScratch(scratch, structureChangeBatch(setZoneIntent(scratch, { zoneId: zone.id, patch: input.intent }).changes));
+    return { changes: diffStructure(nodes, scratch), zoneId: zone.id };
+}

package/dist/commands/structure/delete-zone.d.ts

@@ -0,0 +1,51 @@
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export type DeleteZonePayload = {
+    zoneId: string;
+    name: string;
+    contents: 'delete' | 'keep';
+    /**
+     * `delete`: the room goes with the walls, separators and openings only it
+     * uses. `merge`: an area Divide made (a separator on its outline) goes back
+     * into the room across those separators; walls and items stay. `blocked`:
+     * every boundary is a wall another room shares — nothing of its own to
+     * remove, so deleting one of those walls is the way (a conflict, no changes).
+     */
+    mode: 'delete' | 'merge' | 'blocked';
+    /** `merge`: the room the area goes back into. */
+    mergedIntoZoneId?: string;
+    opensZoneIds: string[];
+    keptSharedSeparatorIds: string[];
+    wallIds: string[];
+    keptSharedWallIds: string[];
+    separatorIds: string[];
+    openingIds: string[];
+    itemIds: string[];
+};
+export declare const SHARED_WALLS_DELETE_MESSAGE = "To remove this room, delete one of its walls.";
+type ZoneInput = {
+    zoneId: string;
+    contents: 'delete' | 'keep';
+};
+type DeleteZonePlan = StructurePlan & {
+    payload: DeleteZonePayload;
+};
+/**
+ * Deletes a room the way its boundaries allow:
+ * - an area Divide made (a separator shared with a room on its outline) merges
+ *   back into that room — the one sharing the most separator length — by
+ *   removing those separators; its intent (name, finishes, regions) goes, its
+ *   walls and items stay, and mezzanines it hosts move to the merged room;
+ * - a room whose every boundary is a wall shared with other rooms is refused
+ *   (`shared-walls`): only deleting one of those walls can remove it;
+ * - otherwise the room goes with the walls, separators and openings only it
+ *   uses, and its items per `contents`.
+ */
+export declare function deleteZone(sourceNodes: StructureNodes, input: ZoneInput): DeleteZonePlan;
+/**
+ * The room removed with the walls, separators and openings only it uses (and
+ * its items per `contents`), whatever its neighbours. Wall deletion uses this
+ * directly for the rooms it takes down.
+ */
+export declare function planZoneRemoval(sourceNodes: StructureNodes, input: ZoneInput): DeleteZonePlan;
+export {};
+//# sourceMappingURL=delete-zone.d.ts.map

package/dist/commands/structure/delete-zone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-zone.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/delete-zone.ts"],"names":[],"mappings":"AAWA,OAAO,EAOL,KAAK,cAAc,EACnB,KAAK,aAAa,EAGnB,MAAM,UAAU,CAAA;AAEjB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAA;IAC3B;;;;;;OAMG;IACH,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAA;IACpC,iDAAiD;IACjD,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,sBAAsB,EAAE,MAAM,EAAE,CAAA;IAChC,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,iBAAiB,EAAE,MAAM,EAAE,CAAA;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AA0CD,eAAO,MAAM,2BAA2B,kDAAkD,CAAA;AAE1F,KAAK,SAAS,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAA;CAAE,CAAA;AAChE,KAAK,cAAc,GAAG,aAAa,GAAG;IAAE,OAAO,EAAE,iBAAiB,CAAA;CAAE,CAAA;AAEpE;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,WAAW,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,GAAG,cAAc,CA2BxF;AAqJD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,GAAG,cAAc,CA4I7F"}