@pascal-app/nodes 1.0.4 → 1.0.6

package/dist/cabinet/kitchen-catalog.js

@@ -0,0 +1,62 @@
+import { CABINET_PRESETS } from './presets.js';
+export const KITCHEN_ITEMS = CABINET_PRESETS.map((preset) => ({
+    ...preset,
+    group: (['base-door', 'drawer-base', 'wall-cabinet', 'tall-pantry'].includes(preset.id)
+        ? 'Cabinets'
+        : 'Appliances & fixtures'),
+    keywords: {
+        'base-door': 'storage cupboard lower cabinet',
+        'drawer-base': 'drawers storage cutlery',
+        'wall-cabinet': 'upper overhead cupboard wall mounted',
+        'tall-pantry': 'pantry tall storage cupboard',
+        'fridge-single': 'refrigerator refrigeration freezer fridge integrated',
+        dishwasher: 'dishwasher dishes integrated',
+        'sink-base': 'sink basin washing faucet tap',
+        'oven-tower': 'oven tower microwave baking',
+        'cooktop-gas': 'gas hob stove cooker cooktop',
+        'cooktop-induction': 'electric induction hob stove cooktop',
+    }[preset.id],
+}));
+export function kitchenItemMatches(id, query) {
+    const item = KITCHEN_ITEMS.find((entry) => entry.id === id);
+    if (!item)
+        return false;
+    const text = `${item.label} ${item.keywords} kitchen cabinet`.toLowerCase();
+    return query
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)
+        .every((word) => text.includes(word));
+}
+export function kitchenPresetForModule(node, run) {
+    const types = node.stack?.map((part) => part.type) ?? [];
+    if (types.some((type) => type.startsWith('fridge-')))
+        return 'fridge-single';
+    if (types.includes('dishwasher'))
+        return 'dishwasher';
+    if (types.includes('sink'))
+        return 'sink-base';
+    if (types.includes('cooktop-gas'))
+        return 'cooktop-gas';
+    if (types.includes('cooktop-induction'))
+        return 'cooktop-induction';
+    if (types.includes('oven') || types.includes('microwave'))
+        return 'oven-tower';
+    if (run?.runTier === 'wall')
+        return 'wall-cabinet';
+    if (node.cabinetType === 'tall')
+        return 'tall-pantry';
+    if (types.length > 0 && types.every((type) => type === 'drawer'))
+        return 'drawer-base';
+    return 'base-door';
+}
+/** The kitchen's placed modules a query names; fillers are part of their run, not items. */
+export function findKitchenItems(nodes, query) {
+    return Object.values(nodes).filter((node) => {
+        if (node.type !== 'cabinet-module' || node.moduleKind !== 'standard')
+            return false;
+        const parent = node.parentId ? nodes[node.parentId] : undefined;
+        const id = kitchenPresetForModule(node, parent?.type === 'cabinet' ? parent : undefined);
+        return (kitchenItemMatches(id, query) || (node.name ?? '').toLowerCase().includes(query.toLowerCase()));
+    });
+}

package/dist/cabinet/kitchen-collection.d.ts

@@ -0,0 +1,11 @@
+import type { CabinetPresetId } from './presets.js';
+export declare function KitchenThumbnail({ id }: {
+    id: CabinetPresetId;
+}): import("react").JSX.Element;
+export declare function KitchenCollection({ onSelect, activeId, query, includeWall, }: {
+    onSelect: (id: CabinetPresetId) => void;
+    activeId?: CabinetPresetId | null;
+    query?: string;
+    includeWall?: boolean;
+}): import("react").JSX.Element;
+//# sourceMappingURL=kitchen-collection.d.ts.map

package/dist/cabinet/kitchen-collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kitchen-collection.d.ts","sourceRoot":"","sources":["../../src/cabinet/kitchen-collection.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAEhD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,EAAE,EAAE;IAAE,EAAE,EAAE,eAAe,CAAA;CAAE,+BAc/D;AAED,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,WAAkB,GACnB,EAAE;IACD,QAAQ,EAAE,CAAC,EAAE,EAAE,eAAe,KAAK,IAAI,CAAA;IACvC,QAAQ,CAAC,EAAE,eAAe,GAAG,IAAI,CAAA;IACjC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,+BA+DA"}

