@pascal-app/core 1.0.3 → 1.0.4

package/dist/agent-operations/apply-outcome.d.ts

@@ -0,0 +1,15 @@
+import type { AgentOperationOutcome, SceneChanges, SceneNodes } from './types.js';
+/** What a surface lends an operation's outcome: its scene, its writes and its reconciler. */
+export type AgentHostRuntime = {
+    getNodes: () => SceneNodes;
+    applyChanges: (changes: SceneChanges) => void;
+    /** Derive construction from the scene as it now is: rooms, auto ceilings, floor plates. */
+    reconcile: () => void;
+};
+/**
+ * Applies an operation's outcome through a host and returns the answer: its changes, then for an
+ * outcome that reads derived construction, the reconcile, its follow-up changes and a second
+ * reconcile. The host frames the call as one undo step.
+ */
+export declare function applyAgentOutcome(outcome: AgentOperationOutcome, runtime: AgentHostRuntime): Record<string, unknown>;
+//# sourceMappingURL=apply-outcome.d.ts.map

package/dist/agent-operations/apply-outcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-outcome.d.ts","sourceRoot":"","sources":["../../src/agent-operations/apply-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAE9E,6FAA6F;AAC7F,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,MAAM,UAAU,CAAA;IAC1B,YAAY,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,CAAA;IAC7C,2FAA2F;IAC3F,SAAS,EAAE,MAAM,IAAI,CAAA;CACtB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,gBAAgB,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUzB"}

package/dist/agent-operations/apply-outcome.js

@@ -0,0 +1,18 @@
+/**
+ * Applies an operation's outcome through a host and returns the answer: its changes, then for an
+ * outcome that reads derived construction, the reconcile, its follow-up changes and a second
+ * reconcile. The host frames the call as one undo step.
+ */
+export function applyAgentOutcome(outcome, runtime) {
+    if (outcome.changes)
+        runtime.applyChanges(outcome.changes);
+    if (!outcome.afterReconcile)
+        return outcome.result;
+    runtime.reconcile();
+    const settled = outcome.afterReconcile(runtime.getNodes());
+    if (settled.changes) {
+        runtime.applyChanges(settled.changes);
+        runtime.reconcile();
+    }
+    return settled.result;
+}

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

@@ -0,0 +1,28 @@
+import { type Collection, type CollectionId, type CollectionTemplateId } from '../schema/index.js';
+import type { AgentOperationOutcome, SceneNodes } from './types.js';
+/** What the collection tools read: the nodes and the scene's collections. */
+export type CollectionScene = {
+    nodes: SceneNodes;
+    collections: Readonly<Record<string, Collection>>;
+};
+export type EditCollectionInput = {
+    collectionId?: string;
+    template?: CollectionTemplateId;
+    name?: string;
+    color?: string;
+    add?: string[];
+    remove?: string[];
+    delete?: boolean;
+};
+/** The scene's collections after `writes` (a surface applies `SceneChanges.collections` with it). */
+export declare function writeCollections(current: Readonly<Record<string, Collection>>, writes: Readonly<Record<string, Collection | null>>): Record<CollectionId, Collection>;
+/**
+ * `edit_collection`: one collection created, changed or deleted. Without an id the call works on
+ * the scene's collection with the template, or else the name, and creates it when there is none.
+ */
+export declare function editCollection(scene: CollectionScene, input: EditCollectionInput): AgentOperationOutcome;
+/** `list_collections`: the scene's collections with their elements, and the templates. */
+export declare function listCollections(scene: CollectionScene, { collectionId }: {
+    collectionId?: string;
+}): AgentOperationOutcome;
+//# sourceMappingURL=collections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/agent-operations/collections.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,oBAAoB,EAE1B,MAAM,WAAW,CAAA;AAElB,OAAO,KAAK,EAAE,qBAAqB,EAAgB,UAAU,EAAE,MAAM,SAAS,CAAA;AAE9E,6EAA6E;AAC7E,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,UAAU,CAAA;IACjB,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;CAClD,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,oBAAoB,CAAA;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,CAAC,EAAE,MAAM,EAAE,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,qGAAqG;AACrG,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,EAC7C,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC,CAAC,GAClD,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAOlC;AA0DD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,mBAAmB,GACzB,qBAAqB,CAoDvB;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,CAC7B,KAAK,EAAE,eAAe,EACtB,EAAE,YAAY,EAAE,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1C,qBAAqB,CAWvB"}

