@pascal-app/core 1.0.4 → 1.0.5

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

@@ -0,0 +1,29 @@
+import { type PlanAabb } from './door-clearance.js';
+import type { LevelTargetInput } from './level-target.js';
+import type { AgentOperation } from './types.js';
+export type ClearanceArea = PlanAabb & {
+    id: string;
+};
+export type PlaceInRoomInput = LevelTargetInput & {
+    assetId: string;
+    zoneId?: string;
+    polygon?: number[][];
+    edge?: number;
+    allowDuplicate?: boolean;
+    rotationDeg?: number;
+    facing?: 'in' | 'out';
+    align?: 'center' | 'start' | 'end';
+    offset?: number;
+    inset?: number;
+    clearanceAreas?: ClearanceArea[];
+};
+/**
+ * `place_in_room`: one floor-standing catalog item where it fits. A wall-bound piece (fridge, counter, bed, sofa,
+ * toilet) is set against a wall, centred in the widest free stretch of wall that clears every door
+ * and every other item, facing into the room, and is never set in the middle: when no wall has room
+ * the answer says how wide the widest stretch is. A free-standing piece (table, rug, plant) takes
+ * the middle of the room, or goes with what it belongs with and faces it (a coffee table and an
+ * armchair face the sofa). A chair is placed around its table facing it, and refused with no table.
+ */
+export declare const placeInRoom: AgentOperation<PlaceInRoomInput>;
+//# sourceMappingURL=place-in-room.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,403 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { ItemNode } from '../schema/index.js';
+import { aabbsOverlap, collectDoorKeepouts, itemNodePlanCorners, itemPlanAabb, } from './door-clearance.js';
+import { edgeFrame, roomToFurnish, WALL_GAP } from './furnish-room.js';
+import { anchorOf, furnitureKind } from './furniture-kind.js';
+import { classifyPlacement, collectOccupiedFootprints } from './layout-clearance.js';
+import { pointInPolygon, polygonBounds } from './plan-geometry.js';
+import { levelRole } from './scene-queries.js';
+/** How far along a wall the sweep moves between the positions it tries. */
+const STEP = 0.05;
+/** A wall is sampled at no more than this many positions (30 m at STEP): a longer one gets a coarser step. */
+const MAX_POSITIONS_PER_WALL = 600;
+/** No room has more corners than this; the outline comes from the caller, and the search is cubic in it. */
+const MAX_CORNERS = 128;
+/** A chair sits this far off its table's edge: the clearance every item keeps (DEFAULT_ITEM_GAP) and a hair more. */
+const CHAIR_GAP = 0.09;
+const rad = (deg) => (deg / 180) * Math.PI;
+const round = (value) => Math.round(value * 100) / 100;
+const facingOf = (dx, dz) => (Math.atan2(dx, dz) * 180) / Math.PI;
+/** Where a piece's front points: it is authored facing +Z, and turns counter-clockwise from above. */
+const frontOf = (rotationDeg) => [
+    Math.sin(rad(rotationDeg)),
+    Math.cos(rad(rotationDeg)),
+];
+/** The piece's four corners on the plan, for a room that is not a rectangle. */
+function corners(pose, [width, , depth]) {
+    const front = frontOf(pose.rotationDeg);
+    const side = [front[1], -front[0]];
+    return [-1, 1].flatMap((s) => [-1, 1].map((f) => [
+        pose.x + side[0] * s * (width / 2) + front[0] * f * (depth / 2),
+        pose.z + side[1] * s * (width / 2) + front[1] * f * (depth / 2),
+    ]));
+}
+/** Whether the piece may stand there: inside the room, clear of every door and every other item. */
+function fits(room, pose, dims, itemGap, occupied = room.occupied) {
+    const aabb = itemPlanAabb([pose.x, 0, pose.z], dims, rad(pose.rotationDeg));
+    const reason = classifyPlacement({
+        aabb,
+        doorKeepouts: room.doorKeepouts,
+        occupied,
+        roomBounds: {
+            maxX: room.bounds.maxX,
+            maxZ: room.bounds.maxZ,
+            minX: room.bounds.minX,
+            minZ: room.bounds.minZ,
+        },
+        ...(itemGap === undefined ? {} : { itemGap }),
+        ...(room.options.inset === undefined ? {} : { padding: 0 }),
+    });
+    if (reason !== 'ok')
+        return false;
+    if (!corners(pose, dims).every((corner) => pointInPolygon(corner, room.polygon, true)))
+        return false;
+    const blocked = (room.options.clearanceAreas ?? []).filter((area) => aabbsOverlap(aabb, area, 0));
+    for (const area of blocked)
+        room.blockedClearanceIds.add(area.id);
+    return blocked.length === 0;
+}
+const chosenYaw = (input, preferred) => (input.rotationDeg ?? preferred) + (input.facing === 'out' ? 180 : 0);
+/** Project the rotated footprint onto the wall tangent and normal, not its authored axes. */
+function wallGeometry(room, edge, dims) {
+    const frame = edgeFrame(room.polygon, edge, room.center);
+    const rotationDeg = chosenYaw(room.options, frame.facing);
+    const relative = rad(rotationDeg - frame.facing);
+    const half = (Math.abs(Math.cos(relative)) * dims[0] + Math.abs(Math.sin(relative)) * dims[2]) / 2;
+    const reach = (Math.abs(Math.sin(relative)) * dims[0] + Math.abs(Math.cos(relative)) * dims[2]) / 2 +
+        (room.options.inset ?? WALL_GAP);
+    return { frame, rotationDeg, half, reach };
+}
+function wallPoseAt(room, edge, dims, s) {
+    const { frame, rotationDeg, reach } = wallGeometry(room, edge, dims);
+    const start = room.polygon[edge % room.polygon.length];
+    return {
+        rotationDeg,
+        x: start[0] + frame.along.x * s + frame.inward.x * reach,
+        z: start[1] + frame.along.z * s + frame.inward.z * reach,
+    };
+}
+function desiredAlong(room, edge, dims) {
+    if (room.options.align === undefined && room.options.offset === undefined)
+        return undefined;
+    const { frame, half } = wallGeometry(room, edge, dims);
+    const base = room.options.align === 'start'
+        ? half
+        : room.options.align === 'end'
+            ? frame.length - half
+            : frame.length / 2;
+    return Math.max(half, Math.min(frame.length - half, base + (room.options.offset ?? 0)));
+}
+/** The free stretches of one wall for a piece: where its centre may stand along the edge, in runs. */
+function runsAlong(room, edge, dims) {
+    const { frame, half } = wallGeometry(room, edge, dims);
+    const width = half * 2;
+    const runs = [];
+    let from = null;
+    let to = 0;
+    // Reserve two samples for the end and the caller's desired alignment.
+    const step = Math.max(STEP, (frame.length - width) / (MAX_POSITIONS_PER_WALL - 3));
+    if (half > frame.length - half)
+        return runs;
+    const positions = [];
+    for (let s = half; s <= frame.length - half + 1e-9 && positions.length < MAX_POSITIONS_PER_WALL - 2; s += step)
+        positions.push(s);
+    positions.push(frame.length - half);
+    const desired = desiredAlong(room, edge, dims);
+    if (desired !== undefined)
+        positions.push(desired);
+    for (const s of [...new Set(positions)].sort((a, b) => a - b)) {
+        const pose = wallPoseAt(room, edge, dims, s);
+        if (fits(room, pose, dims)) {
+            from ??= s;
+            to = s;
+        }
+        else if (from !== null) {
+            runs.push({ edge, frame, from, span: to - from + width, to });
+            from = null;
+        }
+    }
+    if (from !== null)
+        runs.push({ edge, frame, from, span: to - from + width, to });
+    return runs;
+}
+/** The desired alignment, clamped to a free run, or its centre when no alignment was requested. */
+function poseInRun(room, run, dims) {
+    const desired = desiredAlong(room, run.edge, dims) ?? (run.from + run.to) / 2;
+    return wallPoseAt(room, run.edge, dims, Math.max(run.from, Math.min(run.to, desired)));
+}
+/** The widest free stretch of wall that any piece of this depth could use, for the refusal. */
+function widestFree(room, dims, edges) {
+    const probe = [0.1, dims[1], dims[2]];
+    let widest = null;
+    for (const edge of edges)
+        for (const run of runsAlong(room, edge, probe))
+            if (!widest || run.span > widest.span)
+                widest = run;
+    return widest;
+}
+const nameOf = (node) => `${node.asset.id} ${node.name ?? node.asset.name ?? ''}`.toLowerCase();
+function itemDims(node) {
+    const [w = 1, h = 1, d = 1] = node.asset.dimensions ?? [1, 1, 1];
+    return [w, h, d];
+}
+/** Slots around a table for chairs, best first: the middle of the long sides, then the ends, then beside. */
+function chairSlots(table, chair, input) {
+    const tableDims = itemDims(table);
+    const tw = tableDims[0] * Math.abs(table.scale[0]);
+    const td = tableDims[2] * Math.abs(table.scale[2]);
+    const turn = table.rotation[1] ?? 0;
+    const [chairWidth] = chair;
+    const tableCorners = itemNodePlanCorners(table);
+    const center = [
+        tableCorners.reduce((sum, [x]) => sum + x, 0) / tableCorners.length,
+        tableCorners.reduce((sum, [, z]) => sum + z, 0) / tableCorners.length,
+    ];
+    /** A direction or a point in the table's own frame (x along its width, z along its front), on the plan. */
+    const world = (x, z) => [
+        x * Math.cos(turn) + z * Math.sin(turn),
+        -x * Math.sin(turn) + z * Math.cos(turn),
+    ];
+    const slots = [];
+    /** On the side whose outward normal is (nx, nz) in the table's frame, `lateral` along that side. */
+    const slot = (nx, nz, lateral = 0) => {
+        const [outX, outZ] = world(nx, nz);
+        const rotationDeg = chosenYaw(input, facingOf(-outX, -outZ));
+        // Separate the actual rectangles on this table-side normal, after the caller's yaw.
+        const tableReach = Math.max(...tableCorners.map(([x, z]) => (x - center[0]) * outX + (z - center[1]) * outZ));
+        const chairReach = -Math.min(...corners({ x: 0, z: 0, rotationDeg }, chair).map(([x, z]) => x * outX + z * outZ));
+        const reach = tableReach + chairReach + CHAIR_GAP;
+        const [x, z] = world(nx * reach + (nz !== 0 ? lateral : 0), nz * reach + (nz === 0 ? lateral : 0));
+        slots.push({
+            // Straight across its side, front to the table: facing the centre would turn a chair set beside the middle one.
+            rotationDeg,
+            x: center[0] + x,
+            z: center[1] + z,
+        });
+    };
+    const long = tw >= td
+        ? [
+            [0, 1],
+            [0, -1],
+        ]
+        : [
+            [1, 0],
+            [-1, 0],
+        ];
+    const ends = tw >= td
+        ? [
+            [1, 0],
+            [-1, 0],
+        ]
+        : [
+            [0, 1],
+            [0, -1],
+        ];
+    for (const [nx, nz] of long)
+        slot(nx, nz);
+    for (const [nx, nz] of ends)
+        slot(nx, nz);
+    const shift = chairWidth + 0.12;
+    for (const lateral of [shift, -shift, 2 * shift, -2 * shift])
+        for (const [nx, nz] of long)
+            slot(nx, nz, lateral);
+    return slots;
+}
+/**
+ * `place_in_room`: one floor-standing catalog item where it fits. A wall-bound piece (fridge, counter, bed, sofa,
+ * toilet) is set against a wall, centred in the widest free stretch of wall that clears every door
+ * and every other item, facing into the room, and is never set in the middle: when no wall has room
+ * the answer says how wide the widest stretch is. A free-standing piece (table, rug, plant) takes
+ * the middle of the room, or goes with what it belongs with and faces it (a coffee table and an
+ * armchair face the sofa). A chair is placed around its table facing it, and refused with no table.
+ */
+export const placeInRoom = (nodes, input, context) => {
+    for (const key of ['rotationDeg', 'offset', 'inset'])
+        if (input[key] !== undefined && !Number.isFinite(input[key]))
+            refuse('invalid_placement_options', `${key} must be a finite number.`);
+    if ((input.facing !== undefined && !['in', 'out'].includes(input.facing)) ||
+        (input.align !== undefined && !['center', 'start', 'end'].includes(input.align)))
+        refuse('invalid_placement_options', 'Use facing in/out and align center/start/end.');
+    if (input.clearanceAreas !== undefined &&
+        (!Array.isArray(input.clearanceAreas) ||
+            input.clearanceAreas.length > 128 ||
+            !input.clearanceAreas.every((area) => area &&
+                typeof area.id === 'string' &&
+                area.id.length > 0 &&
+                [area.minX, area.maxX, area.minZ, area.maxZ].every(Number.isFinite) &&
+                area.minX <= area.maxX &&
+                area.minZ <= area.maxZ)))
+        refuse('invalid_clearance_areas', 'Supply at most 128 finite normalized clearance rectangles with ids.');
+    const catalog = context.catalog;
+    if (!catalog)
+        refuse('no_catalog', 'This host has no item catalog to place from.');
+    const asset = catalog.find((entry) => entry.id === input.assetId);
+    if (!asset)
+        refuse('asset_not_found', `${input.assetId} is not in the item catalog: use an id search_assets returned.`, { assetId: input.assetId });
+    if (asset.attachTo !== undefined)
+        refuse('unsupported_attachment', `${asset.id} attaches to a ${asset.attachTo === 'ceiling' ? 'ceiling' : 'wall'}, not the room floor. Use place_items with targetNodeId naming its host${asset.attachTo === 'ceiling' ? '' : ' and y giving its bottom height above the floor'}.`, { assetId: asset.id, attachTo: asset.attachTo });
+    const { levelId, polygon } = roomToFurnish(nodes, input, context);
+    if (polygon.length > MAX_CORNERS)
+        refuse('polygon_too_large', `A room outline has at most ${MAX_CORNERS} corners; this one has ${polygon.length}.`, { corners: polygon.length });
+    if (!polygon.every((corner) => corner.length === 2 && corner.every(Number.isFinite)))
+        refuse('polygon_invalid', 'Every corner of the room outline must be a pair of finite numbers.');
+    const level = nodes[levelId];
+    if (level && levelRole(nodes, level).role === 'roof')
+        refuse('roof_level', `${level.name || level.id} is a roof level, not a storey.`, { levelId });
+    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}.`);
+    const all = Object.values(nodes);
+    const bounds = polygonBounds(polygon);
+    const room = {
+        bounds,
+        center: [bounds.centerX, bounds.centerZ],
+        doorKeepouts: collectDoorKeepouts(all, { levelId }).map((door) => door.aabb),
+        occupied: collectOccupiedFootprints(all, { floorOnly: true, levelId }).map((footprint) => footprint.aabb),
+        polygon,
+        options: input,
+        blockedClearanceIds: new Set(),
+    };
+    const inRoom = all.filter((node) => node.type === 'item' &&
+        node.parentId === levelId &&
+        pointInPolygon([node.position[0], node.position[2]], polygon, true));
+    const dims = itemDims({ asset });
+    const kind = furnitureKind(asset);
+    const wallTargeted = input.edge !== undefined ||
+        input.align !== undefined ||
+        input.offset !== undefined ||
+        input.inset !== undefined;
+    if (kind !== 'chair' &&
+        !input.allowDuplicate &&
+        inRoom.some((node) => node.asset.id === asset.id))
+        refuse('duplicate_item', `The room already has a ${asset.id}. Pass allowDuplicate to add another.`, { assetId: asset.id });
+    const named = (pattern) => new RegExp(pattern);
+    const refuseClearance = () => {
+        if (room.blockedClearanceIds.size)
+            refuse('stair_blocked', `No free spot for ${asset.id} clears the supplied clearance areas: ${[...room.blockedClearanceIds].join(', ')}.`, { assetId: asset.id, clearanceAreaIds: [...room.blockedClearanceIds] });
+    };
+    const place = (pose, where) => {
+        const node = ItemNode.parse({
+            asset,
+            name: asset.name,
+            parentId: levelId,
+            position: [pose.x, 0, pose.z],
+            rotation: [0, rad(pose.rotationDeg), 0],
+        });
+        return {
+            changes: { create: [{ node, parentId: levelId }] },
+            result: {
+                ok: true,
+                itemId: node.id,
+                kind,
+                placed: { position: [round(pose.x), round(pose.z)], rotationDeg: round(pose.rotationDeg) },
+                ...where,
+                message: `Placed ${asset.id} ${Object.keys(where).includes('around') ? 'around its table' : 'in the room'}.`,
+            },
+        };
+    };
+    // Without an explicit wall target, a chair goes around its table, or nowhere.
+    if (kind === 'chair' && !wallTargeted) {
+        const table = inRoom
+            .filter((node) => named('table|desk').test(nameOf(node)))
+            .sort((a, b) => Math.hypot(a.position[0] - room.center[0], a.position[2] - room.center[1]) -
+            Math.hypot(b.position[0] - room.center[0], b.position[2] - room.center[1]))[0];
+        if (!table)
+            refuse('no_table', `A ${asset.id} goes around a table, and this room has none: place the table first.`, { assetId: asset.id });
+        // The table is cleared by the oriented slot geometry; every other item still blocks.
+        const others = collectOccupiedFootprints(all, {
+            floorOnly: true,
+            levelId,
+            excludeIds: new Set([table.id]),
+        }).map((footprint) => footprint.aabb);
+        for (const slot of chairSlots(table, dims, input)) {
+            if (fits(room, slot, dims, undefined, others))
+                return place(slot, { around: table.id });
+        }
+        refuseClearance();
+        refuse('no_free_spot', `No free place is left around the table for another ${asset.id}: every side of ${table.id} that is clear of doors and walls is taken.`, { assetId: asset.id });
+    }
+    const edges = input.edge !== undefined ? [input.edge] : polygon.map((_, index) => index);
+    const wallPose = () => {
+        const runs = edges.flatMap((edge) => runsAlong(room, edge, dims));
+        const distance = (run) => {
+            const desired = desiredAlong(room, run.edge, dims);
+            return desired === undefined ? 0 : Math.max(run.from - desired, desired - run.to, 0);
+        };
+        runs.sort((a, b) => distance(a) - distance(b) || b.span - a.span);
+        for (const run of runs) {
+            const poses = [
+                poseInRun(room, run, dims),
+                wallPoseAt(room, run.edge, dims, run.from),
+                wallPoseAt(room, run.edge, dims, run.to),
+            ];
+            for (const pose of poses)
+                if (fits(room, pose, dims))
+                    return { against: run.edge, pose };
+        }
+        return null;
+    };
+    if (kind === 'free' && !wallTargeted) {
+        const anchorPattern = anchorOf(asset);
+        const anchor = anchorPattern
+            ? inRoom
+                .filter((node) => named(anchorPattern).test(nameOf(node)))
+                .sort((a, b) => Math.hypot(a.position[0] - room.center[0], a.position[2] - room.center[1]) -
+                Math.hypot(b.position[0] - room.center[0], b.position[2] - room.center[1]))[0]
+            : undefined;
+        const candidates = [];
+        const faceToward = (x, z, target) => ({
+            rotationDeg: facingOf(target[0] - x, target[1] - z),
+            x,
+            z,
+        });
+        if (anchor) {
+            const [aw, , ad] = itemDims(anchor);
+            const front = frontOf(((anchor.rotation[1] ?? 0) * 180) / Math.PI);
+            const target = [anchor.position[0], anchor.position[2]];
+            const reach = ad / 2 + 0.4 + dims[2] / 2;
+            candidates.push(faceToward(target[0] + front[0] * reach, target[1] + front[1] * reach, target));
+            const side = [front[1], -front[0]];
+            for (const sign of [1, -1])
+                candidates.push(faceToward(target[0] +
+                    front[0] * (ad / 2 + 0.5 + dims[2] / 2) +
+                    side[0] * sign * (aw / 2 + dims[0] / 2 + 0.2), target[1] +
+                    front[1] * (ad / 2 + 0.5 + dims[2] / 2) +
+                    side[1] * sign * (aw / 2 + dims[0] / 2 + 0.2), target));
+        }
+        // The middle of the room: facing what it belongs with, else its width along the room's long
+        // axis; and when that does not fit (a door's clear zone, a counter), the other turns.
+        const preferred = anchor
+            ? facingOf(anchor.position[0] - room.center[0], anchor.position[2] - room.center[1])
+            : room.bounds.width >= room.bounds.depth
+                ? 0
+                : 90;
+        for (const turn of anchor ? [0] : [0, 90, 180, 270])
+            candidates.push({
+                rotationDeg: anchor ? preferred : (preferred + turn) % 360,
+                x: room.center[0],
+                z: room.center[1],
+            });
+        for (const candidate of candidates) {
+            const pose = { ...candidate, rotationDeg: chosenYaw(input, candidate.rotationDeg) };
+            if (fits(room, pose, dims))
+                return place(pose, anchor ? { facing: anchor.id } : {});
+        }
+    }
+    const found = wallPose();
+    if (found)
+        return place(found.pose, {
+            against: {
+                edge: found.against,
+                wall: `edge ${found.against} of ${polygon.length}`,
+            },
+        });
+    refuseClearance();
+    const widest = widestFree(room, dims, edges);
+    refuse('no_free_spot', `No wall has room for ${asset.id} (${round(dims[0])} × ${round(dims[2])} m)${widest
+        ? `: the widest free stretch of wall is ${round(widest.span)} m, on edge ${widest.edge}`
+        : ': no wall of the room is free'}. A smaller one, another room, or remove something.`, {
+        assetId: asset.id,
+        widestFreeRunM: widest ? round(widest.span) : 0,
+        ...(widest ? { edge: widest.edge } : {}),
+    });
+};

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":"AAWA,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAOnE,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;AA6K5D;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CAuHtD,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;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"}

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

@@ -1,4 +1,5 @@
 import { refuse } from '../agent-tools/refusal.js';
+import { OUTSIDE_SOURCES } from '../agent-tools/sources.js';
 import { floorItemFit } from '../building/floor-item-fit.js';
 import { flushMountRotation, geometrySurfaceAt, geometryUndersideAt, mountsFlush, } from '../lib/geometry-surfaces.js';
 import { ItemNode } from '../schema/index.js';
@@ -6,6 +7,7 @@ import { getWallLocalFaceZ } from '../systems/wall/wall-frame.js';
 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';
 /**
  * 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
@@ -71,7 +73,7 @@ function onWall(wall, entry, asset) {
     const left = -dz * (entry.x - wall.start[0]) + dx * (entry.z - wall.start[1]) >= 0;
     const side = left ? 'front' : 'back';
     const z = asset.attachTo === 'wall-side' ? getWallLocalFaceZ(wall, left ? 'a' : 'b') : 0;
-    const turn = (left ? 0 : Math.PI) + ((entry.rotation ?? 0) * Math.PI) / 180;
+    const turn = left ? 0 : Math.PI;
     return {
         parentId: wall.id,
         position: [x, y, z],
@@ -176,6 +178,14 @@ export const placeItems = (nodes, input, context) => {
                 hostId: host.id,
                 ...(pose.side ? { side: pose.side } : {}),
                 ...(pose.restingOn ? { restingOn: pose.restingOn } : {}),
+                ...(host.type === 'wall' && entry.rotation !== undefined
+                    ? {
+                        info: {
+                            code: 'rotation_ignored',
+                            message: 'Rotation is ignored on a wall host: the item faces its selected wall side in the wall’s local frame.',
+                        },
+                    }
+                    : {}),
             };
         }
         // A floor: the level named, or the level holding the room or slab named.
@@ -188,10 +198,13 @@ export const placeItems = (nodes, input, context) => {
                     : null;
         if (!floorId || nodes[floorId]?.type !== 'level')
             return refused(assetId, 'unsupported_host', `A ${host?.type} hosts no item: name a wall, a ceiling, an item standing on the floor, or a room, slab or level for its floor.`);
+        const onRoofLevel = roofLevelRefusal(nodes, floorId, `"${asset.name}"`);
+        if (onRoofLevel)
+            return refused(assetId, onRoofLevel.code, onRoofLevel.message);
         const rooms = roomsOn(nodes, floorId);
         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.`);