package/dist/cabinet/kitchen-collection.js

@@ -0,0 +1,19 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { BuildPanelSection, BuildToolGrid, BuildToolTile } from '@pascal-app/editor';
+import { useId, useState } from 'react';
+import { KITCHEN_ITEMS, kitchenItemMatches } from './kitchen-catalog.js';
+import useCabinetPlacementStatus from './placement-status.js';
+export function KitchenThumbnail({ id }) {
+    return (_jsx("img", { src: `/icons/kitchen/${id}.webp`, alt: "", "aria-hidden": "true", width: 256, height: 256, loading: "lazy", decoding: "async", draggable: false, className: "h-20 w-full object-contain" }));
+}
+export function KitchenCollection({ onSelect, activeId, query, includeWall = true, }) {
+    const [search, setSearch] = useState('');
+    const placementTarget = useCabinetPlacementStatus((state) => state.target);
+    const inputId = useId();
+    const items = KITCHEN_ITEMS.filter((item) => (includeWall || item.id !== 'wall-cabinet') && kitchenItemMatches(item.id, query ?? search));
+    return (_jsxs("div", { className: "space-y-3", children: [placementTarget && (_jsx("p", { role: "status", className: "rounded-lg border border-border bg-muted/40 px-3 py-2 text-xs", children: placementTarget })), query === undefined && (_jsxs("div", { children: [_jsx("label", { htmlFor: inputId, className: "sr-only", children: "Search kitchen items" }), _jsx("input", { id: inputId, type: "search", placeholder: "Search fridge, sink, cabinets\u2026", value: search, onChange: (event) => setSearch(event.target.value), className: "h-9 w-full rounded-lg border border-border bg-background px-3 text-xs focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring" })] })), ['Cabinets', 'Appliances & fixtures'].map((group) => {
+                const entries = items.filter((item) => item.group === group);
+                return (entries.length > 0 && (_jsx(BuildPanelSection, { id: `kitchen-${group === 'Cabinets' ? 'cabinets' : 'appliances'}`, title: group, children: _jsx(BuildToolGrid, { columns: 3, children: entries.map((item) => (_jsx(BuildToolTile, { "aria-label": `Choose ${item.label}`, active: activeId === item.id, tone: "neutral", iconSrc: `/icons/kitchen/${item.id}.webp`, label: item.label, onClick: () => onSelect(item.id) }, item.id))) }) }, group)));
+            }), !items.length && (_jsx("p", { role: "status", className: "text-xs text-muted-foreground", children: "No kitchen items match. Try \u201Cfridge\u201D, \u201Csink\u201D, or \u201Ccabinet\u201D." }))] }));
+}

package/dist/cabinet/kitchen-module-actions.d.ts

