@pascal-app/core 1.0.6 → 1.1.0

package/dist/agent-operations/move-node.js

@@ -0,0 +1,28 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { achievedChanges } from './achieved.js';
+import { planNodeMove } from './move-plan.js';
+/**
+ * `move_node`: the editor's move tool for one node — re-seated on its host by `planNodeMove`,
+ * so the node the agent leaves is the node the editor's drag would leave.
+ */
+export const moveNode = (nodes, input) => {
+    const node = nodes[input.id];
+    if (!node)
+        refuse('node_not_found', `Node not found: ${input.id}.`, { id: input.id });
+    const plan = planNodeMove(nodes, node, input);
+    const changes = { update: [{ id: node.id, data: plan.data }] };
+    return {
+        result: {
+            ok: true,
+            id: node.id,
+            type: node.type,
+            host: plan.host,
+            hostId: plan.hostId,
+            position: plan.position,
+            clamped: plan.clamped,
+            message: `Moved ${node.type} "${node.name ?? node.id}"${plan.clamped ? ', slid to stay seated' : ''}`,
+            achieved: achievedChanges(nodes, changes),
+        },
+        changes,
+    };
+};

package/dist/agent-operations/move-plan.d.ts

@@ -0,0 +1,28 @@
+import { type AnyNode } from '../schema/index.js';
+import type { SceneNodes } from './types.js';
+export type MoveTarget = {
+    to?: number[];
+    by?: number[];
+    y?: number;
+    rotation?: number;
+    force?: boolean;
+};
+export type MoveHostClass = 'wall' | 'ceiling' | 'free' | 'roof' | 'level';
+export type MovePlan = {
+    host: MoveHostClass;
+    hostId: string | null;
+    /** The node's stored position after the move; for a wall, its start as [x, 0, z]. */
+    position: [number, number, number];
+    clamped: boolean;
+    data: Partial<AnyNode>;
+};
+/** The host class a node's seat belongs to, or a coded refusal saying why it has no movable seat. */
+export declare function moveHostClass(nodes: SceneNodes, node: AnyNode): MoveHostClass;
+/**
+ * Where a node lands when moved, seated the way the editor's move tools seat it — the same plan
+ * move_node applies to a live node and duplicate_node applies to a copy's offset.
+ */
+export declare function planNodeMove(nodes: SceneNodes, node: AnyNode, target: MoveTarget, options?: {
+    checkOverlap?: boolean;
+}): MovePlan;
+//# sourceMappingURL=move-plan.d.ts.map

package/dist/agent-operations/move-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-plan.d.ts","sourceRoot":"","sources":["../../src/agent-operations/move-plan.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,OAAO,EAQb,MAAM,WAAW,CAAA;AAKlB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,CAAC,EAAE,MAAM,EAAE,CAAA;IACb,EAAE,CAAC,EAAE,MAAM,EAAE,CAAA;IACb,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;AAE1E,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,aAAa,CAAA;IACnB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,qFAAqF;IACrF,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CACvB,CAAA;AA6CD,qGAAqG;AACrG,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,GAAG,aAAa,CAsC7E;AA2QD;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GACvC,QAAQ,CAcV"}

package/dist/agent-operations/move-plan.js

