@pascal-app/core 1.0.3 → 1.0.5

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

@@ -0,0 +1,330 @@
+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 { 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 { 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,
+ * 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, box, input) {
+    const margin = input.openingOffset ?? OPENING_MARGIN;
+    const half = [
+        (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.position[0] + middle[0],
+        stair.position[2] + middle[1],
+    ];
+    const turn = input.openingRotation === undefined ? stair.rotation : (input.openingRotation * Math.PI) / 180;
+    return [
+        [-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, 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 = !toNoLevel && input.createDestinationSlabOpening !== false;
+    const cutCeiling = !toNoLevel && input.createSourceCeilingOpening !== false;
+    const asGiven = cutFloor !== cutCeiling || shaped;
+    const owned = cutFloor && cutCeiling && !asGiven;
+    const changes = {
+        create: [],
+        update: [],
+        delete: [],
+        collections: {},
+    };
+    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}`,
+        position: [input.x, 0, input.z],
+        rotation: (rotation * Math.PI) / 180,
+        stairType: 'straight',
+        uniformRisers: true,
+        fromLevelId: from.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 } : {}),
+        ...(totalRise === undefined ? {} : { totalRise }),
+        ...(asGiven ? { metadata: { openingManaged: 'floor-opening' } } : {}),
+        children: [],
+    });
+    // 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],
+            children: [...withUpper[from.id].children, draft.id],
+        },
+        [draft.id]: draft,
+    }, {
+        layout,
+        turn: input.turn,
+        width,
+        stepCount: input.steps,
+        runLength: input.length,
+        lowerStepCount: input.lowerSteps,
+    });
+    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.
+    const openingIds = [];
+    // 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 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 = !!upper && adjacentLevelId(built, upper.id, -1) === from.id;
+    const opened = (levelId, drawnOn, cutsAdjacent) => cutFloorOpening(built, {
+        levelId,
+        polygon,
+        drawnOn,
+        source: 'stair',
+        ownerId: stair.id,
+        cutsAdjacent,
+        mintId: generateId,
+    }).changes;
+    const patches = owned
+        ? planOwnedFloorOpenings(built, { ownerIds: new Set([stair.id]) })
+        : [
+            ...(floorCut && upper ? opened(upper.id, 'floor', ceilingCut && adjacent) : []),
+            ...(ceilingCut && (!floorCut || !adjacent) ? opened(from.id, 'ceiling', false) : []),
+        ];
+    for (const patch of patches) {
+        if (patch.op === 'create') {
+            const node = !owned && patch.node.type === 'floor-opening'
+                ? {
+                    ...patch.node,
+                    metadata: {
+                        ...patch.node.metadata,
+                        ownerPose: {
+                            position: stair.position,
+                            rotation: stair.rotation,
+                            width,
+                            runLength: segments[0].length,
+                            footprint: local,
+                        },
+                        ownerOpeningTarget: patch.node.drawnOn === 'ceiling' ? 'source' : 'destination',
+                    },
+                }
+                : patch.node;
+            changes.create.push({ node, parentId: node.parentId ?? undefined });
+            if (node.type === 'floor-opening') {
+                openingIds.push(node.id);
+                if (node.drawnOn !== 'ceiling')
+                    slabHoleCut = true;
+            }
+        }
+        else if (patch.op === 'update')
+            changes.update.push({ id: patch.id, data: patch.data });
+        else
+            changes.delete.push(patch.id);
+    }
+    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,
+            segmentIds: stair.children,
+            fromLevelId: from.id,
+            upperLevelId: upper?.id ?? null,
+            createdUpperLevel,
+            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: !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/delete-node.d.ts

@@ -0,0 +1,6 @@
+import type { AgentOperation } from './types.js';
+/** `delete_node`: the editor's Delete, which takes a node with everything under it. */
+export declare const deleteNode: AgentOperation<{
+    id: string;
+}>;
+//# sourceMappingURL=delete-node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-node.d.ts","sourceRoot":"","sources":["../../src/agent-operations/delete-node.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,uFAAuF;AACvF,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAIrD,CAAA"}

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

@@ -0,0 +1,9 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { descendantsOf } from './scene-queries.js';
+/** `delete_node`: the editor's Delete, which takes a node with everything under it. */
+export const deleteNode = (nodes, { id }) => {
+    if (!nodes[id])
+        refuse('node_not_found', `Node not found: ${id}.`, { id });
+    const deletedIds = [id, ...descendantsOf(nodes, id).map((node) => node.id)];
+    return { result: { deletedIds }, changes: { delete: [id] } };
+};

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"}