@pascal-app/core 1.0.4 → 1.0.5

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

@@ -2,109 +2,122 @@ import { refuse } from '../agent-tools/refusal.js';
 import { levelBuildingId } from '../building/level-duplication.js';
 import { cutFloorOpening } from '../commands/structure/floor-opening.js';
 import { adjacentLevelId } from '../lib/floor-opening-intent.js';
+import { area, intersection } from '../lib/polygon-boolean.js';
 import { generateId, LevelNode, StairNode } from '../schema/index.js';
 import { DEFAULT_LEVEL_HEIGHT } from '../services/level-height.js';
+import { getLevelFloorToFloorHeight } from '../services/storey.js';
 import { planOwnedFloorOpenings } from '../systems/owned-floor-openings.js';
-import { planStairCreation } from '../systems/stair/stair-sizing.js';
-import { refuseRoofLevel } from './add-wall.js';
+import { rotateXZ, stairArrivalOpening, stairFootprintAABB, stairSegmentFootprints, } from '../systems/stair/stair-footprint.js';
+import { planStairPreset } from '../systems/stair/stair-presets.js';
 import { applySceneChanges } from './apply-changes.js';
 import { requireLevel, targetLevel } from './level-target.js';
 import { finishSurface, requireMaterialRef } from './material-refs.js';
-import { pointInPolygon } from './plan-geometry.js';
+import { refuseRoofLevel } from './roof-writes.js';
 import { levelsOf } from './scene-queries.js';
 /** The margin round a stair's opening when none is given, as the editor's stair tool cuts it. */
 const OPENING_MARGIN = 0.08;
+const KIND = { straight: 'a staircase', l: 'an L staircase', u: 'a U staircase' };
+const round = (value) => Math.round(value * 1000) / 1000;
 /**
- * The opening as asked, in level metres: its size plus the margin on every side, round its centre
- * (by default the middle of the flight, along the climb), turned as asked (by default with the
- * flight). An item's turn: local (dx, dz) goes to (cx + dx·cos + dz·sin, cz − dx·sin + dz·cos).
+ * The opening as asked, in level metres: its size plus the margin on every side, round its centre,
+ * turned as asked. By default it is the stair's footprint in the stair's own frame (`box`), turned
+ * with the stair.
  */