@@ -0,0 +1,8 @@
+import { CabinetModuleNode, type CabinetNode } from '@pascal-app/core';
+import { type CabinetPresetId } from './presets.js';
+export declare function KitchenModuleActions({ node, run, onReplace, }: {
+    node: CabinetModuleNode;
+    run: CabinetNode;
+    onReplace: (id: CabinetPresetId) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=kitchen-module-actions.d.ts.map

package/dist/cabinet/kitchen-module-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kitchen-module-actions.d.ts","sourceRoot":"","sources":["../../src/cabinet/kitchen-module-actions.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,iBAAiB,EACjB,KAAK,WAAW,EAIjB,MAAM,kBAAkB,CAAA;AAMzB,OAAO,EAAE,KAAK,eAAe,EAAqB,MAAM,WAAW,CAAA;AAYnE,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,EACJ,GAAG,EACH,SAAS,GACV,EAAE;IACD,IAAI,EAAE,iBAAiB,CAAA;IACvB,GAAG,EAAE,WAAW,CAAA;IAChB,SAAS,EAAE,CAAC,EAAE,EAAE,eAAe,KAAK,IAAI,CAAA;CACzC,+BAsNA"}

package/dist/cabinet/kitchen-module-actions.js

@@ -0,0 +1,117 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CabinetModuleNode, createSceneApi, runAsSingleSceneHistoryStep, useScene, } from '@pascal-app/core';
+import { ActionButton, formatLinearMeasurement } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useState } from 'react';
+import { applyCabinetModuleInsertion, cabinetModuleForRunInsertion } from './insertion.js';
+import { KitchenCollection } from './kitchen-collection.js';
+import { cabinetPresetById } from './presets.js';
+import { moduleMaxX, moduleMinX, planRunModuleInsertion, runWallConstraints } from './run-layout.js';
+import { bumpCabinetRunLayoutRevision, cabinetModulesForRun, cornerPinnedEndsForRun, runModuleBaseY, syncCornerRunsFromRunSources, } from './run-ops.js';
+import { planCabinetPresetReflow } from './run-panel.js';
+import { backAnchoredModuleZ } from './stack.js';
+export function KitchenModuleActions({ node, run, onReplace, }) {
+    const [action, setAction] = useState(null);
+    const [presetId, setPresetId] = useState(null);
+    const [error, setError] = useState(null);
+    const nodes = useScene((state) => state.nodes);
+    const unit = useViewer((state) => state.unit);
+    const notation = useViewer((state) => state.metricNotation);
+    const format = (value) => formatLinearMeasurement(value, unit, notation);
+    const modules = cabinetModulesForRun(run, nodes);
+    const preset = presetId ? cabinetPresetById(presetId) : null;
+    const patch = preset?.createPatch(run);
+    const module = patch
+        ? cabinetModuleForRunInsertion(CabinetModuleNode.parse({
+            ...patch,
+            parentId: run.id,
+            position: [
+                action === 'left'
+                    ? moduleMinX(node) - (patch.width ?? 0.5) / 2
+                    : moduleMaxX(node) + (patch.width ?? 0.5) / 2,
+                runModuleBaseY(run),
+                backAnchoredModuleZ(node.position[2], node.depth, patch.depth ?? run.depth),
+            ],
+        }), run)
+        : null;
+    const insertion = module && action !== 'replace'
+        ? planRunModuleInsertion({
+            modules,
+            insertion: module,
+            wallConstraints: runWallConstraints(run, modules, nodes, { widthGrowth: module.width }),
+            fillerIds: new Set(modules
+                .filter((entry) => entry.moduleKind === 'corner-filler')
+                .map((entry) => entry.id)),
+            preserveEnds: cornerPinnedEndsForRun(modules),
+            anchorInsertionSide: action === 'left' ? 'right' : 'left',
+        })
+        : null;
+    const replacement = patch && action === 'replace'
+        ? planCabinetPresetReflow({
+            modules,
+            parentRun: run,
+            selected: node,
+            patch,
+            scene: useScene.getState(),
+        })
+        : null;
+    const planned = insertion?.ok ? [...insertion.modules, insertion.inserted] : replacement;
+    const fits = !!planned?.length;
+    const changes = planned?.filter((entry) => {
+        const before = modules.find((existing) => existing.id === entry.id);
+        return (before &&
+            (Math.abs(before.width - entry.width) > 0.0001 ||
+                Math.abs(before.position[0] - entry.position[0]) > 0.0001));
+    }) ?? [];
+    const reset = () => {
+        setAction(null);
+        setPresetId(null);
+        setError(null);
+    };
+    const commit = () => {
+        if (!(fits && presetId))
+            return;
+        const api = createSceneApi(useScene);
+        try {
+            runAsSingleSceneHistoryStep(useScene, () => {
+                if (action === 'replace')
+                    onReplace(presetId);
+                else if (module && insertion?.ok) {
+                    const id = applyCabinetModuleInsertion({ module, plan: insertion, run, sceneApi: api });
+                    if (!id)
+                        throw new Error('The kitchen changed. Select an item again to refresh the preview.');
+                    syncCornerRunsFromRunSources({ run: api.get(run.id) ?? run, sceneApi: api });
+                    bumpCabinetRunLayoutRevision(api, run);
+                    useViewer.getState().setSelection({ selectedIds: [id] });
+                }
+            });
+            reset();
+        }
+        catch (cause) {
+            setError(cause instanceof Error ? cause.message : 'Unable to update this kitchen.');
+        }
+    };
+    const changedId = action === 'replace' ? node.id : module?.id;
+    return (_jsxs("div", { className: "space-y-3 px-1 pb-2", children: [_jsxs("div", { className: "flex gap-2", children: [_jsx(ActionButton, { label: "Add beside", onClick: () => {
+                            setAction('right');
+                            setPresetId(null);
+                        } }), _jsx(ActionButton, { label: "Replace with\u2026", onClick: () => {
+                            setAction('replace');
+                            setPresetId(null);
+                        } })] }), action && (_jsxs("div", { className: "space-y-3 rounded-xl border border-border p-3", children: [_jsxs("div", { className: "flex items-center justify-between gap-2 text-xs font-medium", children: [_jsx("span", { children: action === 'replace' ? 'Replace selected item' : 'Add beside selected item' }), _jsx("button", { type: "button", onClick: reset, className: "min-h-8 shrink-0 rounded px-2 py-1.5 hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring", children: "Cancel" })] }), action !== 'replace' && (_jsx("div", { className: "flex gap-2", children: ['left', 'right'].map((side) => (_jsx("button", { type: "button", "aria-pressed": action === side, onClick: () => setAction(side), className: `flex-1 rounded-lg border px-2 py-2 text-xs focus-visible:ring-2 focus-visible:ring-ring ${action === side ? 'border-primary bg-primary/10' : 'border-border'}`, children: side === 'left' ? 'Left side' : 'Right side' }, side))) })), _jsx(KitchenCollection, { activeId: presetId, includeWall: false, onSelect: (id) => {
+                            setPresetId(id);
+                            setError(null);
+                        } }), preset && (_jsxs("div", { role: "status", className: "space-y-2 border-t border-border pt-3 text-xs", children: [_jsxs("p", { className: "font-medium", children: [preset.label, " \u00B7 ", format(patch?.width ?? 0)] }), fits && planned ? (_jsxs(_Fragment, { children: [_jsx("div", { role: "img", "aria-label": "Kitchen run preview, highlighted item is the proposed change", className: "flex h-12 gap-0.5", children: [...planned]
+                                            .sort((a, b) => a.position[0] - b.position[0])
+                                            .map((entry) => (_jsx("div", { style: { flex: entry.width }, title: `${entry.id === changedId ? preset.label : (modules.find((existing) => existing.id === entry.id)?.name ?? 'Cabinet')}: ${format(entry.width)}`, className: `min-w-0 rounded border ${entry.id === changedId ? 'border-primary bg-primary/30' : 'border-border bg-muted'}` }, entry.id))) }), _jsx("p", { children: action === 'replace'
+                                            ? 'Replaces only the selected item.'
+                                            : `Inserts on the ${action} of the selected item.` }), changes.map((entry) => {
+                                        const before = modules.find((existing) => existing.id === entry.id);
+                                        return (_jsxs("p", { className: "text-muted-foreground", children: [before.name || 'Cabinet', ":", ' ', Math.abs(before.width - entry.width) > 0.0001
+                                                    ? `${format(before.width)} → ${format(entry.width)}`
+                                                    : `moves ${format(Math.abs(before.position[0] - entry.position[0]))}`] }, entry.id));
+                                    }), action === 'replace' &&
+                                        patch?.cabinetType === 'tall' &&
+                                        node.children.length > 0 && (_jsx("p", { className: "text-muted-foreground", children: "An upper cabinet attached to this item will be removed to make room." })), _jsx(ActionButton, { label: action === 'replace' ? `Replace with ${preset.label}` : `Add ${preset.label}`, onClick: commit })] })) : (_jsxs("p", { children: ["This ", format(patch?.width ?? 0), " item cannot fit within the current run and its wall or corner limits. Move an end cabinet or free space, then try again."] }))] })), error && (_jsx("p", { role: "alert", className: "text-xs text-destructive", children: error }))] }))] }));
+}