+            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 });
         const misfit = floorFit(nodes, floorId, entry, asset, doorsOn[floorId]);
         if (misfit)

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,CAOvF;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,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

@@ -64,6 +64,9 @@ export function pointInBoundsWithPadding(x, z, bounds, padding) {
         z <= bounds.maxZ - padding);
 }
 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])
+        return distance2D(point, a) <= tolerance;
     const cross = (point[1] - a[1]) * (b[0] - a[0]) - (point[0] - a[0]) * (b[1] - a[1]);
     if (Math.abs(cross) > tolerance)
         return false;

package/dist/agent-operations/point-context.d.ts

@@ -0,0 +1,139 @@
+/**
+ * What a person pointed at in the scene, and from where: ids first, the picture as evidence.
+ *
+ * One shape for every surface that can carry it. The editor's Point and ask mode builds it; the
+ * chat sends it on the message (`metadata.pointContext`) and tells the agent to act on the ids; the
+ * hosted MCP can take the same object as a tool input later. `camera` is `view_scene`'s own
+ * `camera` input plus the projection, so the agent can look from the person's eye.
+ */
+export type PointContext = {
+    kind: 'scene-point';
+    version: 1;
+    /** "ask_…", minted where the person pointed: the pin, the chat chip and the turn share it. */
+    askId: string;
+    /** ISO time of the moment of pointing (pointer-down), not of sending. */
+    capturedAt: string;
+    source: 'editor' | 'mcp';
+    gesture: 'click' | 'multi' | 'region';
+    /** The level in view. */
+    level: {
+        id: string;
+        name: string;
+    };
+    /** Every pointed element, with no cap: a preview limit is for display, not for the agent. */
+    targets: PointTarget[];
+    /** A region's visible elements, by screen area, top 12; `more` counts the rest. */
+    inRegion?: {
+        ids: string[];
+        more: number;
+    };
+    camera: PointCamera;
+    /** [left, top, right, bottom], each 0–1 of the full frame. */
+    region?: [number, number, number, number];
+    /** The crop. `marked`: the targets are outlined in it. */
+    image?: PointImage;
+    /** The id of the suggestion chip when one was sent as it is. */
+    suggestion?: string;
+};
+export type PointTarget = {
+    /** Authoritative: read it with `get_node` before changing it. */
+    id: string;
+    /** The node type: 'zone' | 'wall' | 'window' | 'door' | 'item' | … */
+    type: string;
+    /** "Kitchen", "Wall, north side of Kitchen", "Sofa, Oslo 3-seat". */
+    name: string;
+    levelId: string;
+    /** The room it is in or bounds. */
+    zoneId?: string;
+    /** The wall an opening is in, the item an item stands on. */
+    parentId?: string;
+    /** Where the finger landed, in world metres. */
+    hit?: {
+        point: [number, number, number];
+        normal: [number, number, number];
+        face?: 'interior' | 'exterior' | 'top' | 'bottom';
+    };
+    box: {
+        min: [number, number, number];
+        max: [number, number, number];
+    };
+    /** Metres: wall {length, height, thickness}; zone {area, width, depth}; opening {width, height, sill}; item {width, depth, height}. */
+    size: Record<string, number>;
+};
+export type PointCamera = {
+    position: [number, number, number];
+    target: [number, number, number];
+    fov: number;
+    aspect: number;
+    projection: 'perspective' | 'orthographic';
+    /** Orthographic only. */
+    viewWidth?: number;
+};
+export type PointImage = {
+    /** Where the crop is stored, once the chat has uploaded it. */
+    url?: string;
+    /** The crop as the editor captured it, before it is uploaded. */
+    dataUrl?: string;
+    width: number;
+    height: number;
+    marked: boolean;
+};
+/** What the editor hands the chat when the person sends an ask. */
+export type PointAskSubmit = {
+    askId: string;
+    /** The person's words. */
+    text: string;
+    context: PointContext;
+    /** The bubble text's screen rect in CSS px, where the message's flight starts. */
+    from: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+/**
+ * The chat's answer to a submit. `busy`: Pascal is on a turn and the host does not queue asks, so
+ * the bubble keeps its words and says so.
+ */
+export type PointAskSubmitResult = {
+    ok: true;
+} | {
+    ok: false;
+    code: 'busy' | 'out_of_credits' | 'unavailable' | 'error';
+    message: string;
+};
+/** What the chat tells the pin about the ask's turn. */
+export type PointAskStatus = {
+    askId: string;
+    turnId?: string;
+} /** Pascal is on another turn: the ask waits as its own turn, never steered into it. */ & ({
+    status: 'queued';
+}
+/** The turn started or its live sentence changed. */
+ | {
+    status: 'working';
+    sentence?: string;
+}
+/** The turn is waiting for the person's answer to a question. */
+ | {
+    status: 'asking';
+    question: string;
+} | {
+    status: 'ended';
+    outcome: 'completed' | 'cancelled' | 'errored';
+    /** The turn ended while still waiting on a question. */
+    asked: boolean;
+    /** The turn made at least one successful scene-writing tool call. */
+    wroteScene: boolean;
+    /** The final reply text. */
+    answer?: string;
+    /** What went wrong, in words. */
+    error?: string;
+});
+/** What the pin tells the chat: its turn lights on hover and opens on click. */
+export type PointAskPin = {
+    askId: string;
+    action: 'hover' | 'leave' | 'open';
+};
+//# sourceMappingURL=point-context.d.ts.map

package/dist/agent-operations/point-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"point-context.d.ts","sourceRoot":"","sources":["../../src/agent-operations/point-context.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,aAAa,CAAA;IACnB,OAAO,EAAE,CAAC,CAAA;IACV,8FAA8F;IAC9F,KAAK,EAAE,MAAM,CAAA;IACb,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,QAAQ,GAAG,KAAK,CAAA;IACxB,OAAO,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAA;IACrC,yBAAyB;IACzB,KAAK,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IACnC,6FAA6F;IAC7F,OAAO,EAAE,WAAW,EAAE,CAAA;IACtB,mFAAmF;IACnF,QAAQ,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1C,MAAM,EAAE,WAAW,CAAA;IACnB,8DAA8D;IAC9D,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACzC,0DAA0D;IAC1D,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,iEAAiE;IACjE,EAAE,EAAE,MAAM,CAAA;IACV,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAA;IACZ,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,mCAAmC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gDAAgD;IAChD,GAAG,CAAC,EAAE;QACJ,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;QAC/B,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;QAChC,IAAI,CAAC,EAAE,UAAU,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,CAAA;KAClD,CAAA;IACD,GAAG,EAAE;QAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;IACrE,uIAAuI;IACvI,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,aAAa,GAAG,cAAc,CAAA;IAC1C,yBAAyB;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,+DAA+D;IAC/D,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,iEAAiE;IACjE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,mEAAmE;AACnE,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,YAAY,CAAA;IACrB,kFAAkF;IAClF,IAAI,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAC9D,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GACZ;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,aAAa,GAAG,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7F,wDAAwD;AACxD,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAC,uFAAuF,GAAG,CACxF;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE;AACtB,qDAAqD;GACnD;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE;AAC1C,iEAAiE;GAC/D;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACtC;IACE,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAAA;IAC9C,wDAAwD;IACxD,KAAK,EAAE,OAAO,CAAA;IACd,qEAAqE;IACrE,UAAU,EAAE,OAAO,CAAA;IACnB,4BAA4B;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CACJ,CAAA;AAED,gFAAgF;AAChF,MAAM,MAAM,WAAW,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,CAAA;CAAE,CAAA"}

package/dist/agent-operations/point-context.js

@@ -0,0 +1 @@
+export {};