-function openingRing(stair, input) {
+function openingRing(stair, box, input) {
     const margin = input.openingOffset ?? OPENING_MARGIN;
     const half = [
-        (input.openingWidth ?? stair.width) / 2 + margin,
-        (input.openingLength ?? stair.length) / 2 + margin,
+        (input.openingWidth ?? box.maxX - box.minX) / 2 + margin,
+        (input.openingLength ?? box.maxZ - box.minZ) / 2 + margin,
     ];
+    const middle = rotateXZ((box.minX + box.maxX) / 2, (box.minZ + box.maxZ) / 2, stair.rotation);
     const [cx, cz] = input.openingCenter ?? [
-        stair.x + (stair.length / 2) * Math.sin(stair.turn),
-        stair.z + (stair.length / 2) * Math.cos(stair.turn),
+        stair.position[0] + middle[0],
+        stair.position[2] + middle[1],
     ];
-    const turn = input.openingRotation === undefined ? stair.turn : (input.openingRotation * Math.PI) / 180;
-    const [cos, sin] = [Math.cos(turn), Math.sin(turn)];
+    const turn = input.openingRotation === undefined ? stair.rotation : (input.openingRotation * Math.PI) / 180;
     return [
-        [-half[0], -half[1]],
-        [half[0], -half[1]],
-        [half[0], half[1]],
-        [-half[0], half[1]],
-    ].map(([dx, dz]) => [cx + dx * cos + dz * sin, cz - dx * sin + dz * cos]);
+        [-1, -1],
+        [1, -1],
+        [1, 1],
+        [-1, 1],
+    ].map(([sx, sz]) => {
+        const [dx, dz] = rotateXZ(sx * half[0], sz * half[1], turn);
+        return [cx + dx, cz + dz];
+    });
+}
+/** The flights and landings, as fit_stair lays them out; a layout that cannot be built is refused. */
+function planFlights(draft, nodes, options) {
+    try {
+        return planStairPreset(draft, nodes, options);
+    }
+    catch (error) {
+        if (error instanceof RangeError)
+            refuse('stair_layout', `${error.message}.`, {
+                layout: options.layout,
+                ...(options.stepCount === undefined ? {} : { steps: options.stepCount }),
+                ...(options.lowerStepCount === undefined ? {} : { lowerSteps: options.lowerStepCount }),
+            });
+        throw error;
+    }
 }
 /**
- * `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.
+ * `create_stair`: a straight, L or U stair 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 — or a
+ * flight to no level, which rises as asked and cuts nothing. 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 const createStair = (nodes, input, context) => {
     const from = targetLevel(nodes, input, context);
     refuseRoofLevel(nodes, from.id, 'a stair');
+    const layout = input.layout ?? 'straight';
+    if (layout === 'straight' && (input.turn || input.lowerSteps !== undefined))
+        refuse('stair_layout_required', 'turn and lowerSteps shape an L or U stair: give layout "l" or "u", or leave them out.', { levelId: from.id });
     const preset = input.materialPreset === undefined
         ? undefined
         : requireMaterialRef(input.materialPreset, 'materialPreset', finishSurface('stair'));
+    const railingPreset = input.railingMaterial === undefined
+        ? undefined
+        : requireMaterialRef(input.railingMaterial, 'railingMaterial');
+    const toNoLevel = input.toLevelId === null;
+    // An opening of its own size, centre or turn, or through a surface named.
+    const shaped = [
+        input.destinationSlabId,
+        input.sourceCeilingId,
+        input.openingWidth,
+        input.openingLength,
+        input.openingCenter,
+        input.openingRotation,
+    ].some((value) => value !== undefined);
+    if (toNoLevel &&
+        (shaped ||
+            input.openingOffset !== undefined ||
+            input.createDestinationSlabOpening ||
+            input.createSourceCeilingOpening))
+        refuse('no_level_above', 'A flight to no level cuts no opening: name the level it arrives on (toLevelId), or leave the opening out.', { levelId: from.id });
     if (input.destinationSlabId && nodes[input.destinationSlabId]?.type !== 'slab')
         refuse('slab_not_found', `No slab ${input.destinationSlabId}: name the slab the flight arrives through, or leave it out.`, { slabId: input.destinationSlabId });
     if (input.sourceCeilingId && nodes[input.sourceCeilingId]?.type !== 'ceiling')
         refuse('ceiling_not_found', `No ceiling ${input.sourceCeilingId}: name the ceiling the flight rises through, or leave it out.`, { ceilingId: input.sourceCeilingId });
-    const cutFloor = input.createDestinationSlabOpening !== false;
-    const cutCeiling = input.createSourceCeilingOpening !== false;
-    const asGiven = cutFloor !== cutCeiling ||
-        [
-            input.destinationSlabId,
-            input.sourceCeilingId,
-            input.openingWidth,
-            input.openingLength,
-            input.openingCenter,
-            input.openingRotation,
-        ].some((value) => value !== undefined);
+    const cutFloor = !toNoLevel && input.createDestinationSlabOpening !== false;
+    const cutCeiling = !toNoLevel && input.createSourceCeilingOpening !== false;
+    const asGiven = cutFloor !== cutCeiling || shaped;
     const owned = cutFloor && cutCeiling && !asGiven;
-    const buildingId = levelBuildingId(nodes, from);
-    const building = buildingId ? nodes[buildingId] : undefined;
-    if (building?.type !== 'building')
-        refuse('no_building', `Level ${from.id} is not in a building, so it has no floor above.`, {
-            levelId: from.id,
-        });
-    const floors = levelsOf(nodes).filter((level) => level.parentId === building.id || building.children.includes(level.id));
     const changes = {
         create: [],
         update: [],
         delete: [],
         collections: {},
     };
-    let upper = input.toLevelId
-        ? requireLevel(nodes, input.toLevelId)
-        : floors.find((level) => level.level > from.level);
-    if (upper && (upper.level <= from.level || !floors.includes(upper)))
-        refuse('not_above', `${upper.id} is not above ${from.id} in its building: a flight rises to a higher floor.`, { levelId: from.id, toLevelId: upper.id });
-    if (upper)
-        refuseRoofLevel(nodes, upper.id, 'a stair');
-    // The flight cuts the slab of the floor it arrives at and the ceiling of the one it leaves.
-    if (input.destinationSlabId && nodes[input.destinationSlabId].parentId !== upper?.id)
-        refuse('slab_not_on_level', `Slab ${input.destinationSlabId} is not on ${upper?.id ?? 'the floor above'}, the floor the flight arrives at: name a slab there, or leave it out.`, { slabId: input.destinationSlabId, levelId: upper?.id ?? null });
-    if (input.sourceCeilingId && nodes[input.sourceCeilingId].parentId !== from.id)
-        refuse('ceiling_not_on_level', `Ceiling ${input.sourceCeilingId} is not on ${from.id}, the floor the flight leaves: name a ceiling there, or leave it out.`, { ceilingId: input.sourceCeilingId, levelId: from.id });
-    if (!upper) {
-        upper = LevelNode.parse({
-            parentId: building.id,
-            level: from.level + 1,
-            height: DEFAULT_LEVEL_HEIGHT,
-            children: [],
-        });
-        changes.create.push({ node: upper, parentId: building.id });
-    }
+    const upper = toNoLevel ? undefined : levelAbove(nodes, from, input, changes);
     const withUpper = applySceneChanges(nodes, changes);
     const rotation = input.rotation ?? 0;
     const width = input.width ?? 1;
     const stairs = Object.values(nodes).filter((node) => node.type === 'stair').length;
     const railingMode = input.railingMode ?? 'both';
+    // A flight to no level rises as asked, else its storey's height, and keeps that rise; one to a
+    // level follows the storey (no totalRise) and keeps tracking it.
+    const totalRise = input.height ?? (toNoLevel ? getLevelFloorToFloorHeight(from.id, nodes) : undefined);
     const draft = StairNode.parse({
         parentId: from.id,
         name: input.name ?? `Staircase ${stairs + 1}`,
@@ -113,20 +126,21 @@ export const createStair = (nodes, input, context) => {
         stairType: 'straight',
         uniformRisers: true,
         fromLevelId: from.id,
-        toLevelId: upper.id,
+        toLevelId: upper?.id ?? null,
         slabOpeningMode: owned ? 'destination' : 'none',
         openingOffset: input.openingOffset ?? OPENING_MARGIN,
         width,
         railingMode,
+        ...(input.railingStyle ? { railingStyle: input.railingStyle } : {}),
+        ...(railingPreset ? { railingMaterialPreset: railingPreset } : {}),
         ...(preset ? { materialPreset: preset } : {}),
-        // No height: the flight follows its storey (no totalRise) and keeps tracking it.
-        ...(input.height === undefined ? {} : { totalRise: input.height }),
+        ...(totalRise === undefined ? {} : { totalRise }),
         ...(asGiven ? { metadata: { openingManaged: 'floor-opening' } } : {}),
         children: [],
     });
-    // As main sizes a new flight: the run and the risers from the stair's design targets unless
-    // given, the rise resolved against what the flight stands on and arrives at.
-    const { flight } = planStairCreation(draft, {
+    // As main sizes a new stair: the risers and the run from the stair's design targets unless given,
+    // the rise resolved against what the stair stands on and arrives at.
+    const plan = planFlights(draft, {
         ...withUpper,
         [from.id]: {
             ...withUpper[from.id],
@@ -134,16 +148,16 @@ export const createStair = (nodes, input, context) => {
         },
         [draft.id]: draft,
     }, {
+        layout,
+        turn: input.turn,
         width,
-        attachmentSide: 'front',
-        fillToFloor: true,
-        ...(input.length === undefined ? {} : { length: input.length }),
-        ...(input.steps === undefined ? {} : { stepCount: input.steps }),
+        stepCount: input.steps,
+        runLength: input.length,
+        lowerStepCount: input.lowerSteps,
     });
-    const segment = { ...flight, ...(preset ? { materialPreset: preset } : {}) };
-    const { length, stepCount } = segment;
-    const stair = StairNode.parse({ ...draft, stepCount, children: [segment.id] });
-    changes.create.push({ node: stair, parentId: from.id }, { node: { ...segment, parentId: stair.id }, parentId: stair.id });
+    const stair = plan.stair;
+    const segments = plan.segments.map((segment) => preset ? { ...segment, materialPreset: preset } : segment);
+    changes.create.push({ node: stair, parentId: from.id }, ...segments.map((segment) => ({ node: segment, parentId: stair.id })));
     // The editor's opening pass: the stair owns a floor opening in each floor it passes; the live
     // opening systems then find it in place. Openings as given are cut as main cuts them: owned by
     // the stair, with the pose the live systems move them by.
@@ -151,27 +165,37 @@ export const createStair = (nodes, input, context) => {
     // A hole in the slab above, not one in the ceiling below: the floor upstairs is open.
     let slabHoleCut = false;
     const built = applySceneChanges(nodes, changes);
-    const polygon = asGiven
-        ? openingRing({ x: input.x, z: input.z, turn: stair.rotation, width, length }, input)
-        : [];
-    // The surface the opening falls in, not the storey's first: a floor of several rooms has a
-    // slab (and a ceiling below) per room.
-    const centre = [
-        polygon.reduce((sum, [x]) => sum + x, 0) / (polygon.length || 1),
-        polygon.reduce((sum, [, z]) => sum + z, 0) / (polygon.length || 1),
-    ];
-    const over = (type, levelId) => Object.values(built).find((node) => node.type === type &&
-        node.parentId === levelId &&
-        pointInPolygon(centre, node.polygon));
-    const destinationSlab = input.destinationSlabId
-        ? built[input.destinationSlabId]
-        : over('slab', upper.id);
+    const footprint = stairFootprintAABB(stair, built);
+    // The footprint in the stair's own frame: the opening as given by default, and the box its owner
+    // pose keeps so the opening follows the stair's shape.
+    const local = stairFootprintAABB({ ...stair, position: [0, 0, 0], rotation: 0 }, built);
+    const polygon = asGiven ? openingRing(stair, local, input) : [];
+    // The surface over the flights and landings, not the storey's first: a floor of several rooms
+    // has a slab (and a ceiling below) per room, and an L's inside corner may lie in another.
+    const outlines = stairSegmentFootprints(stair, built);
+    const over = (type, levelId) => {
+        let most = 1e-6;
+        let surface;
+        for (const node of Object.values(built)) {
+            if (node.type !== type || node.parentId !== levelId)
+                continue;
+            const covered = outlines.reduce((sum, outline) => sum + area(intersection(node.polygon, outline)), 0);
+            if (covered > most)
+                [most, surface] = [covered, node];
+        }
+        return surface;
+    };
+    const destinationSlab = !upper
+        ? undefined
+        : input.destinationSlabId
+            ? built[input.destinationSlabId]
+            : over('slab', upper.id);
     const sourceCeiling = input.sourceCeilingId
         ? built[input.sourceCeilingId]
         : over('ceiling', from.id);
     const floorCut = asGiven && cutFloor && !!destinationSlab;
     const ceilingCut = asGiven && cutCeiling && !!sourceCeiling;
-    const adjacent = adjacentLevelId(built, upper.id, -1) === from.id;
+    const adjacent = !!upper && adjacentLevelId(built, upper.id, -1) === from.id;
     const opened = (levelId, drawnOn, cutsAdjacent) => cutFloorOpening(built, {
         levelId,
         polygon,
@@ -184,7 +208,7 @@ export const createStair = (nodes, input, context) => {
     const patches = owned
         ? planOwnedFloorOpenings(built, { ownerIds: new Set([stair.id]) })
         : [
-            ...(floorCut ? opened(upper.id, 'floor', ceilingCut && adjacent) : []),
+            ...(floorCut && upper ? opened(upper.id, 'floor', ceilingCut && adjacent) : []),
             ...(ceilingCut && (!floorCut || !adjacent) ? opened(from.id, 'ceiling', false) : []),
         ];
     for (const patch of patches) {
@@ -198,7 +222,8 @@ export const createStair = (nodes, input, context) => {
                             position: stair.position,
                             rotation: stair.rotation,
                             width,
-                            runLength: length,
+                            runLength: segments[0].length,
+                            footprint: local,
                         },
                         ownerOpeningTarget: patch.node.drawnOn === 'ceiling' ? 'source' : 'destination',
                     },
@@ -216,32 +241,90 @@ export const createStair = (nodes, input, context) => {
         else
             changes.delete.push(patch.id);
     }
-    const createdUpperLevel = !nodes[upper.id];
-    const arrival = upper.name ?? `level ${upper.level}`;
+    const flights = segments.filter((segment) => segment.segmentType === 'stair');
+    const rise = round(segments.reduce((sum, segment) => sum + segment.height, 0));
+    const length = round(flights.reduce((sum, flight) => sum + flight.length, 0));
+    const arrivalEdge = stairArrivalOpening(stair, built);
+    const arrival = arrivalEdge.length
+        ? [
+            round(arrivalEdge.reduce((sum, [x]) => sum + x, 0) / arrivalEdge.length),
+            round(arrivalEdge.reduce((sum, [, z]) => sum + z, 0) / arrivalEdge.length),
+        ]
+        : undefined;
+    const createdUpperLevel = !!upper && !nodes[upper.id];
+    const arrivesOn = upper ? (upper.name ?? `level ${upper.level}`) : undefined;
+    const at = `${KIND[layout]} at (${input.x}, ${input.z}) with ${stair.stepCount} steps`;
     return {
         result: {
             ok: true,
             stairId: stair.id,
-            segmentId: segment.id,
+            segmentIds: stair.children,
             fromLevelId: from.id,
-            upperLevelId: upper.id,
+            upperLevelId: upper?.id ?? null,
             createdUpperLevel,
-            stepCount,
-            rise: Math.round(segment.height * 1000) / 1000,
+            layout,
+            ...(layout === 'straight' ? {} : { turn: input.turn ?? 'left' }),
+            stepCount: stair.stepCount,
+            rise,
             rotation,
             width,
             length,
             railingMode,
+            footprint: {
+                minX: round(footprint.minX),
+                minZ: round(footprint.minZ),
+                maxX: round(footprint.maxX),
+                maxZ: round(footprint.maxZ),
+            },
+            ...(arrival ? { arrival } : {}),
             slabHoleCut,
             ...(openingIds.length ? { openingIds } : {}),
             ...(floorCut ? { destinationSlabId: destinationSlab.id } : {}),
             ...(ceilingCut ? { sourceCeilingId: sourceCeiling.id } : {}),
-            message: openingIds.length
-                ? `Created a staircase at (${input.x}, ${input.z}) with ${stepCount} steps up to ${arrival}, its ${asGiven ? 'opening cut as given' : 'floor opening cut'}.`
-                : !cutFloor && !cutCeiling
-                    ? `Created a staircase at (${input.x}, ${input.z}) with ${stepCount} steps up to ${arrival}${createdUpperLevel ? ' (created for it)' : ''}, with no opening, as asked.`
-                    : `Created a staircase at (${input.x}, ${input.z}) with ${stepCount} steps up to ${arrival}${createdUpperLevel ? ' (created for it)' : ''}, but no floor there covers the flight, so no opening was cut. Add or align the upper floor over the stair's footprint.`,
+            message: !upper
+                ? `Created ${at} rising ${rise} m to no level, so it cuts no opening.`
+                : openingIds.length
+                    ? `Created ${at} up to ${arrivesOn}, its ${asGiven ? 'opening cut as given' : 'floor opening cut'}.`
+                    : !cutFloor && !cutCeiling
+                        ? `Created ${at} up to ${arrivesOn}${createdUpperLevel ? ' (created for it)' : ''}, with no opening, as asked.`
+                        : `Created ${at} up to ${arrivesOn}${createdUpperLevel ? ' (created for it)' : ''}, but no floor there covers the flight, so no opening was cut. Add or align the upper floor over the stair's footprint.`,
         },
         changes,
     };
 };
+/**
+ * The level a stair arrives on: the one named, else the next one up its building, else a blank
+ * level made above for it (added to `changes`). Refused: no building, a level not above, a roof
+ * level, a slab or ceiling named on another storey.
+ */
+function levelAbove(nodes, from, input, changes) {
+    const buildingId = levelBuildingId(nodes, from);
+    const building = buildingId ? nodes[buildingId] : undefined;
+    if (building?.type !== 'building')
+        refuse('no_building', `Level ${from.id} is not in a building, so it has no floor above.`, {
+            levelId: from.id,
+        });
+    const floors = levelsOf(nodes).filter((level) => level.parentId === building.id || building.children.includes(level.id));
+    const upper = input.toLevelId
+        ? requireLevel(nodes, input.toLevelId)
+        : floors.find((level) => level.level > from.level);
+    if (upper && (upper.level <= from.level || !floors.includes(upper)))
+        refuse('not_above', `${upper.id} is not above ${from.id} in its building: a flight rises to a higher floor.`, { levelId: from.id, toLevelId: upper.id });
+    if (upper)
+        refuseRoofLevel(nodes, upper.id, 'a stair');
+    // The flight cuts the slab of the floor it arrives at and the ceiling of the one it leaves.
+    if (input.destinationSlabId && nodes[input.destinationSlabId].parentId !== upper?.id)
+        refuse('slab_not_on_level', `Slab ${input.destinationSlabId} is not on ${upper?.id ?? 'the floor above'}, the floor the flight arrives at: name a slab there, or leave it out.`, { slabId: input.destinationSlabId, levelId: upper?.id ?? null });
+    if (input.sourceCeilingId && nodes[input.sourceCeilingId].parentId !== from.id)
+        refuse('ceiling_not_on_level', `Ceiling ${input.sourceCeilingId} is not on ${from.id}, the floor the flight leaves: name a ceiling there, or leave it out.`, { ceilingId: input.sourceCeilingId, levelId: from.id });
+    if (upper)
+        return upper;
+    const made = LevelNode.parse({
+        parentId: building.id,
+        level: from.level + 1,
+        height: DEFAULT_LEVEL_HEIGHT,
+        children: [],
+    });
+    changes.create.push({ node: made, parentId: building.id });
+    return made;
+}

