@pascal-app/core 1.0.3 → 1.0.5

package/dist/building/wall-openings.js

@@ -0,0 +1,259 @@
+import { refuseParamsWithoutScript } from '../agent-operations/add-object.js';
+import { refuse } from '../agent-tools/refusal.js';
+import { matchScriptSlotsToLibrary, requireMeasured, scriptedSize, scriptSource, } from '../lib/geometry-script-node.js';
+import { wallSupportForNodes } from '../lib/opening-floor-datum.js';
+import { DoorNode, getScaledDimensions, WindowNode, } from '../schema/index.js';
+import { getCurtainWallConfig } from '../schema/nodes/curtain-wall.js';
+import { getWallTop } from '../services/storey.js';
+import { resolveWallExteriorSide } from '../systems/wall/wall-assembly.js';
+import { getWallCurveLength, isCurvedWall } from '../systems/wall/wall-curve.js';
+import { doorStyleLook, getWindowStyleOverrides, } from './opening-style-presets.js';
+import { windowTakesStyle } from './window-types.js';
+/** 1 µm: below any buildable difference, above floating-point noise. */
+const TOUCHING = 1e-6;
+const lengthOf = (wall) => Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+/**
+ * Available wall-local Y span for an opening hosted on `wall`: the wall's resolved top (storey
+ * plane for plane-bound walls, stored height for explicit ones) minus the wall's elected slab
+ * base, the ceiling an opening's top edge must stay under.
+ */
+export function resolveWallOpeningCeiling(wall, nodes) {
+    const support = wallSupportForNodes(wall, nodes);
+    return (getWallTop(wall, wall.parentId ?? '', nodes, support.elevation) -
+        support.elevation);
+}
+/** A curtain wall keeps its perimeter frame clear of openings. */
+const openingMargin = (wall) => wall.wallType === 'curtain' ? getCurtainWallConfig(wall).perimeterWidth : 0;
+/** A door's centre: slid along the wall to stay on it, standing on the floor. */
+export function clampDoorToWall(wall, localX, width, height) {
+    const margin = openingMargin(wall);
+    const length = getWallCurveLength(wall);
+    const clampedX = Math.max(margin + width / 2, Math.min(length - margin - width / 2, localX));
+    return { clampedX, clampedY: height / 2 };
+}
+/** A window's centre: slid to stay on the wall, and between the floor and the wall's ceiling. */
+export function clampWindowToWall(wall, localX, localY, width, height, nodes) {
+    const ceiling = resolveWallOpeningCeiling(wall, nodes);
+    const margin = openingMargin(wall);
+    const length = getWallCurveLength(wall);
+    const clampedX = Math.max(margin + width / 2, Math.min(length - margin - width / 2, localX));
+    const clampedY = Math.max(margin + height / 2, Math.min(ceiling - margin - height / 2, localY));
+    return { clampedX, clampedY };
+}
+/**
+ * The first child of the wall (door, window, or wall-mounted item) that a rectangle centred on
+ * (`clampedX`, `clampedY`) would overlap. Items store their bottom Y; doors and windows their
+ * centre Y.
+ */
+export function findWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height, ignoreId) {
+    const wallNode = nodes[wallId];
+    if (!wallNode)
+        return null;
+    const newBottom = clampedY - height / 2;
+    const newTop = clampedY + height / 2;
+    const newLeft = clampedX - width / 2;
+    const newRight = clampedX + width / 2;
+    for (const childId of Array.isArray(wallNode.children) ? wallNode.children : []) {
+        if (typeof ignoreId === 'string' ? childId === ignoreId : ignoreId?.includes(childId))
+            continue;
+        const child = nodes[childId];
+        if (!child || child.metadata.isTransient)
+            continue;
+        let childLeft;
+        let childRight;
+        let childBottom;
+        let childTop;
+        if (child.type === 'item') {
+            const item = child;
+            if (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side')
+                continue;
+            const [w, h] = getScaledDimensions(item);
+            childLeft = item.position[0] - w / 2;
+            childRight = item.position[0] + w / 2;
+            childBottom = item.position[1];
+            childTop = item.position[1] + h;
+        }
+        else if (child.type === 'window' || child.type === 'door') {
+            const opening = child;
+            childLeft = opening.position[0] - opening.width / 2;
+            childRight = opening.position[0] + opening.width / 2;
+            childBottom = opening.position[1] - opening.height / 2;
+            childTop = opening.position[1] + opening.height / 2;
+        }
+        else {
+            continue;
+        }
+        // Edges that meet are not an overlap, even when a decimal position lands them a hair apart.
+        if (newLeft < childRight - TOUCHING &&
+            newRight > childLeft + TOUCHING &&
+            newBottom < childTop - TOUCHING &&
+            newTop > childBottom + TOUCHING)
+            return child;
+    }
+    return null;
+}
+/** Whether a placement collides; a missing wall counts as blocked, as in the editor's tools. */
+export function hasWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height, ignoreId) {
+    if (!nodes[wallId])
+        return true;
+    return findWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height, ignoreId) !== null;
+}
+const equalRatios = (count) => Array.from({ length: count }, () => 1 / count);
+/** A window's size when none is given. Its sill is not a number: see `centredWindowSill`. */
+export const DEFAULT_WINDOW = { width: 1.5, height: 1.5 };
+const DEFAULTS = {
+    door: { width: 0.9, height: 2.1 },
+    window: DEFAULT_WINDOW,
+};
+const metres = (value) => `${value.toFixed(2)} m`;
+/**
+ * The sill that centres a window of `height` vertically on the lowest of `walls`, or 0 when it is
+ * taller than they are. What a window with no sill given takes, on every agent surface.
+ */
+export function centredWindowSill(walls, height, nodes) {
+    const ceiling = Math.min(...walls.map((wall) => resolveWallOpeningCeiling(wall, nodes)));
+    return Math.max(0, (ceiling - height) / 2);
+}
+/**
+ * Plan a door or window on a wall with the editor's rules, or refuse with a code: the one
+ * operation behind `add_door` / `add_window` on every agent surface. The caller creates
+ * `node` under `wallId`.
+ */
+/**
+ * Which way a door on `wall` faces: out, when the wall knows its outside. A door's swing and a
+ * garage door's track run behind its facing (a garage door's track once ran on the street), so a door facing out opens and rolls inside, whichever way the wall was drawn. A wall
+ * that does not know its outside, or an inside wall, keeps its front.
+ */
+export function doorFacing(wall) {
+    const outside = resolveWallExteriorSide(wall);
+    if (outside === -1)
+        return { side: 'back', rotation: [0, Math.PI, 0] };
+    if (outside === 1)
+        return { side: 'front', rotation: [0, 0, 0] };
+    return { rotation: [0, 0, 0] };
+}
+/** The face a door placed by hand takes: out on an outside wall, else the face hovered. */
+/**
+ * Hinges and handle are both measured from the door's own left, so a handle
+ * left where it is would hang on the hinge edge of a right-hinged door.
+ */
+export function doorHardwareSides(input) {
+    const hingesSide = input.hingesSide ?? 'left';
+    return {
+        hingesSide,
+        handleSide: input.handleSide ?? (hingesSide === 'right' ? 'left' : 'right'),
+    };
+}
+export const placedDoorFace = (wall, hovered) => doorFacing(wall).side ?? hovered;
+export function planWallOpening(nodes, input) {
+    refuseParamsWithoutScript(nodes, input);
+    const { kind, wallId } = input;
+    if (!wallId)
+        refuse('wall_required', `Say which wall the ${kind} goes on (wallId), or pass nodeId to rebuild one.`);
+    const host = nodes[wallId];
+    if (!host)
+        refuse('wall_not_found', `Wall not found: ${wallId}.`, { wallId });
+    if (host.type !== 'wall')
+        refuse('not_a_wall', `Node ${wallId} is a ${host.type}, not a wall.`, {
+            wallId,
+            type: host.type,
+        });
+    const wall = host;
+    if (isCurvedWall(wall))
+        refuse('curved_wall', `Wall ${wallId} is curved; doors and windows go on straight walls, as in the editor.`, { wallId });
+    const { t, position } = input;
+    if (t !== undefined && position !== undefined && Math.abs(t - position) > 1e-9)
+        refuse('conflicting_position', `t (${t}) and position (${position}) disagree; they are the same field, pass one.`, { t, position });
+    const along = t ?? position;
+    if (along === undefined)
+        refuse('position_required', 'Say where on the wall: t (or position) from 0 at its start to 1 at its end.');
+    // The renderer draws a style's panes on a Fixed window only; an operable window draws its own
+    // sashes, so a style there would be written and never seen.
+    const windowType = input.windowType ?? 'fixed';
+    if (kind === 'window' && input.style && !windowTakesStyle(windowType))
+        refuse('style_needs_fixed_window', `A window style shapes a Fixed window's panes; a ${windowType} window draws its own sashes, so the style would not show. Pass windowType 'fixed' with the style, or drop the style.`, { windowType, style: input.style });
+    const { compiled } = input;
+    if (compiled && compiled.mount !== 'wall')
+        refuse('wrong_mount', `A ${kind}'s script uses mount 'wall'.`, { mount: compiled.mount });
+    if (compiled)
+        requireMeasured(compiled, { label: `A ${kind}`, tool: `add_${kind}` });
+    const [scriptedWidth, scriptedHeight] = compiled ? scriptedSize(compiled.manifest) : [];
+    const width = scriptedWidth ?? input.width ?? DEFAULTS[kind].width;
+    const height = scriptedHeight ?? input.height ?? DEFAULTS[kind].height;
+    const wallLength = lengthOf(wall);
+    if (wallLength < width)
+        refuse('wall_too_short', `Wall ${wallId} is ${metres(wallLength)} long, too short for a ${metres(width)} ${kind}.`, { wallId, wallLength, width });
+    const rawX = along * wallLength;
+    // A window with no sill given is centred on its wall, taller than the wall or not: the clamp
+    // below stands one that is too tall on the floor and reports it clamped.
+    const rawY = kind === 'door'
+        ? height / 2
+        : input.sillHeight === undefined
+            ? resolveWallOpeningCeiling(wall, nodes) / 2
+            : input.sillHeight + height / 2;
+    const { clampedX, clampedY } = kind === 'door'
+        ? clampDoorToWall(wall, rawX, width, height)
+        : clampWindowToWall(wall, rawX, rawY, width, height, nodes);
+    if (!input.force) {
+        const blocking = findWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height);
+        if (blocking) {
+            const span = blocking.type === 'item'
+                ? getScaledDimensions(blocking)[0]
+                : blocking.width;
+            const center = blocking.position[0];
+            refuse('opening_overlap', `A ${metres(width)} ${kind} at ${metres(clampedX)} on wall ${wallId} would overlap ${blocking.type} ${blocking.id} (${metres(center - span / 2)}–${metres(center + span / 2)}). Move it along the wall, or, if the person asked for the overlap, pass force, like holding Alt in the editor.`, { wallId, blockingId: blocking.id });
+        }
+    }
+    const levelId = wall.parentId;
+    const siblings = Object.values(nodes).filter((node) => {
+        if (node.type !== kind)
+            return false;
+        const parent = node.parentId ? nodes[node.parentId] : undefined;
+        return parent?.parentId === levelId;
+    }).length;
+    const base = {
+        ...(compiled?.nodeId ? { id: compiled.nodeId } : {}),
+        name: input.name ?? `${kind === 'door' ? 'Door' : 'Window'} ${siblings + 1}`,
+        position: [clampedX, clampedY, 0],
+        rotation: [0, 0, 0],
+        wallId,
+        parentId: wallId,
+        width,
+        height,
+        ...(input.openingShape ? { openingShape: input.openingShape } : {}),
+        ...(input.archHeight === undefined ? {} : { archHeight: Math.min(input.archHeight, height) }),
+        ...(input.cornerRadius === undefined ? {} : { cornerRadius: input.cornerRadius }),
+        ...(compiled
+            ? {
+                source: scriptSource(compiled, input),
+                slots: matchScriptSlotsToLibrary(compiled.manifest),
+            }
+            : {}),
+    };
+    const node = kind === 'door'
+        ? DoorNode.parse({
+            ...base,
+            ...doorFacing(wall),
+            ...doorHardwareSides(input),
+            swingDirection: input.swingDirection ?? 'inward',
+            ...(input.style ? doorStyleLook(input.style) : {}),
+            ...(input.doorType ? { doorType: input.doorType } : {}),
+            ...(input.openingKind ? { openingKind: input.openingKind } : {}),
+        })
+        : WindowNode.parse({
+            ...base,
+            ...getWindowStyleOverrides(input.style),
+            ...(input.windowType ? { windowType: input.windowType } : {}),
+            ...(input.columns ? { columnRatios: equalRatios(input.columns) } : {}),
+            ...(input.rows ? { rowRatios: equalRatios(input.rows) } : {}),
+        });
+    return {
+        node,
+        wallId,
+        localX: clampedX,
+        t: along,
+        wallLength,
+        clamped: Math.abs(clampedX - rawX) > 1e-9 || Math.abs(clampedY - rawY) > 1e-9,
+        ...(kind === 'window' ? { sillHeight: clampedY - height / 2 } : {}),
+    };
+}

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/capture/schema.d.ts