@@ -0,0 +1,259 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { clampDoorToWall, clampWindowToWall, findWallChildOverlap, refuseOpeningAboveSlope, wallOpeningCeilingOver, } from '../building/wall-openings.js';
+import { getDoorOpeningSize } from '../lib/door-opening.js';
+import { openingHostFacing } from '../lib/opening-casing.js';
+import { getCurtainWallConfig, getScaledDimensions, } from '../schema/index.js';
+import { isDerivedNode } from '../store/derived-node-guard.js';
+import { isCurvedWall } from '../systems/wall/wall-curve.js';
+import { getWallLocalFaceZ } from '../systems/wall/wall-frame.js';
+import { projectWorldPointToWallLocalX, wallLength } from './plan-geometry.js';
+/**
+ * Kinds a person can pick up and set down on a level, whose seat is their stored plan position:
+ * the same kinds the node definitions declare `movable` on x/z (core cannot read those
+ * definitions, so the seat is decided by kind and parent here, as other operations decide).
+ */
+const FREE_ON_LEVEL = new Set([
+    'item',
+    'column',
+    'elevator',
+    'shelf',
+    'block',
+    'cabinet',
+    'procedural-item',
+    'imported-mesh',
+    'scan',
+    'spawn',
+    'hvac-equipment',
+    'duct-terminal',
+    'duct-fitting',
+    'pipe-fitting',
+    'pipe-trap',
+]);
+const DEDICATED_TOOL = {
+    zone: 'move_zone or rotate_zone',
+    level: 'add_level or duplicate_level',
+    roof: 'create_roof',
+    'roof-segment': 'create_roof',
+    stair: 'create_stair',
+    building: 'update_node on the building',
+};
+function parentOf(nodes, node) {
+    return node.parentId ? nodes[node.parentId] : undefined;
+}
+function positionOf(node) {
+    const position = node.position;
+    return Array.isArray(position) && position.length === 3
+        ? position
+        : null;
+}
+/** The host class a node's seat belongs to, or a coded refusal saying why it has no movable seat. */
+export function moveHostClass(nodes, node) {
+    if (isDerivedNode(node))
+        refuse('node_not_movable', `${node.type} ${node.id} is derived from its room; the editor rebuilds it rather than moving it.`, { id: node.id, type: node.type });
+    const parent = parentOf(nodes, node);
+    if (parent?.type === 'wall' &&
+        (node.type === 'door' || node.type === 'window' || node.type === 'item'))
+        return 'wall';
+    if (parent?.type === 'ceiling' && node.type === 'item')
+        return 'ceiling';
+    if ((node.type === 'door' || node.type === 'window') &&
+        (node.roofSegmentId || parent?.type === 'roof-segment'))
+        refuse('move_not_supported', `${node.type} ${node.id} sits on a roof-segment wall face, whose seat the editor keeps in face-local coordinates this tool does not move.`, { id: node.id, type: node.type });
+    if (parent?.type === 'roof-segment')
+        return 'roof';
+    if (node.type === 'wall' && parent?.type === 'level')
+        return 'level';
+    if (parent?.type === 'level' && FREE_ON_LEVEL.has(node.type) && positionOf(node))
+        return 'free';
+    if (parent?.type === 'item')
+        refuse('move_not_supported', `${node.type} ${node.id} rests on item ${parent.id}; moving a node on another item's surface is not supported here. Move its host, or delete and place it again.`, { id: node.id, hostId: parent.id });
+    const dedicated = DEDICATED_TOOL[node.type];
+    refuse('node_not_movable', `A ${node.type} has no seat the editor's move tool drags${dedicated ? `; use ${dedicated}` : ''}.`, { id: node.id, type: node.type });
+}
+function requireTarget(target) {
+    if (target.to && target.by)
+        refuse('move_target_ambiguous', 'Pass one of to (absolute) or by (delta), not both.');
+    if (!target.to && !target.by && target.rotation === undefined)
+        refuse('move_target_required', 'Say where the node goes: to [x, z], by [dx, dz], or a rotation alone.');
+}
+function planTargetXZ(current, target) {
+    if (target.to)
+        return [target.to[0] ?? current[0], target.to[1] ?? current[2]];
+    return [current[0] + (target.by?.[0] ?? 0), current[2] + (target.by?.[1] ?? 0)];
+}
+function yawData(node, target, scalar) {
+    if (target.rotation === undefined)
+        return {};
+    const radians = (target.rotation * Math.PI) / 180;
+    if (scalar)
+        return { rotation: radians };
+    const rotation = node.rotation;
+    const tuple = [rotation?.[0] ?? 0, radians, rotation?.[2] ?? 0];
+    return { rotation: tuple };
+}
+function refuseStrayY(target, node) {
+    if (target.y !== undefined)
+        refuse('height_not_applicable', `y sets a window's sill or a wall item's bottom height; ${node.type} ${node.id} takes neither.`, { id: node.id, type: node.type });
+}
+function planFreeMove(node, target, host) {
+    refuseStrayY(target, node);
+    const current = positionOf(node);
+    if (!current)
+        refuse('node_not_movable', `${node.type} ${node.id} has no stored position to move.`, {
+            id: node.id,
+        });
+    const [x, z] = planTargetXZ(current, target);
+    const position = [x, current[1], z];
+    return {
+        host,
+        hostId: node.parentId ?? null,
+        position,
+        clamped: false,
+        data: { position, ...yawData(node, target, host === 'roof') },
+    };
+}
+function desiredLocalX(wall, node, target) {
+    const current = positionOf(node);
+    if (target.to)
+        return projectWorldPointToWallLocalX(wall, [target.to[0] ?? 0, 0, target.to[1] ?? 0]);
+    if (!current)
+        return 0;
+    const length = wallLength(wall);
+    if (!length)
+        return current[0];
+    const ux = (wall.end[0] - wall.start[0]) / length;
+    const uz = (wall.end[1] - wall.start[1]) / length;
+    return current[0] + (target.by?.[0] ?? 0) * ux + (target.by?.[1] ?? 0) * uz;
+}
+function overlapRefusal(nodes, wall, node, centreX, centreY, width, height, target, checkOverlap) {
+    if (!checkOverlap || target.force)
+        return;
+    const blocking = findWallChildOverlap(wall.id, nodes, centreX, centreY, width, height, node.id);
+    if (blocking)
+        refuse('opening_overlap', `Moving ${node.type} ${node.id} there on wall ${wall.id} would overlap ${blocking.type} ${blocking.id}. Move it along the wall, or, if the person asked for the overlap, pass force, like holding Alt in the editor.`, { id: node.id, wallId: wall.id, blockingId: blocking.id });
+}
+function planOpeningMove(nodes, wall, node, target, checkOverlap) {
+    if (node.type === 'door' && target.y !== undefined)
+        refuseStrayY(target, node);
+    // A door's cutout is wider and taller than its leaf once it has sidelights or a transom.
+    const cutout = node.type === 'door'
+        ? getDoorOpeningSize(node)
+        : { width: node.width, height: node.height, leafOffsetX: 0 };
+    const cutoutOffsetX = cutout.leafOffsetX * openingHostFacing(node);
+    const length = wallLength(wall);
+    if (length < cutout.width)
+        refuse('wall_too_short', `Wall ${wall.id} is ${length.toFixed(2)} m long, too short for this ${cutout.width.toFixed(2)} m ${node.type}.`, { id: node.id, wallId: wall.id, wallLength: length, width: cutout.width });
+    const rawX = desiredLocalX(wall, node, target);
+    const rawY = node.type === 'door'
+        ? node.height / 2
+        : target.y === undefined
+            ? node.position[1]
+            : target.y + node.height / 2;
+    const { clampedX, clampedY, fits } = node.type === 'door'
+        ? clampDoorToWall(wall, rawX, node.width, node.height, node, nodes)
+        : clampWindowToWall(wall, rawX, rawY, node.width, node.height, nodes);
+    if (!fits)
+        refuseOpeningAboveSlope(wall, nodes, node.type, node.width, node.height);
+    // Checked where the clamp put the door: under a sloped top it may have slid to the high end.
+    if (node.type === 'door') {
+        const wallHeight = wallOpeningCeilingOver(wall, nodes, clampedX - cutoutOffsetX - cutout.width / 2, clampedX - cutoutOffsetX + cutout.width / 2) - (wall.wallType === 'curtain' ? getCurtainWallConfig(wall).perimeterWidth : 0);
+        if (cutout.height > wallHeight + 1e-6)
+            refuse('wall_too_low', `Wall ${wall.id} is ${wallHeight.toFixed(2)} m high, too low for this ${cutout.height.toFixed(2)} m door.`, { id: node.id, wallId: wall.id, wallHeight, height: cutout.height });
+    }
+    overlapRefusal(nodes, wall, node, clampedX - cutoutOffsetX, clampedY + (cutout.height - node.height) / 2, cutout.width, cutout.height, target, checkOverlap);
+    const position = [clampedX, clampedY, node.position[2]];
+    return {
+        host: 'wall',
+        hostId: wall.id,
+        position,
+        clamped: Math.abs(clampedX - rawX) > 1e-9 || Math.abs(clampedY - rawY) > 1e-9,
+        data: { position },
+    };
+}
+/** A wall item's seat, as place_items seats one: along the wall, bottom at y, on the point's side. */
+function planWallItemMove(nodes, wall, item, target, checkOverlap) {
+    const [width, height] = getScaledDimensions(item);
+    const wallHeight = wall.height ?? 2.5;
+    const length = wallLength(wall);
+    const rawX = desiredLocalX(wall, item, target);
+    const x = Math.max(width / 2, Math.min(length - width / 2, rawX));
+    const rawY = target.y ?? item.position[1];
+    const y = Math.max(0, Math.min(wallHeight - height, rawY));
+    // The side follows the target point when one is named, as the editor's drag crosses the wall.
+    let side = item.side;
+    let faceZ = item.position[2];
+    let turn = item.rotation[1] ?? 0;
+    if (target.to) {
+        const [dx, dz] = [wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]];
+        const left = -dz * ((target.to[0] ?? 0) - wall.start[0]) + dx * ((target.to[1] ?? 0) - wall.start[1]) >= 0;
+        side = left ? 'front' : 'back';
+        faceZ = item.asset.attachTo === 'wall-side' ? getWallLocalFaceZ(wall, left ? 'a' : 'b') : 0;
+        turn = left ? 0 : Math.PI;
+    }
+    overlapRefusal(nodes, wall, item, x, y + height / 2, width, height, target, checkOverlap);
+    const position = [x, y, faceZ];
+    return {
+        host: 'wall',
+        hostId: wall.id,
+        position,
+        clamped: Math.abs(x - rawX) > 1e-9 || Math.abs(y - rawY) > 1e-9,
+        data: {
+            position,
+            rotation: [item.rotation[0] ?? 0, turn, item.rotation[2] ?? 0],
+            wallId: wall.id,
+            wallT: length ? x / length : 0,
+            side,
+        },
+    };
+}
+function planWallHostedMove(nodes, node, target, checkOverlap) {
+    if (target.rotation !== undefined)
+        refuse('rotation_not_supported', `${node.type} ${node.id} faces its wall side; rotation does not apply on a wall host.`, { id: node.id });
+    const wall = parentOf(nodes, node);
+    if (wall?.type !== 'wall')
+        refuse('move_host_missing', `${node.type} ${node.id} has no host wall.`, { id: node.id });
+    if (isCurvedWall(wall))
+        refuse('curved_wall', `Wall ${wall.id} is curved; its hosted nodes do not slide along it, as in the editor.`, { id: node.id, wallId: wall.id });
+    return node.type === 'item'
+        ? planWallItemMove(nodes, wall, node, target, checkOverlap)
+        : planOpeningMove(nodes, wall, node, target, checkOverlap);
+}
+function planWallMove(node, target) {
+    refuseStrayY(target, node);
+    if (target.rotation !== undefined)
+        refuse('rotation_not_supported', `Wall ${node.id} turns by redrawing its ends; move_node only translates it.`, { id: node.id });
+    if (target.to)
+        refuse('move_to_ambiguous', `A wall has two ends; say by how much wall ${node.id} translates, with by [dx, dz].`, { id: node.id });
+    const dx = target.by?.[0] ?? 0;
+    const dz = target.by?.[1] ?? 0;
+    const start = [node.start[0] + dx, node.start[1] + dz];
+    const end = [node.end[0] + dx, node.end[1] + dz];
+    return {
+        host: 'level',
+        hostId: node.parentId ?? null,
+        position: [start[0], 0, start[1]],
+        clamped: false,
+        data: { start, end },
+    };
+}
+/**
+ * Where a node lands when moved, seated the way the editor's move tools seat it — the same plan
+ * move_node applies to a live node and duplicate_node applies to a copy's offset.
+ */
+export function planNodeMove(nodes, node, target, options = {}) {
+    requireTarget(target);
+    const host = moveHostClass(nodes, node);
+    const checkOverlap = options.checkOverlap ?? true;
+    if (host === 'wall')
+        return planWallHostedMove(nodes, node, target, checkOverlap);
+    if (host === 'level')
+        return planWallMove(node, target);
+    if (host === 'roof') {
+        const parent = parentOf(nodes, node);
+        if (parent?.type !== 'roof-segment')
+            refuse('move_host_missing', `${node.type} ${node.id} has no host roof segment.`, {
+                id: node.id,
+            });
+    }
+    return planFreeMove(node, target, host);
+}