package/dist/agent-operations/design-brief.d.ts

@@ -0,0 +1,38 @@
+import { type DesignBrief, type DesignBriefInput } from '../agent-tools/design-brief.js';
+import { AgentRefusal } from '../agent-tools/refusal.js';
+import type { AssetInput } from '../schema/index.js';
+import type { AgentOperation } from './types.js';
+/**
+ * Furnishing follows the turn's design brief. A host that gates keeps the brief in force
+ * (`AgentContext.designBrief`, null while there is none) and each furnishing tool asks
+ * `requireFurnishing` before it runs, inside `run_batch` too. A host that does not gate leaves the
+ * context's brief out and nothing is refused (Pro, a person's own tools).
+ */
+export declare const NO_BRIEF = "Furnishing follows the turn's design brief: design_brief records what the request fixes, what it leaves open and where objects come from; until then the catalog can be searched and viewed, not placed, and no furnishing is made.";
+export declare function isTechnicalEquipment(item: Pick<AssetInput, 'category' | 'functionTags'>): boolean;
+/** The pieces `beyond` names, flattened: the brief's own list of the dressing. */
+export declare function dressingOf(beyond: DesignBriefInput['beyond']): string[];
+/** Whether `design_brief` reads the item library: an open brief naming pieces as they are. */
+export declare function briefReadsCatalog(tool: string, input: unknown): boolean;
+/**
+ * Why a furnishing call may not run under this brief, or null. `brief` null is no brief yet. An
+ * `add_object` that names a `nodeId` edits an object that stands: it places and makes nothing.
+ * A batch holding a refused call is refused whole: the gate says nothing about its other calls.
+ */
+export declare function furnishingRefusal(tool: string, input: unknown, brief: DesignBrief | null): AgentRefusal | null;
+/** Throws the refusal when the host gates and the call may not run; a host with no brief to keep passes. */
+export declare function requireFurnishing(tool: string, input: unknown, brief: DesignBrief | null | undefined): void;
+/** The operation of a furnishing tool, refusing as `requireFurnishing` says before it runs. */
+export declare function gatedByBrief<Input>(tool: string, operation: AgentOperation<Input>): AgentOperation<Input>;
+/** What a brief opens and leaves closed, as facts. */
+export declare function briefUnlocks(brief: DesignBrief): {
+    unlocks: string[];
+    closed: string[];
+};
+/**
+ * `design_brief`: the request read as a brief, recorded as the turn's design record. The operation
+ * echoes it with what it opens and hands it back for the host to keep with the session; nothing in
+ * the scene changes.
+ */
+export declare const designBrief: AgentOperation<DesignBriefInput>;
+//# sourceMappingURL=design-brief.d.ts.map

