@pascal-app/nodes 1.0.6 → 1.0.7

package/README.md

@@ -39,6 +39,7 @@ The built-in plugin exports `builtinAgentTools` from `@pascal-app/nodes/agent-to
 (zod-only contracts) and `builtinAgentOperations` from
 `@pascal-app/nodes/agent-operations` (headless planners). Both the inspector and
 agents execute the same finishing planner, including hosted-item support checks.
+
 - `kitchen_finish_run({ runId, action: 'align' | 'fill' })` aligns a run or closes
   50–150 mm wall gaps. Results apply in one undo step. Missing runs and unsupported
   hosted items return `cabinet_run_not_found` and `hosted_items_unsupported`.

package/dist/beam/actions/move-endpoint.d.ts

@@ -0,0 +1,24 @@
+import { type AnyNodeId, type DragAction } from '@pascal-app/core';
+import { type WallPlanPoint } from '@pascal-app/editor';
+export type MoveBeamEndpointCtx = {
+    beamId: AnyNodeId;
+    endpoint: 'start' | 'end';
+    levelId: string | null;
+    /** The end that stays put. */
+    fixed: WallPlanPoint;
+};
+export type MoveBeamEndpointDraft = {
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+};
+/**
+ * A beam's end dragged in 3D, as a pure drag action:
+ *  - **preview**: the pointer snapped as the beam tool snaps (wall faces and ends, other beams,
+ *    post centres, the grid), angle-stepped off the end that stays; Alt places it freely.
+ *  - **apply**: writes the ends into the scene while history is paused.
+ *  - **commit**: refuses a beam too short to draw; otherwise reverts, resumes history and writes
+ *    the final ends once, so the drag is one undo step.
+ *  - **cancel**: `createDragSession` restores the beam it touched.
+ */
+export declare const moveBeamEndpointDragAction: DragAction<MoveBeamEndpointCtx, MoveBeamEndpointDraft>;
+//# sourceMappingURL=move-endpoint.d.ts.map

package/dist/beam/actions/move-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-endpoint.d.ts","sourceRoot":"","sources":["../../../src/beam/actions/move-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,UAAU,EAEhB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAG5E,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,SAAS,CAAA;IACjB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;IACzB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,8BAA8B;IAC9B,KAAK,EAAE,aAAa,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,GAAG,EAAE,aAAa,CAAA;CAAE,CAAA;AAEhF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,UAAU,CAAC,mBAAmB,EAAE,qBAAqB,CA2C7F,CAAA"}

package/dist/beam/actions/move-endpoint.js

@@ -0,0 +1,54 @@
+import { useScene, } from '@pascal-app/core';
+import { isSegmentLongEnough } from '@pascal-app/editor';
+import { snapBeamPoint } from '../drafting.js';
+/**
+ * A beam's end dragged in 3D, as a pure drag action:
+ *  - **preview**: the pointer snapped as the beam tool snaps (wall faces and ends, other beams,
+ *    post centres, the grid), angle-stepped off the end that stays; Alt places it freely.
+ *  - **apply**: writes the ends into the scene while history is paused.
+ *  - **commit**: refuses a beam too short to draw; otherwise reverts, resumes history and writes
+ *    the final ends once, so the drag is one undo step.
+ *  - **cancel**: `createDragSession` restores the beam it touched.
+ */
+export const moveBeamEndpointDragAction = {
+    begin: (input) => {
+        const beam = input.node;
+        if (beam?.type !== 'beam')
+            throw new Error('[moveBeamEndpointDragAction] begin requires a beam');
+        const endpoint = input.handleId === 'start' ? 'start' : 'end';
+        return {
+            beamId: beam.id,
+            endpoint,
+            levelId: beam.parentId ?? null,
+            fixed: endpoint === 'start' ? [beam.end[0], beam.end[1]] : [beam.start[0], beam.start[1]],
+        };
+    },
+    preview: (ctx, point, modifiers) => {
+        const moved = ctx.levelId
+            ? snapBeamPoint({
+                point: [point[0], point[1]],
+                nodes: useScene.getState().nodes,
+                levelId: ctx.levelId,
+                start: ctx.fixed,
+                ignoreIds: [ctx.beamId],
+                free: modifiers.alt,
+            }).point
+            : [point[0], point[1]];
+        return ctx.endpoint === 'start'
+            ? { start: moved, end: ctx.fixed }
+            : { start: ctx.fixed, end: moved };
+    },
+    apply: (draft, ctx, scene) => {
+        scene.update(ctx.beamId, { start: draft.start, end: draft.end });
+        return [ctx.beamId];
+    },
+    commit: (draft, ctx, scene) => {
+        if (!(draft && isSegmentLongEnough(draft.start, draft.end)))
+            return false;
+        scene.restoreAll();
+        scene.resumeHistory();
+        scene.update(ctx.beamId, { start: draft.start, end: draft.end });
+        return true;
+    },
+    cancel: () => { },
+};

package/dist/beam/definition.d.ts

@@ -0,0 +1,14 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { BeamNode } from './schema.js';
+/**
+ * Beam — a horizontal framing member drawn by hand, end to end like a wall: a porch's header on
+ * its posts, a deck's beam, a girder, a beam across an open span. A box of its actual section
+ * along the centreline, its top stored or following the ceiling plane over it (`beamTopElevation`
+ * in core); the plan draws it dashed with its size, as a framing plan does. `createBeam` in core
+ * makes one from code.
+ *
+ * No `movable`: a beam has no `position`; it moves by both ends, through `affordanceTools.move` in
+ * 3D and `floorplanMoveTarget` in the plan.
+ */
+export declare const beamDefinition: NodeDefinition<typeof BeamNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/beam/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/beam/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAgBzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAwGnC;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAkE1D,CAAA"}

package/dist/beam/definition.js

@@ -0,0 +1,173 @@
+import { beamPlan, beamTopElevation, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, FLOORPLAN_NODE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { beamToolOptions } from './draft-settings.js';
+import { buildBeamFloorplan } from './floorplan.js';
+import { beamEndpointAffordance } from './floorplan-affordances.js';
+import { beamFloorplanMoveTarget } from './floorplan-move.js';
+import { beamPanelModel } from './panel-model.js';
+import { beamParametrics } from './parametrics.js';
+import { BeamNode } from './schema.js';
+const SIDE_HANDLE_OFFSET = 0.22;
+const INCH = 0.0254;
+/** Where a beam's top is in the live scene (a descriptor may run before the scene has a level). */
+function topOf(beam, sceneApi) {
+    return beamTopElevation(sceneApi?.nodes() ?? {}, beam);
+}
+function midFrame(beam) {
+    const plan = beamPlan(beam);
+    return {
+        mid: [(plan.start[0] + plan.end[0]) / 2, (plan.start[1] + plan.end[1]) / 2],
+        normal: plan.normal,
+    };
+}
+/** The beam's top, as the elevation guides read a structural datum. */
+function guideSource(beam) {
+    const { mid } = midFrame(beam);
+    return { nodeId: beam.id, levelId: beam.parentId, anchor: mid };
+}
+// Side arrows: a tap hands the beam to its move tool, either side of its middle at mid-depth.
+function beamSideMoveHandle(side) {
+    return {
+        kind: 'tap-action',
+        onActivate: (node, _scene, editor) => editor.engageMove(node),
+        placement: {
+            position: (n, sceneApi) => {
+                const { mid, normal } = midFrame(n);
+                const offset = (n.width / 2 + SIDE_HANDLE_OFFSET) * side;
+                return [
+                    mid[0] + normal[0] * offset,
+                    topOf(n, sceneApi) - n.depth / 2,
+                    mid[1] + normal[1] * offset,
+                ];
+            },
+            rotationY: (n) => {
+                const { normal } = midFrame(n);
+                return Math.atan2(-normal[1] * side, normal[0] * side);
+            },
+        },
+        cursor: 'ew-resize',
+    };
+}
+// End pickers: a dashed leader down the beam's depth and a disc at its end; a tap drags the end.
+function beamEndPicker(endpoint) {
+    return {
+        kind: 'tap-action',
+        shape: 'corner-picker',
+        cursor: 'move',
+        nodeHeight: (n) => n.depth,
+        onActivate: (node, _scene, editor) => editor.engageEndpointMove(node, endpoint),
+        placement: {
+            position: (n, sceneApi) => {
+                const point = n[endpoint];
+                return [point[0], topOf(n, sceneApi) - n.depth, point[1]];
+            },
+        },
+    };
+}
+/**
+ * The beam's top, dragged up and down: it stores the top it lands on, caught by the levels'
+ * structural heights (a ceiling plane, a slab top) and otherwise to the half inch (the centimetre
+ * on a metric plan).
+ */
+function beamTopHandle(current) {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        shape: 'tracker',
+        currentValue: () => current,
+        magneticSnap: (n, value, sceneApi) => {
+            const snapped = resolveStructuralElevationSnap(guideSource(n), value, sceneApi.nodes());
+            if (snapped !== value)
+                return snapped;
+            const step = useViewer.getState().unit === 'imperial' ? INCH / 2 : 0.01;
+            return Math.round(value / step) * step;
+        },
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(guideSource(n), topOf(n, sceneApi), sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (_n, top) => ({ topElevation: top }),
+        placement: {
+            position: (n, sceneApi) => {
+                const { mid } = midFrame(n);
+                return [mid[0], topOf(n, sceneApi), mid[1]];
+            },
+        },
+    };
+}
+const beamHandles = (node, sceneApi) => [
+    beamSideMoveHandle(1),
+    beamSideMoveHandle(-1),
+    beamEndPicker('start'),
+    beamEndPicker('end'),
+    beamTopHandle(topOf(node, sceneApi)),
+];
+/**
+ * Beam — a horizontal framing member drawn by hand, end to end like a wall: a porch's header on
+ * its posts, a deck's beam, a girder, a beam across an open span. A box of its actual section
+ * along the centreline, its top stored or following the ceiling plane over it (`beamTopElevation`
+ * in core); the plan draws it dashed with its size, as a framing plan does. `createBeam` in core
+ * makes one from code.
+ *
+ * No `movable`: a beam has no `position`; it moves by both ends, through `affordanceTools.move` in
+ * 3D and `floorplanMoveTarget` in the plan.
+ */
+export const beamDefinition = {
+    kind: 'beam',
+    snapProfile: 'structural',
+    schemaVersion: 1,
+    schema: BeamNode,
+    category: 'structure',
+    extensions: {
+        [FLOORPLAN_NODE_EXTENSION_KEY]: {
+            // In 2D-only view the 3D tool never mounts: the plan drafts beams itself.
+            tool: () => import('./tool.js').then((module) => ({ default: module.BeamFloorplanTool })),
+            // A beam crosses rooms: a plan click on it picks the beam, not the room.
+            planHitSelectsNode: true,
+        },
+        [PANEL_MODEL_EXTENSION]: beamPanelModel,
+    },
+    defaults: () => {
+        const { id: _id, type: _type, ...rest } = BeamNode.parse({ start: [0, 0], end: [3, 0] });
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        surfaces: { hosting: false },
+        duplicable: true,
+        deletable: true,
+        drawTool: true,
+    },
+    // The renderer reads the scene and live overrides itself; nothing consumes a dirty mark.
+    dirtyTracking: false,
+    rendersChildren: false,
+    renderer: { kind: 'parametric', module: () => import('./renderer.js') },
+    parametrics: beamParametrics,
+    handles: beamHandles,
+    tool: () => import('./tool.js'),
+    toolOptions: beamToolOptions,
+    toolHints: [
+        { key: 'Left click', label: 'Set beam start / end; the next beam starts there' },
+        { key: 'Alt', label: 'Free place' },
+        { key: 'Esc', label: 'End the run' },
+    ],
+    floorplan: buildBeamFloorplan,
+    floorplanMoveTarget: beamFloorplanMoveTarget,
+    floorplanAffordances: {
+        'move-endpoint': beamEndpointAffordance,
+    },
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+        'move-endpoint': () => import('./move-endpoint-tool.js'),
+    },
+    presentation: {
+        label: 'Beam',
+        description: 'A framing beam drawn end to end: a porch header, a deck beam, a girder.',
+        icon: { kind: 'url', src: '/icons/beam.svg' },
+        paletteSection: 'structure',
+        paletteOrder: 72,
+    },
+    mcp: {
+        description: 'A horizontal framing beam: start/end centreline (level-local), actual width/depth, nominal size and plies, material, dropped or flush placement, and a top elevation (absent = under the ceiling plane).',
+    },
+};

package/dist/beam/draft-settings.d.ts

@@ -0,0 +1,17 @@
+import { type BeamMaterial, type BeamTopReference, type ToolOption } from '@pascal-app/core';
+/** What the beam tool draws with: its size, material and where its top goes. */
+export type BeamDraftChoices = {
+    preset: string;
+    material: BeamMaterial;
+    top: BeamTopReference;
+};
+/**
+ * The beam tool's choices, kept apart from the editor's tool defaults: a host clears those when it
+ * arms a tool from its tile, which would forget the size just picked.
+ */
+export declare const useBeamDraft: import("zustand").UseBoundStore<import("zustand").StoreApi<BeamDraftChoices & {
+    set: (patch: Partial<BeamDraftChoices>) => void;
+}>>;
+/** The Beam tool's rows in the Build panel: material, size, top. */
+export declare const beamToolOptions: readonly ToolOption[];
+//# sourceMappingURL=draft-settings.d.ts.map

package/dist/beam/draft-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft-settings.d.ts","sourceRoot":"","sources":["../../src/beam/draft-settings.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EAGrB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAGzB,gFAAgF;AAChF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,YAAY,CAAA;IACtB,GAAG,EAAE,gBAAgB,CAAA;CACtB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY;SACG,CAAC,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,KAAK,IAAI;GAMnE,CAAA;AAsFH,oEAAoE;AACpE,eAAO,MAAM,eAAe,EAAE,SAAS,UAAU,EAAgD,CAAA"}

package/dist/beam/draft-settings.js

@@ -0,0 +1,81 @@
+import { BEAM_MATERIAL_LABELS, BEAM_SIZE_PRESETS, BEAM_TOP_REFERENCE_LABELS, BEAM_TOP_REFERENCES, beamSizePreset, DEFAULT_BEAM_SIZE_PRESET_ID, } from '@pascal-app/core';
+import { create } from 'zustand';
+/**
+ * The beam tool's choices, kept apart from the editor's tool defaults: a host clears those when it
+ * arms a tool from its tile, which would forget the size just picked.
+ */
+export const useBeamDraft = create((set) => ({
+    preset: DEFAULT_BEAM_SIZE_PRESET_ID,
+    material: 'sawn',
+    top: 'ceiling-dropped',
+    set: (patch) => set(patch),
+}));
+const familyOf = (material) => material === 'pressure-treated' ? 'sawn' : material;
+/** The size a family starts at when its material is picked. */
+const FAMILY_SIZE = {
+    sawn: DEFAULT_BEAM_SIZE_PRESET_ID,
+    lvl: '(2)lvl-1-3/4x11-7/8',
+    glulam: 'glulam-5-1/8x12',
+    steel: 'W8x10',
+};
+const MATERIAL_DESCRIPTIONS = {
+    sawn: 'A solid timber or 2x plies nailed up, inside where it stays dry',
+    'pressure-treated': 'Treated sawn lumber, for a porch, a deck or anything in the weather',
+    lvl: 'Laminated veneer lumber: a stiff beam for a long span inside',
+    glulam: 'Glued-laminated timber: long spans, often left exposed',
+    steel: 'A steel W shape, for the longest spans',
+};
+const TOP_DESCRIPTIONS = {
+    'ceiling-dropped': 'Hangs under the ceiling plane, the top of the walls: the joists or rafters bear on it',
+    'ceiling-flush': 'In the ceiling framing, its underside on the ceiling plane: the joists hang from its sides',
+    'floor-flush': 'Its top flush with the floor over it, in the floor framing',
+    'floor-under': "Under the floor's framing: a girder in a crawl space, or a deck's beam under its joists",
+};
+const subscribe = (onChange) => useBeamDraft.subscribe(() => onChange());
+/** The material row: picking another family brings its usual size along. */
+const materialOption = {
+    id: 'beam-material',
+    label: 'Material',
+    choices: Object.keys(BEAM_MATERIAL_LABELS).map((material) => ({
+        value: material,
+        label: BEAM_MATERIAL_LABELS[material],
+        description: MATERIAL_DESCRIPTIONS[material],
+    })),
+    subscribe,
+    value: () => useBeamDraft.getState().material,
+    set: (value) => {
+        const material = value;
+        const preset = beamSizePreset(useBeamDraft.getState().preset);
+        const keeps = preset && familyOf(preset.material) === familyOf(material);
+        useBeamDraft
+            .getState()
+            .set({ material, ...(keeps ? {} : { preset: FAMILY_SIZE[familyOf(material)] }) });
+    },
+};
+/** One Size row per family, shown while its material is the one picked. */
+const sizeOptions = ['sawn', 'lvl', 'glulam', 'steel'].map((family) => ({
+    id: `beam-size-${family}`,
+    label: 'Size',
+    choices: BEAM_SIZE_PRESETS.filter((preset) => familyOf(preset.material) === family).map((preset) => ({ value: preset.id, label: preset.label.replace(/ (LVL|GLB)$/, '') })),
+    subscribe,
+    value: () => useBeamDraft.getState().preset,
+    set: (value) => useBeamDraft.getState().set({ preset: value }),
+    visible: {
+        subscribe,
+        value: () => familyOf(useBeamDraft.getState().material) === family,
+    },
+}));
+const topOption = {
+    id: 'beam-top',
+    label: 'Top',
+    choices: BEAM_TOP_REFERENCES.map((top) => ({
+        value: top,
+        label: BEAM_TOP_REFERENCE_LABELS[top],
+        description: TOP_DESCRIPTIONS[top],
+    })),
+    subscribe,
+    value: () => useBeamDraft.getState().top,
+    set: (value) => useBeamDraft.getState().set({ top: value }),
+};
+/** The Beam tool's rows in the Build panel: material, size, top. */
+export const beamToolOptions = [materialOption, ...sizeOptions, topOption];

package/dist/beam/drafting.d.ts

@@ -0,0 +1,35 @@
+import { type AnyNode, type AnyNodeId, BeamNode, type WallNode } from '@pascal-app/core';
+import { type WallDraftSnapKind, type WallPlanPoint } from '@pascal-app/editor';
+import { type BeamDraftChoices } from './draft-settings.js';
+type Nodes = Readonly<Record<AnyNodeId, AnyNode>>;
+/**
+ * What a beam drawn on `levelId` snaps to, through the wall snap (`snapWallDraftPoint`): the
+ * level's wall centrelines and both faces of each straight wall (so a beam end lands on a wall's
+ * face or its corner), other beams' centrelines (their ends, middles and runs), and every post
+ * and column centre (a segment of no length). Kept per scene, so a pointer move asks once.
+ */
+export declare function beamSnapTargets(nodes: Nodes, levelId: string, ignoreIds?: readonly string[]): WallNode[];
+/** A snapped plan point and what caught it (null: the grid, an angle step, or nothing). */
+export type BeamPlanSnap = {
+    point: WallPlanPoint;
+    snap: WallDraftSnapKind | null;
+};
+/**
+ * A beam point snapped as the beam tool snaps: wall and beam ends, faces, middles and crossings,
+ * post centres, the grid, and from `start` the angle steps. `free` (Alt) places it as it is.
+ */
+export declare function snapBeamPoint(args: {
+    point: WallPlanPoint;
+    nodes: Nodes;
+    levelId: string;
+    start?: WallPlanPoint | null;
+    ignoreIds?: readonly string[];
+    free?: boolean;
+}): BeamPlanSnap;
+/**
+ * The beam a draft makes from `start` to `end` on `levelId` with the tool's choices, its top set
+ * from the chosen reference; `seed` (a preset the host armed the tool with) overrides them.
+ */
+export declare function draftBeam(start: WallPlanPoint, end: WallPlanPoint, levelId: string, nodes: Nodes, choices?: BeamDraftChoices, seed?: Readonly<Record<string, unknown>> | null, fields?: Partial<BeamNode>): BeamNode;
+export {};
+//# sourceMappingURL=drafting.d.ts.map

package/dist/beam/drafting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drafting.d.ts","sourceRoot":"","sources":["../../src/beam/drafting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,QAAQ,EAIR,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAML,KAAK,iBAAiB,EACtB,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,kBAAkB,CAAA;AAEtE,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;AA0BjD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,SAAS,MAAM,EAAO,GAChC,QAAQ,EAAE,CAmCZ;AAED,2FAA2F;AAC3F,MAAM,MAAM,YAAY,GAAG;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAAE,CAAA;AAEnF;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,KAAK,EAAE,aAAa,CAAA;IACpB,KAAK,EAAE,KAAK,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,aAAa,GAAG,IAAI,CAAA;IAC5B,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,GAAG,YAAY,CAaf;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,aAAa,EAClB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,EACZ,OAAO,GAAE,gBAA0C,EACnD,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,EAC/C,MAAM,GAAE,OAAO,CAAC,QAAQ,CAAM,GAC7B,QAAQ,CAmBV"}

package/dist/beam/drafting.js

@@ -0,0 +1,103 @@
+import { BeamNode, beamTopReferencePatch, createBeam, getWallFaceLine, } from '@pascal-app/core';
+import { getSegmentGridStep, isAngleSnapActive, isMagneticSnapActive, snapBuildingLocalToWorldGrid, snapWallDraftPointDetailed, } from '@pascal-app/editor';
+import { useBeamDraft } from './draft-settings.js';
+/** A segment as the wall snap reads a wall: its ends, its middle and its body catch a point. */
+function reference(id, parentId, start, end) {
+    return {
+        object: 'node',
+        id: id,
+        type: 'wall',
+        parentId,
+        visible: true,
+        metadata: {},
+        children: [],
+        start,
+        end,
+        frontSide: 'unknown',
+        backSide: 'unknown',
+    };
+}
+const targetsMemo = new WeakMap();
+/**
+ * What a beam drawn on `levelId` snaps to, through the wall snap (`snapWallDraftPoint`): the
+ * level's wall centrelines and both faces of each straight wall (so a beam end lands on a wall's
+ * face or its corner), other beams' centrelines (their ends, middles and runs), and every post
+ * and column centre (a segment of no length). Kept per scene, so a pointer move asks once.
+ */
+export function beamSnapTargets(nodes, levelId, ignoreIds = []) {
+    const key = `${levelId}|${ignoreIds.join(',')}`;
+    let byKey = targetsMemo.get(nodes);
+    if (!byKey) {
+        byKey = new Map();
+        targetsMemo.set(nodes, byKey);
+    }
+    const cached = byKey.get(key);
+    if (cached)
+        return cached;
+    const targets = [];
+    for (const node of Object.values(nodes)) {
+        if (node.parentId !== levelId || node.visible === false || ignoreIds.includes(node.id))
+            continue;
+        if (node.type === 'wall') {
+            targets.push(node);
+            if (Math.abs(node.curveOffset ?? 0) > 1e-6)
+                continue;
+            for (const face of ['a', 'b']) {
+                const line = getWallFaceLine(node, face);
+                targets.push(reference(`${node.id}:${face}`, node.parentId, [line.start.x, line.start.y], [line.end.x, line.end.y]));
+            }
+        }
+        else if (node.type === 'beam') {
+            targets.push(reference(node.id, node.parentId, node.start, node.end));
+        }
+        else if (node.type === 'column') {
+            const centre = [node.position[0], node.position[2]];
+            targets.push(reference(node.id, node.parentId, centre, centre));
+        }
+    }
+    byKey.set(key, targets);
+    return targets;
+}
+/**
+ * A beam point snapped as the beam tool snaps: wall and beam ends, faces, middles and crossings,
+ * post centres, the grid, and from `start` the angle steps. `free` (Alt) places it as it is.
+ */
+export function snapBeamPoint(args) {
+    if (args.free)
+        return { point: args.point, snap: null };
+    const step = getSegmentGridStep();
+    const angleSnap = !!args.start && isAngleSnapActive();
+    const result = snapWallDraftPointDetailed({
+        point: args.point,
+        walls: beamSnapTargets(args.nodes, args.levelId, args.ignoreIds),
+        start: args.start ?? undefined,
+        angleSnap,
+        magnetic: isMagneticSnapActive(),
+        gridSnap: (point) => snapBuildingLocalToWorldGrid(point, step),
+    });
+    return { point: result.point, snap: result.snap };
+}
+/**
+ * The beam a draft makes from `start` to `end` on `levelId` with the tool's choices, its top set
+ * from the chosen reference; `seed` (a preset the host armed the tool with) overrides them.
+ */
+export function draftBeam(start, end, levelId, nodes, choices = useBeamDraft.getState(), seed, fields = {}) {
+    const base = createBeam({
+        start,
+        end,
+        preset: choices.preset,
+        material: choices.material,
+        levelId,
+    });
+    const placed = { ...base, ...beamTopReferencePatch(nodes, base, choices.top) };
+    return BeamNode.parse({
+        ...placed,
+        ...(seed ?? {}),
+        ...fields,
+        id: base.id,
+        type: 'beam',
+        start,
+        end,
+        parentId: levelId,
+    });
+}

package/dist/beam/floorplan-affordances.d.ts

@@ -0,0 +1,8 @@
+import { type BeamNode, type FloorplanAffordance } from '@pascal-app/core';
+/**
+ * A beam's end, dragged in the plan: snapped as the beam tool snaps, angle-stepped off the other
+ * end. Previews through live overrides, writes the last end on release, and refuses an end that
+ * would leave the beam too short to draw.
+ */
+export declare const beamEndpointAffordance: FloorplanAffordance<BeamNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/beam/floorplan-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/beam/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAGzB,MAAM,kBAAkB,CAAA;AAKzB;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,QAAQ,CA8BhE,CAAA"}

package/dist/beam/floorplan-affordances.js

@@ -0,0 +1,40 @@
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { isSegmentLongEnough } from '@pascal-app/editor';
+import { snapBeamPoint } from './drafting.js';
+/**
+ * A beam's end, dragged in the plan: snapped as the beam tool snaps, angle-stepped off the other
+ * end. Previews through live overrides, writes the last end on release, and refuses an end that
+ * would leave the beam too short to draw.
+ */
+export const beamEndpointAffordance = {
+    start({ node, payload, nodes }) {
+        const { endpoint } = payload;
+        const id = node.id;
+        const fixed = endpoint === 'start' ? node.end : node.start;
+        let last = null;
+        return {
+            affectedIds: [id],
+            apply({ planPoint, modifiers }) {
+                last = node.parentId
+                    ? snapBeamPoint({
+                        point: [planPoint[0], planPoint[1]],
+                        nodes,
+                        levelId: node.parentId,
+                        start: fixed,
+                        ignoreIds: [node.id],
+                        free: modifiers.altKey,
+                    }).point
+                    : [planPoint[0], planPoint[1]];
+                useLiveNodeOverrides.getState().set(id, { [endpoint]: last });
+            },
+            canCommit() {
+                return last !== null && isSegmentLongEnough(fixed, last);
+            },
+            commit() {
+                if (last)
+                    useScene.getState().updateNodes([{ id, data: { [endpoint]: last } }]);
+                useLiveNodeOverrides.getState().clear(id);
+            },
+        };
+    },
+};

package/dist/beam/floorplan-move.d.ts

@@ -0,0 +1,11 @@
+import { type BeamNode, type FloorplanMoveTarget } from '@pascal-app/core';
+import { type WallPlanPoint } from '@pascal-app/editor';
+/** A beam translated by `delta`, both ends together. */
+export declare function movedBeamEnds(beam: Pick<BeamNode, 'start' | 'end'>, delta: WallPlanPoint): Pick<BeamNode, 'start' | 'end'>;
+/**
+ * A beam moved in the plan: its start follows the pointer and snaps as the beam tool snaps (wall
+ * faces and ends, other beams, post centres, the grid); its end travels with it. Previews through
+ * live overrides, writes once on release.
+ */
+export declare const beamFloorplanMoveTarget: FloorplanMoveTarget<BeamNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

package/dist/beam/floorplan-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/beam/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAGzB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAInE,wDAAwD;AACxD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,KAAK,EAAE,aAAa,GACnB,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,CAKjC;AAED;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAqCjE,CAAA"}

package/dist/beam/floorplan-move.js

@@ -0,0 +1,54 @@
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { snapBeamPoint } from './drafting.js';
+/** A beam translated by `delta`, both ends together. */
+export function movedBeamEnds(beam, delta) {
+    return {
+        start: [beam.start[0] + delta[0], beam.start[1] + delta[1]],
+        end: [beam.end[0] + delta[0], beam.end[1] + delta[1]],
+    };
+}
+/**
+ * A beam moved in the plan: its start follows the pointer and snaps as the beam tool snaps (wall
+ * faces and ends, other beams, post centres, the grid); its end travels with it. Previews through
+ * live overrides, writes once on release.
+ */
+export const beamFloorplanMoveTarget = ({ node, nodes }) => {
+    const id = node.id;
+    const origin = [node.start[0], node.start[1]];
+    let anchor = null;
+    let delta = [0, 0];
+    return {
+        affectedIds: [id],
+        apply({ planPoint, modifiers }) {
+            if (!anchor) {
+                anchor = [planPoint[0], planPoint[1]];
+                return;
+            }
+            const at = node.parentId
+                ? snapBeamPoint({
+                    point: [origin[0] + planPoint[0] - anchor[0], origin[1] + planPoint[1] - anchor[1]],
+                    nodes,
+                    levelId: node.parentId,
+                    ignoreIds: [node.id],
+                    free: modifiers.altKey,
+                }).point
+                : origin;
+            const next = [at[0] - origin[0], at[1] - origin[1]];
+            if (next[0] === delta[0] && next[1] === delta[1])
+                return;
+            delta = next;
+            triggerSFX('sfx:grid-snap');
+            useLiveNodeOverrides.getState().set(id, movedBeamEnds(node, delta));
+        },
+        canCommit() {
+            return delta[0] !== 0 || delta[1] !== 0;
+        },
+        commit() {
+            useScene.getState().updateNodes([{ id, data: movedBeamEnds(node, delta) }]);
+            useLiveNodeOverrides.getState().clear(id);
+            useViewer.getState().setSelection({ selectedIds: [id] });
+        },
+    };
+};