package/dist/agent-operations/node-patch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-patch.d.ts","sourceRoot":"","sources":["../../src/agent-operations/node-patch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AA8ExC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACtC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwDzB"}
+{"version":3,"file":"node-patch.d.ts","sourceRoot":"","sources":["../../src/agent-operations/node-patch.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AA8ExC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACtC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyEzB"}

package/dist/agent-operations/node-patch.js

@@ -1,4 +1,5 @@
 import { refuse } from '../agent-tools/refusal.js';
+import { doorPositionForFacing } from '../lib/door-opening.js';
 import { parseMaterialColor } from '../material-library.js';
 import { parseNode } from '../schema/compiled-node-parsers.js';
 import { finishSurface, requireMaterialRef } from './material-refs.js';
@@ -110,5 +111,19 @@ export function honestNodePatch(current, data) {
         if (sent[material] !== undefined && typeof hider === 'string' && hider)
             refuse('shadowed_field', `${material} would not show: ${preset} (${hider}) is read first. Clear it in the same patch (${preset}: null).`, { field: material, hiddenBy: preset });
     }
+    if (current.type === 'door' &&
+        parsed.data.type === 'door' &&
+        ('rotation' in sent || 'side' in sent)) {
+        const next = parsed.data;
+        const rotation = sent.rotation === undefined
+            ? [
+                next.rotation[0],
+                next.side === 'back' ? Math.PI : 0,
+                next.rotation[2],
+            ]
+            : next.rotation;
+        sent.rotation = rotation;
+        sent.position = doorPositionForFacing({ ...next, rotation: current.rotation }, rotation);
+    }
     return sent;
 }