package/dist/agent-operations/collections.js

@@ -0,0 +1,130 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { COLLECTION_TEMPLATES, generateCollectionId, } from '../schema/index.js';
+import { levelIdOf } from './scene-queries.js';
+/** The scene's collections after `writes` (a surface applies `SceneChanges.collections` with it). */
+export function writeCollections(current, writes) {
+    const next = { ...current };
+    for (const [id, collection] of Object.entries(writes)) {
+        if (collection)
+            next[id] = collection;
+        else
+            delete next[id];
+    }
+    return next;
+}
+function describeCollection({ nodes }, collection) {
+    const elements = collection.nodeIds.flatMap((id) => {
+        const node = nodes[id];
+        if (!node)
+            return [];
+        return [
+            {
+                id,
+                name: node.name ?? (node.type === 'item' ? node.asset.name : undefined),
+                type: node.type,
+                levelId: levelIdOf(nodes, id),
+            },
+        ];
+    });
+    return {
+        id: collection.id,
+        name: collection.name,
+        ...(collection.color ? { color: collection.color } : {}),
+        ...(collection.template ? { template: collection.template } : {}),
+        count: elements.length,
+        elements,
+    };
+}
+function collectionById({ collections }, collectionId) {
+    const collection = collections[collectionId];
+    if (!collection)
+        refuse('collection_not_found', `Collection not found: ${collectionId}.`, { collectionId });
+    return collection;
+}
+/** Items mirror their membership in `collectionIds`, as the editor's own collection actions do. */
+function itemMirrorUpdates(nodes, collectionId, before, after) {
+    const members = new Set(after);
+    const updates = [];
+    for (const id of new Set([...before, ...after])) {
+        const node = nodes[id];
+        if (node?.type !== 'item')
+            continue;
+        const current = node.collectionIds ?? [];
+        if (current.includes(collectionId) === members.has(id))
+            continue;
+        updates.push({
+            id,
+            data: {
+                collectionIds: members.has(id)
+                    ? [...current, collectionId]
+                    : current.filter((other) => other !== collectionId),
+            },
+        });
+    }
+    return updates;
+}
+/**
+ * `edit_collection`: one collection created, changed or deleted. Without an id the call works on
+ * the scene's collection with the template, or else the name, and creates it when there is none.
+ */
+export function editCollection(scene, input) {
+    const all = Object.values(scene.collections);
+    const nameKey = input.name?.toLowerCase();
+    const existing = input.collectionId
+        ? collectionById(scene, input.collectionId)
+        : input.template
+            ? all.find((collection) => collection.template === input.template)
+            : nameKey
+                ? all.find((collection) => collection.name.toLowerCase() === nameKey)
+                : refuse('collection_required', 'Pass a collectionId, a template or a name.');
+    if (input.delete) {
+        if (!existing)
+            refuse('collection_not_found', `No collection named ${input.name ?? input.template}.`);
+        return {
+            result: { deletedId: existing.id, name: existing.name },
+            changes: {
+                collections: { [existing.id]: null },
+                update: itemMirrorUpdates(scene.nodes, existing.id, existing.nodeIds, []),
+            },
+        };
+    }
+    const missing = (input.add ?? []).filter((id) => !scene.nodes[id]);
+    if (missing.length)
+        refuse('node_not_found', `Not in the scene: ${missing.join(', ')}.`, { ids: missing });
+    const preset = input.template ? COLLECTION_TEMPLATES[input.template] : undefined;
+    const base = existing ?? {
+        id: generateCollectionId(),
+        name: preset?.name ?? input.name,
+        ...(preset ? { color: preset.color } : {}),
+        nodeIds: [],
+    };
+    const removed = new Set(input.remove ?? []);
+    const nodeIds = [...new Set([...base.nodeIds, ...(input.add ?? [])])].filter((id) => !removed.has(id));
+    const next = {
+        ...base,
+        ...(input.name ? { name: input.name } : {}),
+        ...(input.color ? { color: input.color } : {}),
+        ...(input.template ? { template: input.template } : {}),
+        nodeIds,
+    };
+    return {
+        result: { created: !existing, collection: describeCollection(scene, next) },
+        changes: {
+            collections: { [next.id]: next },
+            update: itemMirrorUpdates(scene.nodes, next.id, base.nodeIds, nodeIds),
+        },
+    };
+}
+/** `list_collections`: the scene's collections with their elements, and the templates. */
+export function listCollections(scene, { collectionId }) {
+    const collections = collectionId
+        ? [collectionById(scene, collectionId)]
+        : Object.values(scene.collections);
+    return {
+        result: {
+            count: collections.length,
+            collections: collections.map((collection) => describeCollection(scene, collection)),
+            templates: Object.entries(COLLECTION_TEMPLATES).map(([id, { name }]) => ({ id, name })),
+        },
+    };
+}