package/dist/agent-operations/design-brief.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"design-brief.d.ts","sourceRoot":"","sources":["../../src/agent-operations/design-brief.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,WAAW,EAChB,KAAK,gBAAgB,EAGtB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,YAAY,EAAU,MAAM,wBAAwB,CAAA;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,KAAK,EAAgB,cAAc,EAAE,MAAM,SAAS,CAAA;AAE3D;;;;;GAKG;AAEH,eAAO,MAAM,QAAQ,wOACkN,CAAA;AAwBvO,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,UAAU,GAAG,cAAc,CAAC,GAAG,OAAO,CAGjG;AAyGD,kFAAkF;AAClF,wBAAgB,UAAU,CAAC,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,GAAG,MAAM,EAAE,CAEvE;AAiCD,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAGvE;AAuCD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,WAAW,GAAG,IAAI,GACxB,YAAY,GAAG,IAAI,CAwCrB;AAED,4GAA4G;AAC5G,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACpC,IAAI,CAIN;AAED,+FAA+F;AAC/F,wBAAgB,YAAY,CAAC,KAAK,EAChC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,cAAc,CAAC,KAAK,CAAC,GAC/B,cAAc,CAAC,KAAK,CAAC,CAKvB;AAED,sDAAsD;AACtD,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAyBxF;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,gBAAgB,CAqCxD,CAAA"}