package/dist/agent-operations/paint.d.ts

@@ -4,7 +4,8 @@ import type { AgentOperation } from './types.js';
  * `paint`: a finish in one call, as the editor's Paint gives it. Through patches an agent once took
  * five tries to paint a pier grey: `material: {color}` was stored as `{}`, `materialPreset: null`
  * was refused and an unknown preset fell back to grey. A colour is the nearest of the library's
- * flat colours, said with how near; a native material is kept as a scene material. Slots are
+ * flat colours, said with how near, or kept as given with exact; a native material is kept as a
+ * scene material. Slots are
  * written as the editor's slot paint writes them, a wall's faces through its paint plan, a roof's
  * role through its role field, on the roof: a roof shows one finish per surface, so a segment's
  * finish goes on its roof.
@@ -15,6 +16,7 @@ type PaintInput = {
     color?: string;
     material?: string | MaterialSchema;
     materialName?: string;
+    exact?: boolean;
     erase?: true;
 };
 export declare const paint: AgentOperation<PaintInput>;

package/dist/agent-operations/paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/agent-operations/paint.ts"],"names":[],"mappings":"AAKA,OAAO,EAKL,KAAK,cAAc,EAOpB,MAAM,WAAW,CAAA;AAMlB,OAAO,KAAK,EAAgB,cAAc,EAAc,MAAM,SAAS,CAAA;AAEvE;;;;;;;;GAQG;AAEH,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,GAAG,cAAc,CAAA;IAClC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,IAAI,CAAA;CACb,CAAA;AAsKD,eAAO,MAAM,KAAK,EAAE,cAAc,CAAC,UAAU,CA8M5C,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/agent-operations/paint.ts"],"names":[],"mappings":"AAMA,OAAO,EAKL,KAAK,cAAc,EAOpB,MAAM,WAAW,CAAA;AAMlB,OAAO,KAAK,EAAgB,cAAc,EAAc,MAAM,SAAS,CAAA;AAEvE;;;;;;;;;GASG;AAEH,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,GAAG,cAAc,CAAA;IAClC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE,IAAI,CAAA;CACb,CAAA;AA4KD,eAAO,MAAM,KAAK,EAAE,cAAc,CAAC,UAAU,CAoN5C,CAAA"}