@@ -90,10 +90,10 @@ export declare const CaptureStreamDescriptorSchema: z.ZodObject<{
     kind: z.ZodString;
     role: z.ZodOptional<z.ZodString>;
     availability: z.ZodDefault<z.ZodEnum<{
-        pending: "pending";
+        failed: "failed";
         live: "live";
+        pending: "pending";
         ready: "ready";
-        failed: "failed";
     }>>;
     frameId: z.ZodOptional<z.ZodString>;
     clockId: z.ZodOptional<z.ZodString>;
@@ -116,10 +116,10 @@ export declare const CaptureStreamDescriptorSchema: z.ZodObject<{
 export declare const CaptureClockSchema: z.ZodObject<{
     id: z.ZodString;
     timebase: z.ZodEnum<{
-        seconds: "seconds";
-        milliseconds: "milliseconds";
         microseconds: "microseconds";
+        milliseconds: "milliseconds";
         nanoseconds: "nanoseconds";
+        seconds: "seconds";
     }>;
     epoch: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -185,18 +185,18 @@ export declare const CaptureSessionManifestV2Schema: z.ZodObject<{
     projectId: z.ZodOptional<z.ZodString>;
     revisionId: z.ZodOptional<z.ZodString>;
     state: z.ZodDefault<z.ZodEnum<{
-        live: "live";
-        ready: "ready";
         failed: "failed";
         finalizing: "finalizing";
+        live: "live";
+        ready: "ready";
     }>>;
     clocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         timebase: z.ZodEnum<{
-            seconds: "seconds";
-            milliseconds: "milliseconds";
             microseconds: "microseconds";
+            milliseconds: "milliseconds";
             nanoseconds: "nanoseconds";
+            seconds: "seconds";
         }>;
         epoch: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
@@ -211,10 +211,10 @@ export declare const CaptureSessionManifestV2Schema: z.ZodObject<{
         kind: z.ZodString;
         role: z.ZodOptional<z.ZodString>;
         availability: z.ZodDefault<z.ZodEnum<{
-            pending: "pending";
+            failed: "failed";
             live: "live";
+            pending: "pending";
             ready: "ready";
-            failed: "failed";
         }>>;
         frameId: z.ZodOptional<z.ZodString>;
         clockId: z.ZodOptional<z.ZodString>;
@@ -291,18 +291,18 @@ export declare const CaptureSessionManifestSchema: z.ZodUnion<readonly [z.ZodObj
     projectId: z.ZodOptional<z.ZodString>;
     revisionId: z.ZodOptional<z.ZodString>;
     state: z.ZodDefault<z.ZodEnum<{
-        live: "live";
-        ready: "ready";
         failed: "failed";
         finalizing: "finalizing";
+        live: "live";
+        ready: "ready";
     }>>;
     clocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         timebase: z.ZodEnum<{
-            seconds: "seconds";
-            milliseconds: "milliseconds";
             microseconds: "microseconds";
+            milliseconds: "milliseconds";
             nanoseconds: "nanoseconds";
+            seconds: "seconds";
         }>;
         epoch: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
@@ -317,10 +317,10 @@ export declare const CaptureSessionManifestSchema: z.ZodUnion<readonly [z.ZodObj
         kind: z.ZodString;
         role: z.ZodOptional<z.ZodString>;
         availability: z.ZodDefault<z.ZodEnum<{
-            pending: "pending";
+            failed: "failed";
             live: "live";
+            pending: "pending";
             ready: "ready";
-            failed: "failed";
         }>>;
         frameId: z.ZodOptional<z.ZodString>;
         clockId: z.ZodOptional<z.ZodString>;
@@ -348,18 +348,18 @@ export declare const CaptureSessionDescriptorSchema: z.ZodObject<{
     projectId: z.ZodOptional<z.ZodString>;
     revisionId: z.ZodOptional<z.ZodString>;
     state: z.ZodEnum<{
-        live: "live";
-        ready: "ready";
         failed: "failed";
         finalizing: "finalizing";
+        live: "live";
+        ready: "ready";
     }>;
     clocks: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         timebase: z.ZodEnum<{
-            seconds: "seconds";
-            milliseconds: "milliseconds";
             microseconds: "microseconds";
+            milliseconds: "milliseconds";
             nanoseconds: "nanoseconds";
+            seconds: "seconds";
         }>;
         epoch: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
@@ -374,10 +374,10 @@ export declare const CaptureSessionDescriptorSchema: z.ZodObject<{
         kind: z.ZodString;
         role: z.ZodOptional<z.ZodString>;
         availability: z.ZodDefault<z.ZodEnum<{
-            pending: "pending";
+            failed: "failed";
             live: "live";
+            pending: "pending";
             ready: "ready";
-            failed: "failed";
         }>>;
         frameId: z.ZodOptional<z.ZodString>;
         clockId: z.ZodOptional<z.ZodString>;

package/dist/capture/source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/capture/source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAE7B,KAAK,qBAAqB,EAG3B,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,yBAAyB;;;;;;;;;;;iBAapC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,wBAAwB,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAA;AAEtB,MAAM,MAAM,yBAAyB,GAAG;IACtC,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC9B,CAAA;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAA;IACjE,eAAe,CAAC,CACd,QAAQ,EAAE,wBAAwB,EAClC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,yBAAyB,CAAC,CAAA;IACrC,SAAS,CAAC,CAAC,OAAO,CAAC,EAAE,0BAA0B,GAAG,aAAa,CAAC,kBAAkB,CAAC,CAAA;CACpF;AAED,MAAM,MAAM,qBAAqB,GAAG,CAClC,OAAO,EAAE,qBAAqB,KAC3B,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;AAE3C,MAAM,MAAM,wBAAwB,GAAG;IACrC,WAAW,CAAC,EAAE,kBAAkB,CAAA;IAChC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;IAC/B,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,MAAM,CAAA;IACxD,eAAe,CAAC,EAAE,CAChB,QAAQ,EAAE,wBAAwB,EAClC,MAAM,CAAC,EAAE,WAAW,KACjB,OAAO,CAAC,yBAAyB,CAAC,CAAA;CACxC,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,4BAA4B,CAAC,EAAE,MAAM,CAAA;CACtC,CAAA;AAED,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,qBAAqB,EACnC,OAAO,GAAE,wBAA6B,GACrC,aAAa,CAwCf;AAmCD,qBAAa,iBAAkB,YAAW,aAAa;;gBAMzC,UAAU,EAAE,wBAAwB,EAAE,OAAO,GAAE,wBAA6B;IAKlF,QAAQ,IAAI,OAAO,CAAC,wBAAwB,CAAC;IAI7C,eAAe,CAAC,QAAQ,EAAE,wBAAwB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAK7F,SAAS,CAAC,OAAO,GAAE,0BAA+B,GAAG,aAAa,CAAC,kBAAkB,CAAC;IAyBtF,gBAAgB,CAAC,UAAU,EAAE,wBAAwB,GAAG,IAAI;IAU5D,aAAa,CAAC,WAAW,EAAE,mBAAmB,GAAG,IAAI;IAYrD,KAAK,IAAI,IAAI;CAqBd"}
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/capture/source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAE7B,KAAK,qBAAqB,EAG3B,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,yBAAyB;;;;;;;;;;;iBAapC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,wBAAwB,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAA;AAEtB,MAAM,MAAM,yBAAyB,GAAG;IACtC,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC9B,CAAA;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAA;IACjE,eAAe,CAAC,CACd,QAAQ,EAAE,wBAAwB,EAClC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,yBAAyB,CAAC,CAAA;IACrC,SAAS,CAAC,CAAC,OAAO,CAAC,EAAE,0BAA0B,GAAG,aAAa,CAAC,kBAAkB,CAAC,CAAA;CACpF;AAED,MAAM,MAAM,qBAAqB,GAAG,CAClC,OAAO,EAAE,qBAAqB,KAC3B,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;AAE3C,MAAM,MAAM,wBAAwB,GAAG;IACrC,WAAW,CAAC,EAAE,kBAAkB,CAAA;IAChC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;IAC/B,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,MAAM,CAAA;IACxD,eAAe,CAAC,EAAE,CAChB,QAAQ,EAAE,wBAAwB,EAClC,MAAM,CAAC,EAAE,WAAW,KACjB,OAAO,CAAC,yBAAyB,CAAC,CAAA;CACxC,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,4BAA4B,CAAC,EAAE,MAAM,CAAA;CACtC,CAAA;AAED,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,qBAAqB,EACnC,OAAO,GAAE,wBAA6B,GACrC,aAAa,CAwCf;AAmCD,qBAAa,iBAAkB,YAAW,aAAa;;IAMrD,YAAY,UAAU,EAAE,wBAAwB,EAAE,OAAO,GAAE,wBAA6B,EAGvF;IAEK,QAAQ,IAAI,OAAO,CAAC,wBAAwB,CAAC,CAElD;IAEK,eAAe,CAAC,QAAQ,EAAE,wBAAwB,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAG5F;IAED,SAAS,CAAC,OAAO,GAAE,0BAA+B,GAAG,aAAa,CAAC,kBAAkB,CAAC,CAuBrF;IAED,gBAAgB,CAAC,UAAU,EAAE,wBAAwB,GAAG,IAAI,CAQ3D;IAED,aAAa,CAAC,WAAW,EAAE,mBAAmB,GAAG,IAAI,CAUpD;IAED,KAAK,IAAI,IAAI,CAOZ;CAcF"}

package/dist/capture/source.js

@@ -233,7 +233,7 @@ class EventIterator {
     #trimQueue() {
         while (this.#queue.length > this.#maxQueuedEvents) {
             const packetIndex = this.#queue.findIndex((event) => event.type === 'packet');
-            this.#queue.splice(packetIndex >= 0 ? packetIndex : 0, 1);
+            this.#queue.splice(Math.max(packetIndex, 0), 1);
         }
     }
 }

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,43 @@
+import { type WallNode, type ZoneNode } 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;
+    /** Name the walled room a person already named, instead of stacking a zone on it (an agent's explicit rename). */
+    adoptNamed?: 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;
+}[];
+/**
+ * The room walls already make where a room is drawn, to name rather than stack a second zone on
+ * (walls first, then create_room, gave every room a "Room N" twin). Only when every edge of the
+ * polygon runs along a wall, so nothing is built and the rooms stand as they are; the room the
+ * polygon fits by the reconciler's own adoption rule, and only while it keeps the name the
+ * reconciler gave it.
+ */
+export declare function walledRoomAt(nodes: StructureNodes, levelId: string, polygon: Point[]): ZoneNode | undefined;
+export declare function createZone(nodes: StructureNodes, input: CreateZoneInput): StructurePlan & {
+    zoneId: string;
+    renamed?: string;
+};
+export {};
+//# sourceMappingURL=create-zone.d.ts.map