package/dist/agent-operations/create-room.d.ts

@@ -0,0 +1,36 @@
+import { type LevelTargetInput } from './level-target.js';
+import { type Vec2 } from './plan-geometry.js';
+import type { AgentOperation } from './types.js';
+type OpeningSpec = {
+    wallIndex: number;
+    t?: number;
+    width?: number;
+    height?: number;
+    sillHeight?: number;
+    hingesSide?: 'left' | 'right';
+    swingDirection?: 'inward' | 'outward';
+    style?: string;
+};
+type CreateRoomInput = LevelTargetInput & {
+    name: string;
+    polygon: number[][];
+    color?: string;
+    wallHeight?: number;
+    wallThickness?: number;
+    outdoor?: boolean;
+    doors?: OpeningSpec[];
+    windows?: OpeningSpec[];
+};
+/** Distance from `point` to the line through a and b, and where it projects along a → b (0..1). */
+export declare function edgeProjection(a: Vec2, b: Vec2, point: readonly number[]): {
+    distance: number;
+    t: number;
+};
+/**
+ * `create_room`: the editor's room command — walls where no wall runs yet, the zone that names the
+ * room — then the doors and windows declared by polygon edge, each placed as add_door / add_window
+ * place one. The floor plate and the ceiling are the host's to derive; the result reads them back.
+ */
+export declare const createRoom: AgentOperation<CreateRoomInput>;
+export {};
+//# sourceMappingURL=create-room.d.ts.map

package/dist/agent-operations/create-room.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-room.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-room.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AACnE,OAAO,EAAe,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAExD,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,SAAS,CAAA;AAEzD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IAC7B,cAAc,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;IACrC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,KAAK,eAAe,GAAG,gBAAgB,GAAG;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,EAAE,EAAE,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,WAAW,EAAE,CAAA;IACrB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAA;CACxB,CAAA;AAYD,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE;;;EAWxE;AA+CD;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CA+HtD,CAAA"}

package/dist/agent-operations/create-room.js