package/dist/cabinet/kitchen-placement.d.ts

@@ -0,0 +1,3 @@
+import { type CabinetPresetId } from './presets.js';
+export declare function beginKitchenPlacement(id: CabinetPresetId): void;
+//# sourceMappingURL=kitchen-placement.d.ts.map

package/dist/cabinet/kitchen-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kitchen-placement.d.ts","sourceRoot":"","sources":["../../src/cabinet/kitchen-placement.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,eAAe,EAAqB,MAAM,WAAW,CAAA;AAEnE,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,eAAe,QAUxD"}

package/dist/cabinet/kitchen-placement.js

@@ -0,0 +1,16 @@
+import { emitter } from '@pascal-app/core';
+import { useEditor } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import useCabinetPlacementType from './placement-type.js';
+import { cabinetPresetById } from './presets.js';
+export function beginKitchenPlacement(id) {
+    emitter.emit('tool:cancel');
+    const editor = useEditor.getState();
+    useCabinetPlacementType.getState().setType('cabinet');
+    editor.setToolDefaults('cabinet', { ...cabinetPresetById(id).createPatch(), kitchenPreset: id });
+    editor.setContinuation('cabinet', 'single');
+    useViewer.getState().setSelection({ selectedIds: [], zoneId: null });
+    editor.setPhase('building');
+    editor.setCatalogCategory(null);
+    editor.armToolMode({ mode: 'build', tool: 'cabinet' });
+}