package/dist/agent-operations/paint.js

@@ -1,4 +1,5 @@
 import { refuse } from '../agent-tools/refusal.js';
+import { slabSurfaceScriptPaintRefusal } from '../lib/floor-plate-paint.js';
 import { wallFaceScriptPaintRefusal } from '../lib/wall-face-script.js';
 import { GLAZED_ROOF_SLOTS, nodeSlotDeclarations } from '../node-slots/index.js';
 import { nearestLibraryColorRef } from '../procedural-items/library-colors.js';
@@ -7,7 +8,7 @@ import { buildWallFinishLayout, getWallLevelZones } from '../systems/wall/wall-f
 import { planWallPaint } from '../systems/wall/wall-paint-plan.js';
 import { roomFaceCover } from '../systems/wall/wall-room-sides.js';
 import { finishSurface, requireMaterialRef } from './material-refs.js';
-import { resolveInlinePaintMaterial } from './scene-materials.js';
+import { exactColorMaterial, resolveInlinePaintMaterial } from './scene-materials.js';
 const WALL_TRIMS = ['skirting', 'crown', 'chairRail'];
 const ROOF_ROLES = ['top', 'edge', 'wall', 'fascia'];
 /** The surfaces the roof itself holds; its fascia is held by each of its segments. */
@@ -38,8 +39,14 @@ function finishOf(input, surface, context) {
         refuse('finish_required', 'Give one finish: color (#rrggbb), material (a library or scene ref, or a native material), or erase: true.');
     if (input.materialName !== undefined && typeof input.material !== 'object')
         refuse('invalid_material_name', 'materialName names a native material only.');
+    if (input.exact && !input.color)
+        refuse('invalid_exact', 'exact keeps a color as given: give color.');
     if (input.erase)
         return { ref: undefined };
+    if (input.color && input.exact) {
+        const { ref, sceneMaterial, created } = exactColorMaterial(context.materials, input.color);
+        return { ref, sceneMaterial, created };
+    }
     if (input.color) {
         const match = nearestLibraryColorRef(input.color);
         if (!match)
@@ -289,6 +296,12 @@ export const paint = (nodes, input, context) => {
                     keptParts.push(`${id} ${face}: ${parts.map((region) => region.id).join(', ')}`);
                 continue;
             }
+            const scripted = slabSurfaceScriptPaintRefusal(target, role);
+            if (scripted)
+                refuse('surface_built_by_script', `${scripted.message} Nothing was painted.`, {
+                    target: id,
+                    role,
+                });
             const next = { ...(target.slots ?? {}) };
             if (ref)
                 next[role] = ref;

package/dist/agent-operations/photo-elevation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"photo-elevation.d.ts","sourceRoot":"","sources":["../../src/agent-operations/photo-elevation.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"photo-elevation.d.ts","sourceRoot":"","sources":["../../src/agent-operations/photo-elevation.ts"],"names":[],"mappings":"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"}

package/dist/agent-operations/photo-elevation.js

@@ -1,6 +1,7 @@
 import { refuse } from '../agent-tools/refusal.js';
 import { applyHomography, cameraFaceHomography, faceAtWidth, faceCoordinates, faceThroughCorner, invertHomography, lineIntersection, multiplyHomography, pointOnFace, solveHomography, solvePhotoCamera, vanishingPoint, vanishingResidualPx, } from '../building/photo-elevation.js';
 import { getLevelElevations } from '../services/storey.js';
+import { queryNodes } from './scene-queries.js';
 /** Longest side of a drawing, and the finest scale worth drawing a facade at. */
 const MAX_SIDE = 1200;
 const MAX_PX_PER_METRE = 60;
@@ -691,7 +692,7 @@ function photoPose(nodes, elevations, faces, camera, anchors, focalAssumed) {
     let best = null;
     if (faces.length === 1) {
         // One face: the camera stands outside the building, away from its walls' middle.
-        const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === faces[0].levelId);
+        const walls = queryNodes(nodes, { type: 'wall', parentId: faces[0].levelId });
         const middle = walls.flatMap((wall) => [wall.start, wall.end]);
         const cx = mean(middle.map((p) => p[0]));
         const cz = mean(middle.map((p) => p[1]));

package/dist/agent-operations/place-in-room.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"place-in-room.d.ts","sourceRoot":"","sources":["../../src/agent-operations/place-in-room.ts"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAIzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAGtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAErD,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,GAAG;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;IACpB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,IAAI,GAAG,KAAK,CAAA;IACrB,KAAK,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAA;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,cAAc,CAAC,EAAE,aAAa,EAAE,CAAA;CACjC,CAAA;AAqPD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,gBAAgB,CAwQxD,CAAA"}
+{"version":3,"file":"place-in-room.d.ts","sourceRoot":"","sources":["../../src/agent-operations/place-in-room.ts"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAIzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAGtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAErD,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,GAAG;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;IACpB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,IAAI,GAAG,KAAK,CAAA;IACrB,KAAK,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAA;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,cAAc,CAAC,EAAE,aAAa,EAAE,CAAA;CACjC,CAAA;AAqPD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,gBAAgB,CAyQxD,CAAA"}

package/dist/agent-operations/place-in-room.js

@@ -246,6 +246,7 @@ export const placeInRoom = (nodes, input, context) => {
     if (input.edge !== undefined &&
         (!Number.isInteger(input.edge) || input.edge < 0 || input.edge >= polygon.length))
         refuse('edge_out_of_range', `The room has ${polygon.length} edges (0–${polygon.length - 1}); there is no edge ${input.edge}.`);
+    // biome-ignore lint/plugin: door keep-outs and occupied footprints resolve each item through its parents
     const all = Object.values(nodes);
     const bounds = polygonBounds(polygon);
     const room = {

package/dist/agent-operations/place-items.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"place-items.d.ts","sourceRoot":"","sources":["../../src/agent-operations/place-items.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAQnE,OAAO,KAAK,EAAE,cAAc,EAA4B,MAAM,SAAS,CAAA;AAEvE,KAAK,KAAK,GAAG;IACX,OAAO,EAAE,MAAM,CAAA;IACf,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AACD,KAAK,eAAe,GAAG,gBAAgB,GAAG;IAAE,KAAK,EAAE,KAAK,EAAE,CAAA;CAAE,CAAA;AA8K5D;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CAkItD,CAAA"}
+{"version":3,"file":"place-items.d.ts","sourceRoot":"","sources":["../../src/agent-operations/place-items.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AASnE,OAAO,KAAK,EAAE,cAAc,EAA4B,MAAM,SAAS,CAAA;AAEvE,KAAK,KAAK,GAAG;IACX,OAAO,EAAE,MAAM,CAAA;IACf,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AACD,KAAK,eAAe,GAAG,gBAAgB,GAAG;IAAE,KAAK,EAAE,KAAK,EAAE,CAAA;CAAE,CAAA;AA4K5D;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CAqItD,CAAA"}

package/dist/agent-operations/place-items.js

@@ -8,6 +8,7 @@ import { collectDoorKeepouts } from './door-clearance.js';
 import { targetLevel } from './level-target.js';
 import { pointInPolygon, projectWorldPointToWallLocalX, wallLength, } from './plan-geometry.js';
 import { roofLevelRefusal } from './roof-writes.js';
+import { queryNodes } from './scene-queries.js';
 /**
  * What belongs on the lot rather than in a room. Anything else placed outside every room of a
  * level that has rooms is refused: in production a model that had fallen back to raw place_items
@@ -16,9 +17,7 @@ import { roofLevelRefusal } from './roof-writes.js';
 const OUTDOOR_ASSET = /tree|plant|shrub|bush|hedge|flower|palm|\bfir\b|bench|grill|bbq|barbecue|\bcar\b|vehicle|truck|bike|bicycle|pool|fence|gate|lamp ?post|street|outdoor|garden|patio|deck|swing|trampoline|planter|mailbox|umbrella|parasol/i;
 const isOutdoor = (asset) => OUTDOOR_ASSET.test(`${asset.name} ${asset.category ?? ''} ${(asset.tags ?? []).join(' ')}`);
 function roomsOn(nodes, levelId) {
-    return Object.values(nodes).flatMap((node) => node.type === 'zone' && node.parentId === levelId && node.polygon.length >= 3
-        ? [node.polygon]
-        : []);
+    return queryNodes(nodes, { type: 'zone', parentId: levelId }).flatMap((node) => node.polygon.length >= 3 ? [node.polygon] : []);
 }
 const refused = (assetId, code, error) => ({
     ok: false,
@@ -205,7 +204,7 @@ export const placeItems = (nodes, input, context) => {
         const room = rooms.find((polygon) => pointInPolygon([x, z], polygon));
         if (rooms.length && !isOutdoor(asset) && !room)
             return refused(assetId, 'outside_rooms', `"${asset.name}" at (${x}, ${z}) is outside every room on this level: indoor items go inside a room (read the rooms with get_zones); trees and garden items may stand outside. Outside a room, ${OUTSIDE_SOURCES}`);
-        doorsOn[floorId] ??= collectDoorKeepouts(Object.values(nodes), { levelId: floorId });
+        doorsOn[floorId] ??= collectDoorKeepouts(queryNodes(nodes, { type: ['door', 'wall', 'level'] }), { levelId: floorId });
         const misfit = floorFit(nodes, floorId, entry, asset, doorsOn[floorId]);
         if (misfit)
             return misfit;

package/dist/agent-operations/plan-clearance.d.ts

@@ -0,0 +1,28 @@
+import type { PlanAabb } from './door-clearance.js';
+/** The direction of a move in the plan, along the scene's x or z axis. */
+export type ClearDirection = '+x' | '-x' | '+z' | '-z';
+export type ClearMove = {
+    direction: ClearDirection;
+    distanceM: number;
+};
+/** A length in metres, to the millimetre. */
+export declare const roundMm: (value: number) => number;
+/** A length as the findings say it, to the millimetre. */
+export declare const metres: (value: number) => string;
+/** Moves as the findings say them: "0.295 m toward -x or 0.620 m toward -z". */
+export declare const describeMoves: (moves: readonly ClearMove[]) => string;
+export declare const roundBox: (box: PlanAabb) => PlanAabb;
+/**
+ * How far two boxes share each plan axis: the length of the shared stretch, or minus the gap where
+ * they are apart along it.
+ */
+export declare function axisOverlap(a: PlanAabb, b: PlanAabb): {
+    x: number;
+    z: number;
+};
+/**
+ * The moves of `a` that leave `margin` between it and `b`: the nearer way out on each axis, away
+ * from the other box's middle, shortest first. A box already clear by the margin has none.
+ */
+export declare function clearingMoves(a: PlanAabb, b: PlanAabb, margin: number): ClearMove[];
+//# sourceMappingURL=plan-clearance.d.ts.map

package/dist/agent-operations/plan-clearance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-clearance.d.ts","sourceRoot":"","sources":["../../src/agent-operations/plan-clearance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD,0EAA0E;AAC1E,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAEtD,MAAM,MAAM,SAAS,GAAG;IAAE,SAAS,EAAE,cAAc,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAA;AAIxE,6CAA6C;AAC7C,eAAO,MAAM,OAAO,UAAW,MAAM,WAA4C,CAAA;AAEjF,0DAA0D;AAC1D,eAAO,MAAM,MAAM,UAAW,MAAM,WAAqB,CAAA;AAEzD,gFAAgF;AAChF,eAAO,MAAM,aAAa,UAAW,SAAS,SAAS,EAAE,WACiC,CAAA;AAE1F,eAAO,MAAM,QAAQ,QAAS,QAAQ,KAAG,QAKvC,CAAA;AAKF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAK9E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,CAiBnF"}

package/dist/agent-operations/plan-clearance.js

@@ -0,0 +1,47 @@
+const MM_PER_M = 1000;
+/** A length in metres, to the millimetre. */
+export const roundMm = (value) => Math.round(value * MM_PER_M) / MM_PER_M;
+/** A length as the findings say it, to the millimetre. */
+export const metres = (value) => value.toFixed(3);
+/** Moves as the findings say them: "0.295 m toward -x or 0.620 m toward -z". */
+export const describeMoves = (moves) => moves.map((move) => `${metres(move.distanceM)} m toward ${move.direction}`).join(' or ');
+export const roundBox = (box) => ({
+    minX: roundMm(box.minX),
+    maxX: roundMm(box.maxX),
+    minZ: roundMm(box.minZ),
+    maxZ: roundMm(box.maxZ),
+});
+/** Up to the millimetre, so a move of the stated length clears; the sliver below is float noise. */
+const ceilMm = (value) => Math.ceil(value * MM_PER_M - 1e-9) / MM_PER_M;
+/**
+ * How far two boxes share each plan axis: the length of the shared stretch, or minus the gap where
+ * they are apart along it.
+ */
+export function axisOverlap(a, b) {
+    return {
+        x: Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX),
+        z: Math.min(a.maxZ, b.maxZ) - Math.max(a.minZ, b.minZ),
+    };
+}
+/**
+ * The moves of `a` that leave `margin` between it and `b`: the nearer way out on each axis, away
+ * from the other box's middle, shortest first. A box already clear by the margin has none.
+ */
+export function clearingMoves(a, b, margin) {
+    const awayX = a.minX + a.maxX >= b.minX + b.maxX;
+    const awayZ = a.minZ + a.maxZ >= b.minZ + b.maxZ;
+    const moves = [
+        {
+            direction: awayX ? '+x' : '-x',
+            distanceM: awayX ? margin + b.maxX - a.minX : margin + a.maxX - b.minX,
+        },
+        {
+            direction: awayZ ? '+z' : '-z',
+            distanceM: awayZ ? margin + b.maxZ - a.minZ : margin + a.maxZ - b.minZ,
+        },
+    ];
+    return moves
+        .filter((move) => move.distanceM > 0)
+        .map((move) => ({ ...move, distanceM: ceilMm(move.distanceM) }))
+        .sort((first, second) => first.distanceM - second.distanceM);
+}

package/dist/agent-operations/plan-geometry.d.ts

@@ -18,6 +18,8 @@ export declare function polygonBounds(points: Vec2[]): {
     centerZ: number;
 };
 export declare function pointInBoundsWithPadding(x: number, z: number, bounds: ReturnType<typeof polygonBounds>, padding: number): boolean;
+/** The shortest distance from a point to the segment a–b. */
+export declare function distanceToSegment(point: Vec2, a: Vec2, b: Vec2): number;
 export declare function pointOnSegment(point: Vec2, a: Vec2, b: Vec2, tolerance?: number): boolean;
 export declare function pointInPolygon(point: Vec2, polygon: Vec2[], includeBoundary?: boolean): boolean;
 export declare function polygonContainsPolygon(outer: Vec2[], inner: Vec2[]): boolean;

package/dist/agent-operations/plan-geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan-geometry.d.ts","sourceRoot":"","sources":["../../src/agent-operations/plan-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACnC,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAE3C,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAInD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,GAAG,MAAM,CAExE;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGrE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,GACZ,MAAM,CAGR;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,QAAQ,EAAE,IAAI,GACb,MAAM,CAWR;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,CASlD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,CAiBA;AAED,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,OAAO,CAOT;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,SAAO,GAAG,OAAO,CASvF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,eAAe,UAAO,GAAG,OAAO,CAgB5F;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAE5E"}
+{"version":3,"file":"plan-geometry.d.ts","sourceRoot":"","sources":["../../src/agent-operations/plan-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACnC,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAE3C,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAInD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,GAAG,MAAM,CAExE;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGrE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,GACZ,MAAM,CAGR;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,QAAQ,EAAE,IAAI,GACb,MAAM,CAWR;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,CASlD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,CAiBA;AAED,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,OAAO,CAOT;AAED,6DAA6D;AAC7D,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CASvE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,SAAO,GAAG,OAAO,CASvF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,eAAe,UAAO,GAAG,OAAO,CAgB5F;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAE5E"}

package/dist/agent-operations/plan-geometry.js

@@ -63,6 +63,16 @@ export function pointInBoundsWithPadding(x, z, bounds, padding) {
         z >= bounds.minZ + padding &&
         z <= bounds.maxZ - padding);
 }
+/** The shortest distance from a point to the segment a–b. */
+export function distanceToSegment(point, a, b) {
+    const dx = b[0] - a[0];
+    const dz = b[1] - a[1];
+    const length2 = dx * dx + dz * dz;
+    const t = length2 === 0
+        ? 0
+        : Math.max(0, Math.min(1, ((point[0] - a[0]) * dx + (point[1] - a[1]) * dz) / length2));
+    return Math.hypot(point[0] - (a[0] + t * dx), point[1] - (a[1] + t * dz));
+}
 export function pointOnSegment(point, a, b, tolerance = 1e-6) {
     // A segment of no length (an outline's repeated corner) is its one point, not every point.
     if (a[0] === b[0] && a[1] === b[1])