@@ -0,0 +1,177 @@
+import { isAgentRefusal, refuse } from '../agent-tools/refusal.js';
+import { doorFacing, planWallOpening } from '../building/wall-openings.js';
+import { createZone } from '../commands/structure/create-zone.js';
+import { structureChangeBatch } from '../commands/structure/shared.js';
+import { generateId } from '../schema/index.js';
+import { applySceneChanges } from './apply-changes.js';
+import { targetLevel } from './level-target.js';
+import { polygonArea } from './plan-geometry.js';
+import { levelRole } from './scene-queries.js';
+// A wall counts as running along a polygon edge when both its ends sit this close to the edge's line.
+const EDGE_TOLERANCE = 0.2;
+const lerp = (a, b, t) => [
+    a[0] + (b[0] - a[0]) * t,
+    a[1] + (b[1] - a[1]) * t,
+];
+/** Distance from `point` to the line through a and b, and where it projects along a → b (0..1). */
+export function edgeProjection(a, b, point) {
+    const dx = b[0] - a[0];
+    const dz = b[1] - a[1];
+    const lengthSq = dx * dx + dz * dz;
+    if (lengthSq < 1e-12)
+        return { distance: Math.hypot(point[0] - a[0], point[1] - a[1]), t: 0 };
+    const rx = point[0] - a[0];
+    const rz = point[1] - a[1];
+    return {
+        distance: Math.abs(rx * dz - rz * dx) / Math.sqrt(lengthSq),
+        t: (rx * dx + rz * dz) / lengthSq,
+    };
+}
+const wallsOn = (nodes, levelId) => Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === levelId);
+/** The walls of the level that run along the edge a → b, both ends on its line. */
+function wallsAlong(nodes, levelId, a, b) {
+    return wallsOn(nodes, levelId).filter((wall) => {
+        const start = edgeProjection(a, b, wall.start);
+        const end = edgeProjection(a, b, wall.end);
+        return (start.distance < EDGE_TOLERANCE &&
+            end.distance < EDGE_TOLERANCE &&
+            Math.min(1, Math.max(start.t, end.t)) - Math.max(0, Math.min(start.t, end.t)) > 1e-6);
+    });
+}
+/**
+ * Where on which wall a point of a polygon edge falls: by position among the walls of the room's
+ * own level, never by the id a wall had — walls split and join, and the floor below has walls on
+ * the same line.
+ */
+function wallAt(nodes, levelId, a, b, point) {
+    for (const wall of wallsAlong(nodes, levelId, a, b)) {
+        const { t } = edgeProjection(wall.start, wall.end, point);
+        if (t >= -1e-6 && t <= 1 + 1e-6)
+            return { wallId: wall.id, t: Math.min(1, Math.max(0, t)) };
+    }
+    return null;
+}
+/** The construction the host derived for the room: its floor plate and its ceiling. */
+function derivedSurfaces(nodes, levelId, zoneId) {
+    const children = Object.values(nodes).filter((node) => node.parentId === levelId);
+    const slab = children.find((node) => node.type === 'slab' && node.boundary === 'auto' && node.zoneIds?.includes(zoneId));
+    const ceiling = children.find((node) => node.type === 'ceiling' && node.boundary === 'auto' && node.zoneId === zoneId);
+    return { slabId: slab?.id ?? null, ceilingId: ceiling?.id ?? null };
+}
+const plural = (count, noun) => `${count} ${noun}${count === 1 ? '' : 's'}`;
+/**
+ * `create_room`: the editor's room command — walls where no wall runs yet, the zone that names the
+ * room — then the doors and windows declared by polygon edge, each placed as add_door / add_window
+ * place one. The floor plate and the ceiling are the host's to derive; the result reads them back.
+ */
+export const createRoom = (nodes, input, context) => {
+    const level = targetLevel(nodes, input, context);
+    if (levelRole(nodes, level).role === 'roof')
+        refuse('roof_level', `${level.name || level.id} is a roof level, not a storey: build the room on the storey below it.`, { levelId: level.id });
+    const polygon = input.polygon;
+    let plan;
+    try {
+        plan = createZone(nodes, {
+            levelId: level.id,
+            polygon,
+            name: input.name,
+            enclose: !input.outdoor,
+            ...(input.outdoor
+                ? { intent: { hasCeiling: false } }
+                : {
+                    wall: {
+                        ...(input.wallHeight === undefined ? {} : { height: input.wallHeight }),
+                        ...(input.wallThickness === undefined ? {} : { thickness: input.wallThickness }),
+                    },
+                }),
+            mintId: generateId,
+        });
+    }
+    catch (error) {
+        if (!(error instanceof Error && error.name === 'Error'))
+            throw error;
+        if (/valid polygon/.test(error.message))
+            refuse('invalid_polygon', 'The polygon is not a room: give at least three corners in order, edges that do not cross, an area above 0.01 m².');
+        refuse('cannot_enclose', error.message, { levelId: level.id });
+    }
+    // The refusal takes the conflict's own code: today createZone reports only a terrace overlapping
+    // a room (outdoor-room-overlap), and an indoor conflict must not borrow that name.
+    if (plan.conflicts?.length)
+        refuse(plan.conflicts[0].code.replaceAll('-', '_'), plan.conflicts.map((conflict) => conflict.message).join(' '), { conflicts: plan.conflicts });
+    const roomChanges = structureChangeBatch(plan.changes);
+    if (input.color)
+        roomChanges.create = roomChanges.create.map((entry) => entry.node.id === plan.zoneId
+            ? { ...entry, node: { ...entry.node, color: input.color } }
+            : entry);
+    let scene = applySceneChanges(nodes, roomChanges);
+    const openings = [];
+    const skippedOpenings = [];
+    const place = (kind, specs = []) => specs.flatMap(({ wallIndex, t = 0.5, ...spec }, index) => {
+        const skip = (code, message) => {
+            skippedOpenings.push({ kind, index, code, message });
+            return [];
+        };
+        if (wallIndex >= polygon.length)
+            return skip('edge_out_of_range', `The polygon has ${polygon.length} edges (0–${polygon.length - 1}); there is no edge ${wallIndex}.`);
+        const a = polygon[wallIndex];
+        const b = polygon[(wallIndex + 1) % polygon.length];
+        const host = wallAt(scene, level.id, a, b, lerp(a, b, t));
+        if (!host)
+            return skip('no_wall', `No wall runs along edge ${wallIndex} at t ${t}.`);
+        try {
+            const planned = planWallOpening(scene, { kind, ...spec, wallId: host.wallId, t: host.t });
+            const create = { node: planned.node, parentId: planned.wallId };
+            scene = applySceneChanges(scene, { create: [create] });
+            openings.push(create);
+            return [planned.node.id];
+        }
+        catch (error) {
+            if (!isAgentRefusal(error))
+                throw error;
+            return skip(error.code, error.message);
+        }
+    });
+    const doorIds = place('door', input.doors);
+    const windowIds = place('window', input.windows);
+    const wallIds = polygon.map((a, i) => wallsAlong(scene, level.id, a, polygon[(i + 1) % polygon.length])[0]?.id ?? null);
+    const reusedWalls = wallIds.filter((id) => id && nodes[id]).length;
+    const result = {
+        ok: true,
+        zoneId: plan.zoneId,
+        wallIds,
+        reusedWalls,
+        areaSqMeters: Math.round(polygonArea(polygon) * 100) / 100,
+        doorIds,
+        windowIds,
+        ...(skippedOpenings.length ? { skippedOpenings } : {}),
+        message: [
+            `Created ${input.outdoor ? 'outdoor room' : 'room'} "${input.name}" on ${level.name || level.id}`,
+            ...(reusedWalls ? [`reused ${plural(reusedWalls, 'wall')} already there`] : []),
+            ...(doorIds.length ? [plural(doorIds.length, 'door')] : []),
+            ...(windowIds.length ? [plural(windowIds.length, 'window')] : []),
+            ...(skippedOpenings.length
+                ? [`skipped ${plural(skippedOpenings.length, 'opening')} (see skippedOpenings)`]
+                : []),
+        ].join(', '),
+    };
+    return {
+        result,
+        changes: { ...roomChanges, create: [...roomChanges.create, ...openings] },
+        // The doors were planned before the host derived the room, so a new wall did not know its
+        // outside yet; once it does, a door on an outside wall faces out, as add_door's does.
+        afterReconcile: (derived) => {
+            const update = doorIds.flatMap((id) => {
+                const door = derived[id];
+                const wall = derived[door?.parentId ?? ''];
+                if (door?.type !== 'door' || wall?.type !== 'wall')
+                    return [];
+                const facing = doorFacing(wall);
+                return facing.side && facing.side !== door.side ? [{ id, data: facing }] : [];
+            });
+            return {
+                result: { ...result, ...derivedSurfaces(derived, level.id, plan.zoneId) },
+                ...(update.length ? { changes: { update } } : {}),
+            };
+        },
+    };
+};