package/dist/cabinet/move-frame.js

@@ -1,8 +1,8 @@
 import { findLevelAncestorId } from '@pascal-app/core';
-import { findWallOpeningConflicts } from '../shared/wall-opening-clearance';
-import { moduleMaxX, moduleMinX, planToRunLocal, runLocalToPlan } from './run-layout';
-import { bumpCabinetRunLayoutRevision, cabinetModulesForRun, cabinetModuleTotalHeight, previewCornerRunsFromRunSources, syncCornerRunsFromSourceModule, } from './run-ops';
-import { findClosestCabinetWallInPlan, resolveCabinetWallFaceOffset } from './wall-snap';
+import { findWallOpeningConflicts } from '../shared/wall-opening-clearance.js';
+import { moduleMaxX, moduleMinX, planToRunLocal, runLocalToPlan } from './run-layout.js';
+import { bumpCabinetRunLayoutRevision, cabinetModulesForRun, cabinetModuleTotalHeight, previewCornerRunsFromRunSources, syncCornerRunsFromSourceModule, } from './run-ops.js';
+import { findClosestCabinetWallInPlan, resolveCabinetWallFaceOffset } from './wall-snap.js';
 /** Matches the generic move tool's Figma-alignment pull (8 cm). */
 const MAGNETIC_THRESHOLD_M = 0.08;
 const GUIDE_EPSILON_M = 1e-4;

package/dist/cabinet/neighbor-placement.d.ts

