@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/cabinet/countertop-layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"countertop-layout.d.ts","sourceRoot":"","sources":["../../src/cabinet/countertop-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,WAAW,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvF,OAAO,EAAE,KAAK,YAAY,EAAa,MAAM,oBAAoB,CAAA;AAIjE,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,YAAY,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAExE,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,CAAC,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BvE,WAAW;iBACR,WAAW;cACd,WAAW,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC;;;IA4DvD"}
+{"version":3,"file":"countertop-layout.d.ts","sourceRoot":"","sources":["../../src/cabinet/countertop-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,WAAW,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvF,OAAO,EAAE,KAAK,YAAY,EAAa,MAAM,oBAAoB,CAAA;AAIjE,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,YAAY,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAExE,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,CAAC,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BvE,WAAW;iBACR,WAAW;cACd,WAAW,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC;;;IA4DvD"}

package/dist/cabinet/countertop-layout.js

@@ -1,6 +1,6 @@
-import { sinkBowls } from './appliance-layout';
-import { getRunSpanEnds, getRunSpanGroups } from './run-layout';
-import { compartmentSinkLayout } from './stack';
+import { sinkBowls } from './appliance-layout.js';
+import { getRunSpanEnds, getRunSpanGroups } from './run-layout.js';
+import { compartmentSinkLayout } from './stack.js';
 export function getCabinetCountertopLayout(node, ctx) {
     const modules = (ctx?.children ?? []).filter((child) => child.type === 'cabinet-module');
     const groups = getRunSpanGroups(modules, { runTier: node.runTier });

package/dist/cabinet/definition.d.ts

@@ -1,5 +1,5 @@
 import type { AnyNode, AnyNodeId, CabinetNode as CabinetNodeType, FloorPlacedFootprint, NodeDefinition, SceneApi } from '@pascal-app/core';
-import { CabinetModuleNode, CabinetNode } from './schema';
+import { CabinetModuleNode, CabinetNode } from './schema.js';
 export declare function cabinetFloorPlacedFootprints(node: CabinetNodeType, nodes?: Readonly<Record<AnyNodeId, AnyNode>>): FloorPlacedFootprint[];
 export type CabinetRunFootprint = {
     parentId: AnyNodeId | null;

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/cabinet/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EAET,WAAW,IAAI,eAAe,EAG9B,oBAAoB,EAMpB,cAAc,EACd,QAAQ,EACT,MAAM,kBAAkB,CAAA;AAyDzB,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAwKzD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,eAAe,EACrB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC3C,oBAAoB,EAAE,CAcxB;AAiKD,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAA;IAC1B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,mBAAmB,CAWrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,SAAS,mBAAmB,EAAE,EAC1C,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,QAgD9B;AAED,oEAAoE;AACpE,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAexE;AAgvDD,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CA+MhE,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,cAAc,CAAC,OAAO,iBAAiB,CA0K5E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/cabinet/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EAET,WAAW,IAAI,eAAe,EAG9B,oBAAoB,EAMpB,cAAc,EACd,QAAQ,EACT,MAAM,kBAAkB,CAAA;AA2DzB,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAuKzD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,eAAe,EACrB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC3C,oBAAoB,EAAE,CAcxB;AAiKD,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAA;IAC1B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,mBAAmB,CAWrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,SAAS,mBAAmB,EAAE,EAC1C,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,QAgD9B;AAED,oEAAoE;AACpE,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAexE;AAgvDD,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAkNhE,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,cAAc,CAAC,OAAO,iBAAiB,CA2K5E,CAAA"}

package/dist/cabinet/definition.js

@@ -1,30 +1,30 @@
-import { CABINET_METRIC_DEFAULTS, findLevelAncestorId, selectionProxyIdFromMetadata, } from '@pascal-app/core';
-import { findWallOpeningConflicts } from '../shared/wall-opening-clearance';
-import { bakeCabinetAnimationClip } from './animation';
-import { buildCabinetFloorplan, buildCabinetModuleFloorplan } from './floorplan';
-import { cabinetModuleFloorplanMoveTarget } from './floorplan-move';
-import { cabinetFloorplanSiblingOverrides } from './floorplan-overrides';
-import { buildCabinetGeometry } from './geometry';
-import { withCabinetHostedChildren } from './hosted-resize';
-import { toggleCabinetOperationState } from './interaction';
-import { cabinetModuleParentFrame } from './move-frame';
-import { cabinetPaint } from './paint';
-import { cabinetModuleUsesFixedApplianceWidth } from './panel-visibility';
-import { cabinetModuleParametrics, cabinetParametrics } from './parametrics';
-import { resolveCabinetGridPosition } from './placement-snap';
-import useCabinetPlacementType from './placement-type';
-import { metadataForSelectedWidth, metadataWithPresetWidthDebt } from './preset-width-debt';
-import { cabinetQuickActions } from './quick-actions';
-import { cabinetConnectedDepthBounds, cabinetResizeUpperBound, MAX_CABINET_DEPTH, MAX_CABINET_WIDTH, MIN_CABINET_DEPTH, MIN_CABINET_WIDTH, } from './resize-limits';
-import { moduleSideOpen, reflowRunModules as reflowCabinetRunModules, runWallConstraints, sortRunModules, } from './run-layout';
-import { backAlignedRunDepthOverrides, backAlignZ, buildWallCornerDepthIndex, bumpCabinetRunLayoutRevision, cabinetMetadataRecord, cabinetModulesForRun, cabinetModuleTotalHeight, totalCabinetHeight as cabinetTotalHeight, cornerSourceWidthOverridesForDerivedDepth, nestedCornerRunPositionOverrides, previewCornerRunsFromRunSources, resolveCabinetType, runModuleBaseY, syncCornerRunsFromRunSources, syncCornerRunsFromSourceModule, wallChildOf, wallCornerWidthOverridesForDepthTargets, } from './run-ops';
-import { cabinetSceneAction } from './scene-action';
-import { CabinetModuleNode, CabinetNode } from './schema';
-import { cabinetSlots } from './slots';
-import { backAnchoredModuleZ, isHoodCompartmentType, minCabinetCarcassHeightForStack, stackForCabinet, } from './stack';
-import { cabinetModuleSurfaceProvider, cabinetSurfaceProvider } from './surfaces';
-import { cabinetFloorplanAffectedIds, cabinetTreeChildIds, cabinetTreeHidden, cabinetTreeLabel, } from './tree-structure';
-import { findClosestCabinetWallInPlan, resolveCabinetModuleWallSnapLocal, resolveCabinetRunWallSnap, resolveCabinetWallFaceOffset, } from './wall-snap';
+import { CABINET_METRIC_DEFAULTS, cabinetSlots, findLevelAncestorId, selectionProxyIdFromMetadata, } from '@pascal-app/core';
+import { findWallOpeningConflicts } from '../shared/wall-opening-clearance.js';
+import { bakeCabinetAnimationClip } from './animation.js';
+import { buildCabinetFloorplan, buildCabinetModuleFloorplan } from './floorplan.js';
+import { cabinetModuleFloorplanMoveTarget } from './floorplan-move.js';
+import { cabinetFloorplanSiblingOverrides } from './floorplan-overrides.js';
+import { buildCabinetGeometry } from './geometry.js';
+import { withCabinetHostedChildren } from './hosted-resize.js';
+import { toggleCabinetOperationState } from './interaction.js';
+import { cabinetModuleParentFrame } from './move-frame.js';
+import { cabinetPaint } from './paint.js';
+import { cabinetModuleUsesFixedApplianceWidth } from './panel-visibility.js';
+import { cabinetModuleParametrics, cabinetParametrics } from './parametrics.js';
+import { cabinetPlacementNotice } from './placement-notice.js';
+import { resolveCabinetGridPosition } from './placement-snap.js';
+import useCabinetPlacementType from './placement-type.js';
+import { metadataForSelectedWidth, metadataWithPresetWidthDebt } from './preset-width-debt.js';
+import { cabinetQuickActions } from './quick-actions.js';
+import { cabinetConnectedDepthBounds, cabinetResizeUpperBound, MAX_CABINET_DEPTH, MAX_CABINET_WIDTH, MIN_CABINET_DEPTH, MIN_CABINET_WIDTH, } from './resize-limits.js';
+import { moduleSideOpen, reflowRunModules as reflowCabinetRunModules, runWallConstraints, sortRunModules, } from './run-layout.js';
+import { backAlignedRunDepthOverrides, backAlignZ, buildWallCornerDepthIndex, bumpCabinetRunLayoutRevision, cabinetMetadataRecord, cabinetModulesForRun, cabinetModuleTotalHeight, totalCabinetHeight as cabinetTotalHeight, cornerSourceWidthOverridesForDerivedDepth, nestedCornerRunPositionOverrides, previewCornerRunsFromRunSources, resolveCabinetType, runModuleBaseY, syncCornerRunsFromRunSources, syncCornerRunsFromSourceModule, wallChildOf, wallCornerWidthOverridesForDepthTargets, } from './run-ops.js';
+import { cabinetSceneAction } from './scene-action.js';
+import { CabinetModuleNode, CabinetNode } from './schema.js';
+import { backAnchoredModuleZ, isHoodCompartmentType, minCabinetCarcassHeightForStack, stackForCabinet, } from './stack.js';
+import { cabinetModuleSurfaceProvider, cabinetSurfaceProvider } from './surfaces.js';
+import { cabinetFloorplanAffectedIds, cabinetTreeChildIds, cabinetTreeHidden, cabinetTreeLabel, } from './tree-structure.js';
+import { findClosestCabinetWallInPlan, resolveCabinetModuleWallSnapLocal, resolveCabinetRunWallSnap, resolveCabinetWallFaceOffset, } from './wall-snap.js';
 function isCabinetDuplicableNode(node) {
     return ((node?.type === 'cabinet' || node?.type === 'cabinet-module') &&
         Array.isArray(node.position) &&
@@ -531,7 +531,7 @@ function cabinetWallWidthGap(module, side, sceneApi) {
     return Math.max(0, direction * (connectedCenter - moduleCenter) - (module.width + connected.width) / 2);
 }
 function isCabinetWidthFiller(module) {
-    return (module.moduleKind === 'corner-filler' ||
+    return (module.moduleKind !== 'standard' ||
         module.name === 'Corner Filler' ||
         module.name === 'Wall Bridge Filler' ||
         module.name === 'Corner Wall Filler');
@@ -1801,6 +1801,8 @@ export const cabinetDefinition = {
         // material / materialPreset left undefined — paint mode writes slot refs.
     }),
     capabilities: {
+        reveal: { phase: 'furnishing', style: 'drop', height: 0.3 },
+        revealOnEdit: ['width', 'depth', 'carcassHeight', 'plinthHeight'],
         surfacePlacement: 'floor-only',
         selectable: { hitVolume: 'bbox' },
         movable: {
@@ -1854,10 +1856,11 @@ export const cabinetDefinition = {
     },
     parametrics: cabinetParametrics,
     handles: (node, sceneApi) => cabinetHandles(node, sceneApi).map(withCabinetHostedChildren),
+    placementNotice: cabinetPlacementNotice,
     geometry: buildCabinetGeometry,
     exportAnimation: ({ node, object }) => bakeCabinetAnimationClip(node, object),
     system: {
-        module: () => import('./system'),
+        module: () => import('./system.js'),
         priority: 2,
     },
     // `operationState` is deliberately absent — door/drawer poses are applied
@@ -1918,7 +1921,7 @@ export const cabinetDefinition = {
             run: (node) => toggleCabinetOperationState(node.id),
         },
     },
-    tool: () => import('./tool'),
+    tool: () => import('./tool.js'),
     toolHints: [
         { key: 'Click', label: 'Place cabinet' },
         {
@@ -2032,6 +2035,7 @@ export const cabinetModuleDefinition = {
     relations: { hosts: ['cabinet', 'cabinet-module', 'item', 'procedural-item'] },
     parametrics: cabinetModuleParametrics,
     handles: () => cabinetModuleHandles().map(withCabinetHostedChildren),
+    placementNotice: cabinetPlacementNotice,
     geometry: buildCabinetGeometry,
     exportAnimation: ({ node, object }) => bakeCabinetAnimationClip(node, object),
     // `operationState` is deliberately absent — see cabinetDefinition.geometryKey.

package/dist/cabinet/essential-controls.d.ts

@@ -0,0 +1,7 @@
+import { type CabinetCompartment } from './stack.js';
+export declare function CabinetEssentialControls({ stack, width, onReplace, }: {
+    stack: CabinetCompartment[];
+    width: number;
+    onReplace: (index: number, next: CabinetCompartment) => void;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=essential-controls.d.ts.map

package/dist/cabinet/essential-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"essential-controls.d.ts","sourceRoot":"","sources":["../../src/cabinet/essential-controls.tsx"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,kBAAkB,EAUxB,MAAM,SAAS,CAAA;AAEhB,wBAAgB,wBAAwB,CAAC,EACvC,KAAK,EACL,KAAK,EACL,SAAS,GACV,EAAE;IACD,KAAK,EAAE,kBAAkB,EAAE,CAAA;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,KAAK,IAAI,CAAA;CAC7D,sCAwGA"}

package/dist/cabinet/essential-controls.js

@@ -0,0 +1,47 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PanelSection, SegmentedControl } from '@pascal-app/editor';
+import { COOKTOP_DEFAULT_GAS_LAYOUT, COOKTOP_DEFAULT_INDUCTION_LAYOUT, compartmentDoorType, compartmentSinkLayout, isCooktopCompartmentType, isFridgeCompartmentType, patchCompartment, } from './stack.js';
+export function CabinetEssentialControls({ stack, width, onReplace, }) {
+    const entries = stack
+        .map((part, index) => ({ part, index }))
+        .filter(({ part }) => part.type === 'door' ||
+        part.type === 'sink' ||
+        isFridgeCompartmentType(part.type) ||
+        isCooktopCompartmentType(part.type));
+    if (!entries.length)
+        return null;
+    return (_jsx(PanelSection, { title: "Item options", children: entries.map(({ part, index }) => (_jsxs("div", { className: "space-y-2 pb-2", children: [_jsxs("div", { className: "text-xs text-muted-foreground", children: [part.type === 'door'
+                            ? 'Door direction'
+                            : part.type === 'sink'
+                                ? 'Sink layout'
+                                : isFridgeCompartmentType(part.type)
+                                    ? 'Fridge type'
+                                    : 'Cooktop type', entries.length > 1 ? ` · ${index + 1}` : ''] }), part.type === 'door' && (_jsx(SegmentedControl, { value: compartmentDoorType(part, width), options: [
+                        { value: 'single-left', label: 'Left hinge' },
+                        { value: 'single-right', label: 'Right hinge' },
+                        { value: 'double', label: 'Double' },
+                        { value: 'glass', label: 'Glass' },
+                    ], onChange: (value) => onReplace(index, patchCompartment(part, {
+                        doorType: value,
+                    })) })), part.type === 'sink' && (_jsx(SegmentedControl, { value: compartmentSinkLayout(part), options: [
+                        { value: 'single', label: 'Single' },
+                        { value: 'double', label: 'Double' },
+                        { value: 'double-offset', label: '60/40' },
+                    ], onChange: (value) => onReplace(index, patchCompartment(part, {
+                        sinkLayout: value,
+                    })) })), isFridgeCompartmentType(part.type) && (_jsx(SegmentedControl, { value: part.type, options: [
+                        { value: 'fridge-single', label: 'Single' },
+                        { value: 'fridge-double', label: 'Double' },
+                        { value: 'fridge-top-freezer', label: 'Top freezer' },
+                        { value: 'fridge-bottom-freezer', label: 'Bottom freezer' },
+                    ], onChange: (value) => onReplace(index, patchCompartment(part, { type: value })) })), isCooktopCompartmentType(part.type) && (_jsx(SegmentedControl, { value: part.type, options: [
+                        { value: 'cooktop-gas', label: 'Gas' },
+                        { value: 'cooktop-induction', label: 'Induction' },
+                    ], onChange: (value) => onReplace(index, patchCompartment(part, {
+                        type: value,
+                        cooktopLayout: value === 'cooktop-gas'
+                            ? COOKTOP_DEFAULT_GAS_LAYOUT
+                            : COOKTOP_DEFAULT_INDUCTION_LAYOUT,
+                    })) }))] }, part.id))) }));
+}

package/dist/cabinet/finish-operation.d.ts

@@ -0,0 +1,9 @@
+import type { AgentOperation } from '@pascal-app/core/agent-operations';
+export declare const finishKitchenRun: AgentOperation<{
+    runId: string;
+    action: 'align' | 'fill';
+}>;
+export declare const checkKitchenClearance: AgentOperation<{
+    nodeId: string;
+}>;
+//# sourceMappingURL=finish-operation.d.ts.map

package/dist/cabinet/finish-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finish-operation.d.ts","sourceRoot":"","sources":["../../src/cabinet/finish-operation.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,mCAAmC,CAAA;AAMrF,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAA;CAAE,CAkExF,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAkBpE,CAAA"}

package/dist/cabinet/finish-operation.js

@@ -0,0 +1,86 @@
+import { createSceneApi, nodeRegistry, resolveLevelId, } from '@pascal-app/core';
+import { refuse } from '@pascal-app/core/agent-tools';
+import { cabinetHostedChildUpdates } from './hosted-resize.js';
+import { cabinetPlacementNotice } from './placement-notice.js';
+import { alignCabinetRun, fitCabinetWallFillers } from './run-finishing.js';
+export const finishKitchenRun = (before, input) => {
+    const run = before[input.runId];
+    if (run?.type !== 'cabinet')
+        return refuse('cabinet_run_not_found', 'Choose a kitchen run to finish.');
+    const nodes = { ...before };
+    const updateNode = (id, data) => {
+        if (nodes[id])
+            nodes[id] = { ...nodes[id], ...data };
+    };
+    const deleteNode = (id) => {
+        const node = nodes[id];
+        if (!node)
+            return;
+        for (const child of Object.values(nodes).filter((entry) => entry.parentId === id))
+            deleteNode(child.id);
+        const parent = node.parentId ? nodes[node.parentId] : undefined;
+        if (parent && 'children' in parent)
+            updateNode(parent.id, {
+                children: parent.children.filter((child) => child !== id),
+            });
+        delete nodes[id];
+    };
+    const scene = createSceneApi({
+        getState: () => ({
+            nodes,
+            rootNodeIds: [],
+            dirtyNodes: new Set(),
+            updateNode,
+            deleteNode,
+            createNode(node, parentId) {
+                const parent = parentId ? nodes[parentId] : undefined;
+                nodes[node.id] = parentId ? { ...node, parentId } : node;
+                if (parent && 'children' in parent && !parent.children.some((id) => id === node.id))
+                    updateNode(parent.id, { children: [...parent.children, node.id] });
+            },
+            markDirty() { },
+        }),
+        temporal: { getState: () => ({ pause() { }, resume() { } }) },
+    });
+    if (input.action === 'align')
+        alignCabinetRun(run, scene);
+    else
+        fitCabinetWallFillers(run, scene);
+    const hosted = cabinetHostedChildUpdates(before, nodes);
+    if (!hosted)
+        return refuse('hosted_items_unsupported', 'Unable to finish while keeping hosted items supported. Move items on the countertop and try again.');
+    for (const [id, data] of hosted)
+        updateNode(id, data);
+    const changes = { create: [], update: [], delete: [] };
+    for (const [id, node] of Object.entries(nodes)) {
+        if (!before[id])
+            changes.create.push({ node, ...(node.parentId ? { parentId: node.parentId } : {}) });
+        else if (JSON.stringify(before[id]) !== JSON.stringify(node))
+            changes.update.push({ id, data: node });
+    }
+    for (const id of Object.keys(before))
+        if (!nodes[id])
+            changes.delete.push(id);
+    return {
+        result: {
+            runId: run.id,
+            action: input.action,
+            createdIds: changes.create.map(({ node }) => node.id),
+            updatedIds: changes.update.map(({ id }) => id),
+        },
+        changes,
+    };
+};
+export const checkKitchenClearance = (nodes, input) => {
+    const node = nodes[input.nodeId];
+    if (node?.type !== 'cabinet' && node?.type !== 'cabinet-module')
+        return refuse('cabinet_not_found', 'Choose a kitchen run or module to check.');
+    const levelId = resolveLevelId(node, nodes);
+    const unavailable = Object.values(nodes).find((candidate) => 'position' in candidate &&
+        resolveLevelId(candidate, nodes) === levelId &&
+        !nodeRegistry.has(candidate.type));
+    if (unavailable)
+        return refuse('node_capability_unavailable', `Load the ${unavailable.type} plugin definitions before checking kitchen clearance.`);
+    const notice = cabinetPlacementNotice(node, { nodes });
+    return { result: { nodeId: node.id, clear: !notice, warning: notice?.line ?? null } };
+};

package/dist/cabinet/floorplan-move.js

@@ -1,8 +1,8 @@
 import { createSceneApi, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
-import { cabinetModuleParentFrame } from './move-frame';
-import { bumpCabinetRunLayoutRevision, previewCornerRunsFromRunSources, syncCornerRunsFromSourceModule, } from './run-ops';
-import { resolveCabinetModuleWallSnapLocal } from './wall-snap';
+import { cabinetModuleParentFrame } from './move-frame.js';
+import { bumpCabinetRunLayoutRevision, previewCornerRunsFromRunSources, syncCornerRunsFromSourceModule, } from './run-ops.js';
+import { resolveCabinetModuleWallSnapLocal } from './wall-snap.js';
 function alignmentGuideFromParentFrameMatch(match) {
     return {
         axis: match.axis,

package/dist/cabinet/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/cabinet/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EAEjB,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAuBzB,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAsG1B;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,iBAAiB,EACvB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAS1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/cabinet/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EAEjB,eAAe,EAChB,MAAM,kBAAkB,CAAA;AA+BzB,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAyG1B;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,iBAAiB,EACvB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAU1B"}

package/dist/cabinet/floorplan.js

@@ -1,7 +1,8 @@
-import { GAS_HOB_BURNER_RADIUS, gasHobBurners, inductionZones } from './geometry/cooktop';
-import { FAUCET_SETBACK, sinkBowls } from './geometry/sink';
-import { getRunSpanEnds, getRunSpans } from './run-layout';
-import { compartmentCooktopLayout, compartmentSinkLayout, isCooktopCompartmentType, isFridgeCompartmentType, isHoodCompartmentType, stackForCabinet, } from './stack';
+import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
+import { GAS_HOB_BURNER_RADIUS, gasHobBurners, inductionZones } from './geometry/cooktop.js';
+import { FAUCET_SETBACK, sinkBowls } from './geometry/sink.js';
+import { getRunSpanEnds, getRunSpans } from './run-layout.js';
+import { compartmentCooktopLayout, compartmentSinkLayout, isCooktopCompartmentType, isFridgeCompartmentType, isHoodCompartmentType, stackForCabinet, } from './stack.js';
 const BODY_FILL = '#ffffff';
 const BODY_STROKE = '#7c7468';
 const SYMBOL_STROKE = '#6f675b';
@@ -10,6 +11,13 @@ const LABEL_FILL = '#6f675b';
 // cabinets, hoods) draw with a dashed outline; floor-standing units solid.
 const ABOVE_CUT_DASH = '0.08 0.06';
 const SYMBOL_STROKE_WIDTH = 0.014;
+// Sheet drafting (permit set): casework in near-black ink — the countertop
+// line the heavier one, module divisions light, appliance labels bold.
+const DRAFT_STROKE = '#1f2937';
+const DRAFT_DIVISION_STROKE = '#6b7280';
+const DRAFT_LABEL_FILL = '#111827';
+const DRAFT_LABEL_SIZE = 0.11;
+const DRAFT_LABEL_PT = 6.5;
 export function buildCabinetFloorplan(node, ctx) {
     const modules = ctx.children.filter((child) => child.type === 'cabinet-module');
     const showSelectedChrome = (ctx.viewState?.selected || ctx.viewState?.highlighted) ?? false;
@@ -37,6 +45,9 @@ export function buildCabinetFloorplan(node, ctx) {
     const backOverhang = node.withCountertop && barEdge !== 'back' ? node.countertopBackOverhang : 0;
     const spanEnds = getRunSpanEnds(node, ctx, spans);
     const children = [];
+    const drafting = readFloorplanContext(ctx).drafting;
+    const runStroke = drafting ? DRAFT_STROKE : stroke;
+    const runStrokeWidth = drafting ? 0.014 : showSelectedChrome ? 0.03 : 0.022;
     for (const span of spans) {
         const spanIndex = spans.indexOf(span);
         const ends = spanEnds[spanIndex];
@@ -58,10 +69,10 @@ export function buildCabinetFloorplan(node, ctx) {
             width: Math.max(0.01, right - left),
             height: Math.max(0.01, front - back),
             fill: node.runTier === 'wall' ? 'none' : BODY_FILL,
-            stroke,
-            strokeWidth: showSelectedChrome ? 0.03 : 0.022,
+            stroke: runStroke,
+            strokeWidth: runStrokeWidth,
             strokeDasharray: node.runTier === 'wall' ? ABOVE_CUT_DASH : undefined,
-            opacity: 0.95,
+            opacity: drafting ? 1 : 0.95,
         });
         // Raised bar slab reads as its own counter band along the chosen edge
         // (bar height sits below the ~1.2m cut plane, so it draws solid). Side
@@ -89,9 +100,9 @@ export function buildCabinetFloorplan(node, ctx) {
                 kind: 'rect',
                 ...bar,
                 fill: BODY_FILL,
-                stroke,
-                strokeWidth: showSelectedChrome ? 0.03 : 0.022,
-                opacity: 0.95,
+                stroke: runStroke,
+                strokeWidth: runStrokeWidth,
+                opacity: drafting ? 1 : 0.95,
             });
         }
     }
@@ -105,6 +116,7 @@ export function buildCabinetModuleFloorplan(node, ctx) {
         aboveCutPlane: parent?.type === 'cabinet-module'
             ? true
             : parent?.type === 'cabinet' && parent.runTier === 'wall',
+        vanity: isVanityModule(node, parent),
     });
 }
 function composeChild(parentPosition, parentRotation, childPosition, childRotation = 0) {
@@ -163,15 +175,17 @@ function withWorldChrome(position, rotation, localChildren, ctx, showSelectedChr
 }
 function buildModuleSymbol(node, position, rotation, ctx, opts) {
     const showSelectedChrome = (ctx.viewState?.selected || ctx.viewState?.highlighted) ?? false;
+    const drafting = readFloorplanContext(ctx).drafting;
     const stroke = showSelectedChrome && ctx.viewState?.palette
         ? ctx.viewState.palette.selectedStroke
         : BODY_STROKE;
     const stack = stackForCabinet(node);
-    const showCompartments = node.moduleKind !== 'corner-filler';
+    const showCompartments = node.moduleKind === 'standard';
     const hoodOnly = stack.length > 0 && stack.every((c) => isHoodCompartmentType(c.type));
     const dashed = opts.aboveCutPlane || hoodOnly;
     const hw = node.width / 2;
     const hd = node.depth / 2;
+    const appliance = moduleLabel(stack) !== null && !stack.some((c) => c.type === 'pull-out-pantry');
     const children = [
         {
             kind: 'rect',
@@ -182,33 +196,71 @@ function buildModuleSymbol(node, position, rotation, ctx, opts) {
             // Above-cut-plane units draw as a dashed open outline so the base
             // cabinet underneath stays readable.
             fill: dashed ? 'none' : BODY_FILL,
-            stroke,
-            strokeWidth: showSelectedChrome ? 0.03 : 0.018,
+            // On a sheet the countertop line (the run) carries the weight; module
+            // divisions are light, an appliance's box and anything above the cut
+            // (wall cabinets, dashed) print in full ink.
+            stroke: drafting ? (dashed || appliance ? DRAFT_STROKE : DRAFT_DIVISION_STROKE) : stroke,
+            strokeWidth: drafting
+                ? dashed || appliance
+                    ? 0.01
+                    : 0.006
+                : showSelectedChrome
+                    ? 0.03
+                    : 0.018,
             strokeDasharray: dashed ? ABOVE_CUT_DASH : undefined,
-            opacity: dashed ? 0.85 : 0.95,
+            opacity: drafting ? 1 : dashed ? 0.85 : 0.95,
         },
     ];
     if (!dashed && showCompartments) {
-        // Cabinet front edge, inset from the countertop line the run draws.
-        children.push({
-            kind: 'line',
-            x1: -hw,
-            y1: hd,
-            x2: hw,
-            y2: hd,
-            stroke,
-            strokeWidth: 0.03,
-            opacity: 0.5,
-        });
+        // Cabinet front edge, inset from the countertop line the run draws. A
+        // sheet shows the countertop line alone.
+        if (!drafting) {
+            children.push({
+                kind: 'line',
+                x1: -hw,
+                y1: hd,
+                x2: hw,
+                y2: hd,
+                stroke,
+                strokeWidth: 0.03,
+                opacity: 0.5,
+            });
+        }
         for (const compartment of stack) {
-            children.push(...compartmentSymbol(compartment, node));
+            children.push(...compartmentSymbol(compartment, node, drafting ? DRAFT_STROKE : SYMBOL_STROKE));
         }
     }
     // Appliance labels live in world space with `upright` so they read
     // horizontally regardless of run rotation and plan-view rotation.
     const worldChildren = [];
-    const label = dashed || !showCompartments ? null : moduleLabel(stack);
-    if (label) {
+    const label = dashed || !showCompartments
+        ? null
+        : drafting
+            ? draftingModuleLabel(stack, opts.vanity === true)
+            : moduleLabel(stack);
+    if (label && drafting) {
+        // a sheet prints the label at a fixed paper size, like every fixture label,
+        // in the FRONT half of the module — clear of the wall-cabinet line above
+        // the back half — on the (first) bowl of a sink, before the burners of a range
+        const [lx, ly] = draftingLabelOffset(label, stack, node);
+        const cos = Math.cos(rotation);
+        const sin = Math.sin(rotation);
+        worldChildren.push({
+            kind: 'text',
+            x: position[0] + lx * cos + ly * sin,
+            y: position[2] - lx * sin + ly * cos,
+            text: label,
+            fontSize: DRAFT_LABEL_SIZE,
+            fill: DRAFT_LABEL_FILL,
+            fontWeight: 700,
+            fontFamily: 'Helvetica, Arial, sans-serif',
+            textAnchor: 'middle',
+            dominantBaseline: 'central',
+            upright: true,
+            metadata: floorplanGeometryMetadata({ textSizePt: DRAFT_LABEL_PT }),
+        });
+    }
+    else if (label) {
         worldChildren.push({
             kind: 'text',
             x: position[0],
@@ -226,7 +278,7 @@ function buildModuleSymbol(node, position, rotation, ctx, opts) {
     return withWorldChrome(position, rotation, children, ctx, showSelectedChrome, worldChildren);
 }
 /** Plan symbol for one compartment, in module-local metres (front = +y). */
-function compartmentSymbol(compartment, node) {
+function compartmentSymbol(compartment, node, symbolStroke = SYMBOL_STROKE) {
     if (compartment.type === 'sink') {
         const innerWidth = Math.max(0.01, node.width - 2 * node.boardThickness);
         const bowls = sinkBowls(compartmentSinkLayout(compartment), innerWidth, node.depth);
@@ -239,7 +291,7 @@ function compartmentSymbol(compartment, node) {
             rx: 0.04,
             ry: 0.04,
             fill: 'none',
-            stroke: SYMBOL_STROKE,
+            stroke: symbolStroke,
             strokeWidth: SYMBOL_STROKE_WIDTH,
             opacity: 0.9,
         }));
@@ -251,7 +303,7 @@ function compartmentSymbol(compartment, node) {
             cy: -(bowls[0]?.depth ?? node.depth * 0.6) / 2 - FAUCET_SETBACK,
             r: 0.02,
             fill: 'none',
-            stroke: SYMBOL_STROKE,
+            stroke: symbolStroke,
             strokeWidth: SYMBOL_STROKE_WIDTH,
             opacity: 0.9,
         });
@@ -273,7 +325,7 @@ function compartmentSymbol(compartment, node) {
                 cy: ring.y,
                 r: ring.r,
                 fill: 'none',
-                stroke: SYMBOL_STROKE,
+                stroke: symbolStroke,
                 strokeWidth: SYMBOL_STROKE_WIDTH,
                 opacity: 0.9,
             },
@@ -283,7 +335,7 @@ function compartmentSymbol(compartment, node) {
                 cy: ring.y,
                 r: ring.r * 0.45,
                 fill: 'none',
-                stroke: SYMBOL_STROKE,
+                stroke: symbolStroke,
                 strokeWidth: SYMBOL_STROKE_WIDTH * 0.8,
                 opacity: 0.7,
             },
@@ -291,6 +343,51 @@ function compartmentSymbol(compartment, node) {
     }
     return [];
 }
+/** Where a drafting label sits in module-local plan metres (front = +y). */
+function draftingLabelOffset(label, stack, node) {
+    const hd = node.depth / 2;
+    if (label === 'R' || label === 'CT')
+        return [0, Math.max(0, hd - 0.065)];
+    const sink = stack.find((c) => c.type === 'sink');
+    if (sink) {
+        const innerWidth = Math.max(0.01, node.width - 2 * node.boardThickness);
+        const bowl = sinkBowls(compartmentSinkLayout(sink), innerWidth, node.depth)[0];
+        const front = bowl ? bowl.depth / 2 - DRAFT_LABEL_SIZE * 0.6 : 0;
+        return [bowl?.centerX ?? 0, Math.max(0, Math.min(node.depth * 0.12, front))];
+    }
+    return [0, node.depth >= 0.45 ? node.depth * 0.12 : 0];
+}
+/**
+ * The permit-set label for a module: what `moduleLabel` names, plus the
+ * plumbing a plans examiner looks for — a sink is LAV in a vanity, SINK in a
+ * kitchen — and an oven under a cooktop is the range, R.
+ */
+function draftingModuleLabel(stack, vanity) {
+    if (stack.some((c) => c.type === 'sink'))
+        return vanity ? 'LAV' : 'SINK';
+    const hasCooktop = stack.some((c) => isCooktopCompartmentType(c.type));
+    const hasOven = stack.some((c) => c.type === 'oven');
+    if (hasCooktop && hasOven)
+        return 'R';
+    if (hasCooktop)
+        return 'CT';
+    return moduleLabel(stack);
+}
+/** A bathroom vanity's module, not a kitchen's: its run is a vanity, or it is vanity-shallow. */
+function isVanityModule(node, parent) {
+    const roles = [node.metadata, parent?.metadata].map((metadata) => {
+        const m = (metadata ?? {});
+        const kitchen = m.kitchen;
+        const furnish = m.furnish;
+        return `${kitchen?.role ?? ''} ${furnish?.role ?? ''}`;
+    });
+    if (roles.some((role) => /vanity/i.test(role)))
+        return true;
+    if (/vanity|\bbath/i.test(`${parent?.name ?? ''} ${node.name ?? ''}`))
+        return true;
+    // a kitchen base is 24 in deep; a vanity 21 in
+    return node.depth < 0.575;
+}
 /** Standard plan abbreviation for the module's appliance content. */
 function moduleLabel(stack) {
     if (stack.some((c) => isFridgeCompartmentType(c.type)))

package/dist/cabinet/geometry/cooktop.d.ts

@@ -1,6 +1,6 @@
 import { Group } from 'three';
-import { type CabinetCompartment, type CabinetCooktopCompartmentType, type CooktopLayout } from '../stack';
-import { type CabinetGeometryNode } from './shared';
+import { type CabinetCompartment, type CabinetCooktopCompartmentType, type CooktopLayout } from '../stack.js';
+import { type CabinetGeometryNode } from './shared.js';
 export declare const GAS_HOB_BURNER_RADIUS = 0.052;
 export type CooktopBurnerSpec = {
     x: number;

package/dist/cabinet/geometry/cooktop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cooktop.d.ts","sourceRoot":"","sources":["../../../src/cabinet/geometry/cooktop.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,EAMN,MAAM,OAAO,CAAA;AAQd,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,6BAA6B,EAClC,KAAK,aAAa,EAMnB,MAAM,UAAU,CAAA;AACjB,OAAO,EAGL,KAAK,mBAAmB,EAWzB,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,qBAAqB,QAAQ,CAAA;AAC1C,MAAM,MAAM,iBAAiB,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AA+BtE,MAAM,MAAM,iBAAiB,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAgBhG,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,EAAE,CASxE;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,EAAE,CAMzE;AA+SD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,mBAAmB,EACzB,WAAW,EAAE,kBAAkB,EAC/B,IAAI,EAAE,6BAA6B,EACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,QAmJd"}
+{"version":3,"file":"cooktop.d.ts","sourceRoot":"","sources":["../../../src/cabinet/geometry/cooktop.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,EAMN,MAAM,OAAO,CAAA;AASd,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,6BAA6B,EAClC,KAAK,aAAa,EAMnB,MAAM,UAAU,CAAA;AACjB,OAAO,EAGL,KAAK,mBAAmB,EAYzB,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,qBAAqB,QAAQ,CAAA;AAC1C,MAAM,MAAM,iBAAiB,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AA+BtE,MAAM,MAAM,iBAAiB,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAgBhG,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,EAAE,CASxE;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,EAAE,CAMzE;AA6VD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,mBAAmB,EACzB,WAAW,EAAE,kBAAkB,EAC/B,IAAI,EAAE,6BAA6B,EACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,QAoJd"}