package/dist/agent-operations/create-stair.d.ts

@@ -0,0 +1,33 @@
+import { type LevelTargetInput } from './level-target.js';
+import type { AgentOperation } from './types.js';
+type CreateStairInput = LevelTargetInput & {
+    x: number;
+    z: number;
+    rotation?: number;
+    width?: number;
+    length?: number;
+    height?: number;
+    steps?: number;
+    toLevelId?: string;
+    railingMode?: 'none' | 'left' | 'right' | 'both';
+    materialPreset?: string;
+    name?: string;
+    createDestinationSlabOpening?: boolean;
+    createSourceCeilingOpening?: boolean;
+    destinationSlabId?: string;
+    sourceCeilingId?: string;
+    openingWidth?: number;
+    openingLength?: number;
+    openingOffset?: number;
+    openingCenter?: [number, number];
+    openingRotation?: number;
+};
+/**
+ * `create_stair`: a straight flight placed as the editor's stair tool places one — rising to the
+ * next level (made when there is none), its floor openings owned and cut by the stair. With the
+ * opening controls create_stair_between_levels had, the opening is cut as given instead, owned by
+ * the stair as main's are, and the stair's own opening is off so nothing is cut twice.
+ */
+export declare const createStair: AgentOperation<CreateStairInput>;
+export {};
+//# sourceMappingURL=create-stair.d.ts.map

package/dist/agent-operations/create-stair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-stair.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-stair.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,gBAAgB,EAA6B,MAAM,gBAAgB,CAAA;AAIjF,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAA;AAE3D,KAAK,gBAAgB,GAAG,gBAAgB,GAAG;IACzC,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAA;IAChD,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,4BAA4B,CAAC,EAAE,OAAO,CAAA;IACtC,0BAA0B,CAAC,EAAE,OAAO,CAAA;IACpC,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAsCD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,gBAAgB,CA4OxD,CAAA"}