@@ -0,0 +1,335 @@
+import type { AnyNode, AnyNodeId, CabinetModuleNode } from '@pascal-app/core';
+/** Attach at a run's exposed ends; interior insertion keeps its existing wall planner. */
+export declare function resolveCabinetNeighborPlacement({ nodes, levelId, position, module, wallTier, threshold, }: {
+    nodes: Record<AnyNodeId, AnyNode>;
+    levelId: string;
+    position: [number, number, number];
+    module: CabinetModuleNode;
+    wallTier: boolean;
+    threshold?: number;
+}): {
+    run: {
+        object: "node";
+        name?: string | undefined;
+        parentId: string | null;
+        visible: boolean;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "orthographic" | "perspective";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        metadata: Record<string, unknown>;
+        provenance?: {
+            refs: {
+                ns?: string | undefined;
+                id: string;
+                role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+            }[];
+            lineage?: {
+                op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+                fromIds: string[];
+            } | undefined;
+        } | undefined;
+        position: [number, number, number];
+        rotation: number;
+        supportSlabId?: string | undefined;
+        width: number;
+        depth: number;
+        carcassHeight: number;
+        operationState: number;
+        plinthHeight: number;
+        toeKickDepth: number;
+        boardThickness: number;
+        countertopThickness: number;
+        countertopOverhang: number;
+        countertopBackOverhang: number;
+        withFinishedBack: boolean;
+        frontThickness: number;
+        frontGap: number;
+        frontStyle: "raised-arch" | "shaker" | "slab";
+        panelReady: boolean;
+        handleStyle: "bar" | "cutout" | "hole" | "knob" | "none";
+        handlePosition: "auto" | "center" | "top";
+        frontOverlay: "full" | "inset";
+        withBottomPanel: boolean;
+        showPlinth: boolean;
+        withCountertop: boolean;
+        material?: {
+            id?: string | undefined;
+            preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "back" | "double" | "front";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        materialPreset?: string | undefined;
+        slots?: Record<string, string> | undefined;
+        stack?: ({
+            id: string;
+            height?: number | undefined;
+            type: "shelf";
+            shelfCount?: number | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "drawer";
+            drawerCount?: number | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "door";
+            doorType?: "double" | "glass" | "single-left" | "single-right" | undefined;
+            shelfCount?: number | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "sink";
+            sinkLayout?: "double" | "double-offset" | "single" | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "oven";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "microwave";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "dishwasher";
+        } | {
+            id: string;
+            height?: number | undefined;
+            cooktopBurnersOn?: boolean | undefined;
+            cooktopActiveBurners?: number[] | undefined;
+            cooktopKnobProgress?: number[] | undefined;
+            cooktopShowGrate?: boolean | undefined;
+            type: "cooktop-gas";
+            cooktopLayout?: "gas-2burner" | "gas-4burner" | "gas-5burner-wok" | "gas-6burner" | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            cooktopBurnersOn?: boolean | undefined;
+            cooktopActiveBurners?: number[] | undefined;
+            cooktopKnobProgress?: number[] | undefined;
+            cooktopShowGrate?: boolean | undefined;
+            type: "cooktop-induction";
+            cooktopLayout?: "induction-2zone" | "induction-4zone" | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "pull-out-pantry";
+            shelfCount?: number | undefined;
+            pantryRackStyle?: "glass" | "tray" | "wire" | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "fridge-single";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "fridge-double";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "fridge-top-freezer";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "fridge-bottom-freezer";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "hood-pyramid";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "hood-curved-glass";
+        })[] | undefined;
+        id: `cabinet_${string}`;
+        type: "cabinet";
+        runTier: "base" | "tall" | "wall";
+        children: string[];
+        barLedge?: {
+            edge: "back" | "left" | "right";
+            height: number;
+            depth: number;
+        } | undefined;
+        withWaterfall: boolean;
+        withFinishedEnds: boolean;
+    };
+    side: "left" | "right";
+    depth: number;
+    result: import("./run-layout.js").RunModuleInsertionPlan<{
+        object: "node";
+        name?: string | undefined;
+        parentId: string | null;
+        visible: boolean;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "orthographic" | "perspective";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        metadata: Record<string, unknown>;
+        provenance?: {
+            refs: {
+                ns?: string | undefined;
+                id: string;
+                role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+            }[];
+            lineage?: {
+                op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+                fromIds: string[];
+            } | undefined;
+        } | undefined;
+        position: [number, number, number];
+        rotation: number;
+        supportSlabId?: string | undefined;
+        width: number;
+        depth: number;
+        carcassHeight: number;
+        operationState: number;
+        plinthHeight: number;
+        toeKickDepth: number;
+        boardThickness: number;
+        countertopThickness: number;
+        countertopOverhang: number;
+        countertopBackOverhang: number;
+        withFinishedBack: boolean;
+        frontThickness: number;
+        frontGap: number;
+        frontStyle: "raised-arch" | "shaker" | "slab";
+        panelReady: boolean;
+        handleStyle: "bar" | "cutout" | "hole" | "knob" | "none";
+        handlePosition: "auto" | "center" | "top";
+        frontOverlay: "full" | "inset";
+        withBottomPanel: boolean;
+        showPlinth: boolean;
+        withCountertop: boolean;
+        material?: {
+            id?: string | undefined;
+            preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "back" | "double" | "front";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        materialPreset?: string | undefined;
+        slots?: Record<string, string> | undefined;
+        stack?: ({
+            id: string;
+            height?: number | undefined;
+            type: "shelf";
+            shelfCount?: number | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "drawer";
+            drawerCount?: number | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "door";
+            doorType?: "double" | "glass" | "single-left" | "single-right" | undefined;
+            shelfCount?: number | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "sink";
+            sinkLayout?: "double" | "double-offset" | "single" | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "oven";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "microwave";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "dishwasher";
+        } | {
+            id: string;
+            height?: number | undefined;
+            cooktopBurnersOn?: boolean | undefined;
+            cooktopActiveBurners?: number[] | undefined;
+            cooktopKnobProgress?: number[] | undefined;
+            cooktopShowGrate?: boolean | undefined;
+            type: "cooktop-gas";
+            cooktopLayout?: "gas-2burner" | "gas-4burner" | "gas-5burner-wok" | "gas-6burner" | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            cooktopBurnersOn?: boolean | undefined;
+            cooktopActiveBurners?: number[] | undefined;
+            cooktopKnobProgress?: number[] | undefined;
+            cooktopShowGrate?: boolean | undefined;
+            type: "cooktop-induction";
+            cooktopLayout?: "induction-2zone" | "induction-4zone" | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "pull-out-pantry";
+            shelfCount?: number | undefined;
+            pantryRackStyle?: "glass" | "tray" | "wire" | undefined;
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "fridge-single";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "fridge-double";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "fridge-top-freezer";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "fridge-bottom-freezer";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "hood-pyramid";
+        } | {
+            id: string;
+            height?: number | undefined;
+            type: "hood-curved-glass";
+        })[] | undefined;
+        id: `cabinet-module_${string}`;
+        type: "cabinet-module";
+        children: string[];
+        cabinetType: "base" | "tall";
+        moduleKind: "corner-filler" | "standard" | "wall-filler";
+        openSide?: "left" | "right" | undefined;
+        cornerShelf?: boolean | undefined;
+        topFinish: "none" | "top-cabinet" | "trim";
+        topFinishHeight: number;
+        topFinishDepth: number;
+    }>;
+} | null;
+//# sourceMappingURL=neighbor-placement.d.ts.map

package/dist/cabinet/neighbor-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neighbor-placement.d.ts","sourceRoot":"","sources":["../../src/cabinet/neighbor-placement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAe,MAAM,kBAAkB,CAAA;AAW1F,0FAA0F;AAC1F,wBAAgB,+BAA+B,CAAC,EAC9C,KAAK,EACL,OAAO,EACP,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,SAAgB,GACjB,EAAE;IACD,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,MAAM,EAAE,iBAAiB,CAAA;IACzB,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAmDA"}

package/dist/cabinet/neighbor-placement.js

@@ -0,0 +1,48 @@
+import { moduleMaxX, moduleMinX, planRunModuleInsertion, planToRunLocal, runWallConstraints, sortRunModules, } from './run-layout.js';
+import { cabinetModulesForRun, cornerPinnedEndsForRun } from './run-ops.js';
+/** Attach at a run's exposed ends; interior insertion keeps its existing wall planner. */
+export function resolveCabinetNeighborPlacement({ nodes, levelId, position, module, wallTier, threshold = 0.25, }) {
+    let best = null;
+    for (const candidate of Object.values(nodes)) {
+        if (candidate.type !== 'cabinet' ||
+            candidate.parentId !== levelId ||
+            candidate.visible === false ||
+            (candidate.runTier === 'wall') !== wallTier)
+            continue;
+        const modules = sortRunModules(cabinetModulesForRun(candidate, nodes));
+        if (!modules.length)
+            continue;
+        const local = planToRunLocal(candidate, position[0], position[1], position[2]);
+        const pinned = cornerPinnedEndsForRun(modules);
+        for (const side of ['left', 'right']) {
+            if (pinned[side])
+                continue;
+            const neighbor = side === 'left' ? modules[0] : modules[modules.length - 1];
+            if (neighbor.moduleKind !== 'standard')
+                continue;
+            const x = side === 'left'
+                ? moduleMinX(neighbor) - module.width / 2
+                : moduleMaxX(neighbor) + module.width / 2;
+            const distance = Math.hypot(local[0] - x, local[2] - neighbor.position[2]);
+            if (distance <= threshold && (!best || distance < best.distance))
+                best = { distance, run: candidate, neighbor, side, x };
+        }
+    }
+    if (!best)
+        return null;
+    const { run, neighbor, side, x } = best;
+    const modules = cabinetModulesForRun(run, nodes);
+    const result = planRunModuleInsertion({
+        modules,
+        insertion: {
+            id: module.id,
+            width: module.width,
+            position: [x, neighbor.position[1], neighbor.position[2]],
+        },
+        wallConstraints: runWallConstraints(run, modules, nodes, { widthGrowth: module.width }),
+        fillerIds: new Set(modules.filter((entry) => entry.moduleKind === 'corner-filler').map((entry) => entry.id)),
+        preserveEnds: cornerPinnedEndsForRun(modules),
+        anchorInsertionSide: side === 'left' ? 'right' : 'left',
+    });
+    return { run, side, depth: neighbor.depth, result };
+}