@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/item/definition.js

@@ -1,356 +1,4 @@
-import { getEffectiveCutterNode, getScaledDimensions, resolveCutterHost, toggleMechanism, } from '@pascal-app/core';
-import { itemHasLights, itemMechanism, toggleItemLights } from '../shared/item-interactions.js';
-import { itemBatchable } from '../shared/node-batch/batchable.js';
-import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan.js';
-import { authoredItemFaceHost } from './authored-face-host.js';
-import { buildItemContextualDimensions, buildItemFloorplan } from './floorplan.js';
-import { itemFloorplanMoveTarget } from './floorplan-move.js';
-import { itemPaint } from './paint.js';
-import { itemParametrics } from './parametrics.js';
-import { itemPlacementNotice } from './placement-notice.js';
-import { ItemNode } from './schema.js';
-// The two floor gizmos flank the item at mid-height so they never overlap,
-// even on small items: move sits past the left edge, rotate past the right
-// edge, both floated the same distance in front of the item. Mirrors the
-// wall-item layout below (WALL_SIDE_OFFSET / WALL_GIZMO_LIFT). The guide ring
-// traces a circle slightly outside the footprint's bounding circle.
-const GIZMO_SIDE_OFFSET = 0.3;
-const GIZMO_FRONT_OFFSET = 0.3;
-const ROTATE_RING_OFFSET = 0.06;
-// Whole-item rotation handle — the two-headed curved arrow. `arc-resize`
-// does the angular drag math (raycasts a horizontal plane at the gizmo's
-// Y, measures cursor bearing around the item's local origin, returns the
-// delta). Rotation snaps to 15° increments by default; holding Shift
-// bypasses that snap (handled generically in node-arrow-handles for any
-// `shape: 'rotate'`), matching the R/T rotate step for placed items. Item
-// rotation is stored as `[x, y, z]`; only the Y component turns.
-function itemRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        // Negate the cursor delta to match three.js Y-rotation handedness
-        // (positive Ry takes +X → −Z, while atan2(z, x) increases +X → +Z).
-        apply: (initial, delta) => {
-            const [rx, ry, rz] = initial.rotation ?? [0, 0, 0];
-            return { rotation: [rx, ry - delta, rz] };
-        },
-        placement: {
-            // Past the item's right edge at mid-height, floated in front. The
-            // registered item mesh carries position + rotation only (scale lives on
-            // an inner mesh), so the scaled footprint maps straight to world.
-            position: (n) => {
-                const [w, h, d] = getScaledDimensions(n);
-                return [w / 2 + GIZMO_SIDE_OFFSET, h / 2, d / 2 + GIZMO_FRONT_OFFSET];
-            },
-            // Fixed −45° tilt leans the curve toward the item's front face.
-            rotationY: () => -Math.PI / 4,
-        },
-        decoration: {
-            kind: 'ring',
-            radius: (n) => {
-                const [w, , d] = getScaledDimensions(n);
-                return Math.hypot(w / 2, d / 2) + ROTATE_RING_OFFSET;
-            },
-            y: (n) => getScaledDimensions(n)[1] / 2,
-        },
-    };
-}
-// The 4-way move cross, just past the item's left edge. Press-drag hands the
-// item to its placement coordinator (showing the bounding box, dimension labels
-// and grid-snap ticker) and commits on release — press-drag-release motion with
-// the full placement feedback.
-function itemMoveHandle() {
-    return {
-        kind: 'tap-action',
-        shape: 'move-cross',
-        cursor: 'move',
-        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
-        placement: {
-            // Past the item's left edge at mid-height, mirroring the rotate grip on
-            // the right so the two never overlap on small items.
-            position: (n) => {
-                const [w, h, d] = getScaledDimensions(n);
-                return [-(w / 2 + GIZMO_SIDE_OFFSET), h / 2, d / 2 + GIZMO_FRONT_OFFSET];
-            },
-        },
-    };
-}
-// ---- Wall-mounted items (attachTo 'wall' / 'wall-side') ----
-// These live in the wall's local frame: position is [along-wall, up, depth]
-// and the item faces along the wall normal (its local +Z). Both gizmos use
-// `portal: 'grandparent'` so they render in the wall frame like door / window
-// handles, and sit a little off the wall surface (+Z) so they're grabbable.
-// How far off the wall surface (along the normal) the wall gizmos float, and
-// how far to either side of the item they sit.
-const WALL_GIZMO_LIFT = 0.12;
-const WALL_SIDE_OFFSET = 0.3;
-// Spin the item flat against the wall — rotation about its local +Z (the wall
-// normal), written to rotation[2]. Sits just past the item's right edge.
-function itemWallRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        rotationPlane: 'node-normal',
-        portal: 'grandparent',
-        apply: (initial, delta) => {
-            const [rx, ry, rz] = initial.rotation ?? [0, 0, 0];
-            return { rotation: [rx, ry, rz + delta] };
-        },
-        placement: {
-            position: (n) => {
-                const [w] = getScaledDimensions(n);
-                return [w / 2 + WALL_SIDE_OFFSET, 0, WALL_GIZMO_LIFT];
-            },
-        },
-    };
-}
-// Move cross past the item's left edge on the wall face. Tap to hand the item
-// to its placement coordinator (`engageMove`) — same feedback as the floating
-// move button, and the coordinator handles the wall ↔ floor ↔ ceiling
-// transitions the generic translate drag couldn't. `plane: 'node-normal'`
-// stands the cross up against the wall face.
-function itemWallMoveHandle() {
-    return {
-        kind: 'tap-action',
-        shape: 'move-cross',
-        plane: 'node-normal',
-        portal: 'grandparent',
-        cursor: 'move',
-        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
-        placement: {
-            position: (n) => {
-                const [w] = getScaledDimensions(n);
-                return [-(w / 2 + WALL_SIDE_OFFSET), 0, WALL_GIZMO_LIFT];
-            },
-        },
-    };
-}
-/**
- * Item — Phase 5 batch kind. Catalog-backed, GLB-rendered, multi-host.
- *
- * Demonstrates the **custom `def.renderer` escape hatch** ("Opting out of a
- * generic path" in wiki/architecture/node-definitions.md): items use `useGLTF` from drei to
- * load CDN assets, plus a non-trivial interactive-widget layer inside
- * the rendered scene. Not expressible as a pure `def.geometry`. The
- * registry mounts the custom React renderer as-is.
- *
- * Capabilities:
- *  - **No `movable`**: item's move is bespoke `MoveItemContent` —
- *    handles attachTo transitions mid-drag (floor ↔ wall ↔ ceiling),
- *    asset.attachTo lookups, scale-preserving Y math for surface
- *    placement. The smooth generic mover can't express that. Legacy
- *    mover keeps running via capability-driven dispatch.
- *  - `selectable`, `duplicable`, `deletable` standard.
- *
- * Stages:
- *  - A: registered.
- *  - B: N/A — def.renderer escape hatch (GLB / useGLTF).
- *  - C: `def.floorplan` resolves parent chain via `ctx.resolve`,
- *    returns a rotated rectangle (width × depth). Mirrors the legacy
- *    `getItemFloorplanTransform` math. Legacy `floorplanItemEntries`
- *    short-circuits when item is registered.
- *
- * `toolHints`: matches the legacy ItemHelper UI (mouse / R / T / Shift /
- * Esc) — registry-driven placement panel.
- */
-export const itemDefinition = {
-    kind: 'item',
-    snapProfile: 'item',
-    facingIndicator: true,
-    schemaVersion: 2,
-    schema: ItemNode,
-    category: 'furnish',
-    surfaceRole: 'furnishing',
-    extensions: {
-        'pascal:editor/floorplan': {
-            contextualDimensions: buildItemContextualDimensions,
-            actionMenu: { actions: () => import('../shared/item-interaction-actions.js') },
-        },
-    },
-    // Defaults shape is cast: the schema requires a fully-typed `asset`
-    // field, but in practice items are always created from the catalog
-    // (the asset is supplied at placement time). `createNode` re-parses
-    // through the schema, so any missing zod defaults fill at runtime.
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        children: [],
-        position: [0, 0, 0],
-        rotation: [0, 0, 0],
-        scale: [1, 1, 1],
-        asset: {
-            id: 'placeholder',
-            category: 'misc',
-            name: 'Item',
-            thumbnail: '',
-            src: 'asset:placeholder',
-            dimensions: [1, 1, 1],
-            source: 'library',
-        },
-    }),
-    capabilities: {
-        reveal: { phase: 'furnishing', style: 'drop', height: 0.3 },
-        revealOnEdit: ['scale'],
-        batchable: itemBatchable,
-        selectable: { hitVolume: 'bbox' },
-        // Authored objects host ceiling items on their undersides; catalog items do not.
-        faceHost: authoredItemFaceHost,
-        surfaces: {
-            top: {
-                height: (node) => {
-                    const item = node;
-                    return (item.asset.surface?.height ?? item.asset.dimensions[1]) * item.scale[1];
-                },
-            },
-        },
-        duplicable: { subtree: 'with-children' },
-        deletable: true,
-        paint: itemPaint,
-        mechanism: itemMechanism,
-        // Items participate in compositions — e.g. "table-with-plants",
-        // "shelf-with-books-on-top" — so they're presettable in their own
-        // right (and as descendants of presettable parents). The GLB-kind
-        // catalog still exists alongside; preset-flavoured items become
-        // siblings of GLB items inside the unified `items` table.
-        //
-        // Items can be hosted on walls (assets with `attachTo: 'wall'`)
-        // via `wallId` + `wallT`, or on a roof-segment wall face via
-        // `roofSegmentId`. When a composition that includes a wall-hosted
-        // item is saved as a preset (a sconce, a hanging shelf, etc.), the
-        // host app strips these via `getHostRefFields(def)` so the
-        // descendant re-attaches against the new host geometry at
-        // placement time.
-        hostRefFields: ['wallId', 'wallT', 'roofSegmentId', 'roofFace', 'blockFaceId'],
-        // Floor items get lifted by slabs underneath via the generic
-        // `<FloorElevationSystem>`. Wall- / ceiling-attached items live in
-        // their parent's local frame and skip the lift via `applies`.
-        floorPlaced: {
-            footprint: (node) => {
-                const item = node;
-                return { dimensions: getScaledDimensions(item), rotation: item.rotation };
-            },
-            applies: (node) => !node.asset.attachTo,
-            collides: true,
-        },
-        // Recessed ceiling fixtures cut a hole in their host ceiling. The viewer's
-        // CeilingSystem queries this capability on each child of a ceiling so it
-        // never needs to branch on `node.type`.
-        ceilingCut: {
-            buildCeilingHole(rawNode) {
-                const node = rawNode;
-                if (!node.asset.recessed || node.asset.attachTo !== 'ceiling')
-                    return null;
-                // Inset slightly so the fixture's trim (widest part, sitting in the
-                // ceiling plane) overlaps the solid ceiling around the opening and hides
-                // the cut edge. Same constant the old ceiling-system used.
-                const INSET = 0.82;
-                const [width, , depth] = getScaledDimensions(node);
-                const halfW = (width / 2) * INSET;
-                const halfD = (depth / 2) * INSET;
-                const cx = node.position[0];
-                const cz = node.position[2];
-                const yaw = node.rotation?.[1] ?? 0;
-                const cos = Math.cos(yaw);
-                const sin = Math.sin(yaw);
-                // Rotate the (inset) footprint corners about Y and translate to the
-                // item's plan position. Y-rotation of (dx, dz): (dx·cos + dz·sin, −dx·sin + dz·cos).
-                return [
-                    [-halfW, -halfD],
-                    [halfW, -halfD],
-                    [halfW, halfD],
-                    [-halfW, halfD],
-                ].map(([dx, dz]) => [cx + dx * cos + dz * sin, cz - dx * sin + dz * cos]);
-            },
-        },
-    },
-    parametrics: itemParametrics,
-    // In-world rotate + move gizmos for selected items.
-    //  - Floor items: world-Y rotate + free floor-plane move cross.
-    //  - Wall items: wall-normal rotate (spin flat against the wall) + a move
-    //    cross constrained to the wall face. Both ride the wall frame.
-    //  - Ceiling items: no gizmos yet (move via the move tool).
-    handles: (node) => {
-        const attachTo = node.asset.attachTo;
-        if (attachTo === 'wall' || attachTo === 'wall-side') {
-            return [itemWallRotateHandle(), itemWallMoveHandle()];
-        }
-        if (attachTo)
-            return [];
-        return [itemRotateHandle(), itemMoveHandle()];
-    },
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./renderer.js').then(({ ItemPreview }) => ({ default: ItemPreview })),
-    system: {
-        module: () => import('./system.js'),
-        // Same priority as the legacy ItemSystem.
-        priority: 2,
-    },
-    // Catalog placement tool — mounted when `useEditor.tool === 'item'`.
-    // Wraps the same placement coordinator the move-tool uses (surface
-    // strategies for floor / wall / ceiling / item-surface). Replaces
-    // the legacy `editor/src/components/tools/item/item-tool.tsx`.
-    tool: () => import('./tool.js'),
-    // Stage D — 3D move-tool (registry-driven). Adopts the moving node
-    // and runs the placement coordinator with surface strategies for
-    // floor / wall / ceiling / item-surface, including attachTo
-    // *transitions* (drop a wall item on a ceiling and have it switch).
-    // Replaces the legacy `MoveItemContent` in editor's dispatcher; the
-    // `getRegistryAffordanceTool('item', 'move')` lookup picks this up.
-    affordanceTools: {
-        move: () => import('./move-tool.js'),
-    },
-    // Stage C: floor-plan polygon. ctx.resolve walks the parent chain
-    // (wall / nested item / level) to compute the world-space transform.
-    floorplan: buildItemFloorplan,
-    floorplanAffectedIds: (args) => {
-        const ids = [...restingFloorplanAffectedIds(args)];
-        for (const node of [args.node, getEffectiveCutterNode(args.node)]) {
-            if (node.type !== 'item')
-                continue;
-            for (const cutter of node.source?.manifest.cutters ?? []) {
-                const host = resolveCutterHost(node, cutter.host === 'mounted' ? 'cutout' : `cut:${cutter.host}`, args.nodes);
-                if (host)
-                    ids.push(host.id);
-            }
-        }
-        return ids;
-    },
-    // 2D move-on-floorplan handler. Branches on `asset.attachTo`:
-    // wall items snap to walls (like door / window), ceiling items
-    // snap to ceiling polygons, floor items snap to slabs. attachTo
-    // *transitions* (drop a wall item on a ceiling) remain canonical
-    // in the 3D path; 2D only re-anchors within the same family.
-    floorplanMoveTarget: itemFloorplanMoveTarget,
-    placementNotice: itemPlacementNotice,
-    keyboardActions: {
-        e: {
-            appliesTo: (node) => itemMechanism.has(node) || itemHasLights(node),
-            // Same as the action bar: mechanisms when the item has them, otherwise its light.
-            run: (node) => itemMechanism.has(node) ? toggleMechanism(itemMechanism, node) : toggleItemLights(node),
-        },
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Place item' },
-        { key: 'R / T', label: 'Rotate' },
-        { key: 'Shift', label: 'Cycle snapping mode' },
-        { key: 'Alt', label: 'Force place' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Item',
-        description: 'A catalog-backed item (furniture, fixtures, decorations).',
-        icon: { kind: 'url', src: '/icons/item.webp' },
-        paletteSection: 'furnish',
-        paletteOrder: 10,
-    },
-    mcp: {
-        description: 'A catalog-backed item with asset reference, transforms, and optional attachTo for wall/ceiling mounting.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { itemEditContribution } from './definition.edit.js';
+import { itemRenderDefinition } from './definition.render.js';
+export const itemDefinition = composeNodeDefinition(itemRenderDefinition, itemEditContribution);

package/dist/item/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { ItemNode } from './schema.js';
+export declare const itemRenderDefinition: NodeRenderDefinition<typeof ItemNode> & {
+    kind: 'item';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/item/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/item/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CA+HxF,CAAA"}

package/dist/item/definition.render.js

@@ -0,0 +1,128 @@
+import { getScaledDimensions } from '@pascal-app/core';
+import { itemMechanism } from '../shared/item-interactions.js';
+import { itemBatchable } from '../shared/node-batch/batchable.js';
+import { authoredItemFaceHost } from './authored-face-host.js';
+import { ItemNode } from './schema.js';
+export const itemRenderDefinition = {
+    kind: 'item',
+    schemaVersion: 2,
+    schema: ItemNode,
+    category: 'furnish',
+    surfaceRole: 'furnishing',
+    // Defaults shape is cast: the schema requires a fully-typed `asset`
+    // field, but in practice items are always created from the catalog
+    // (the asset is supplied at placement time). `createNode` re-parses
+    // through the schema, so any missing zod defaults fill at runtime.
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        children: [],
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        scale: [1, 1, 1],
+        asset: {
+            id: 'placeholder',
+            category: 'misc',
+            name: 'Item',
+            thumbnail: '',
+            src: 'asset:placeholder',
+            dimensions: [1, 1, 1],
+            source: 'library',
+        },
+    }),
+    capabilities: {
+        reveal: { phase: 'furnishing', style: 'drop', height: 0.3 },
+        revealOnEdit: ['scale'],
+        batchable: itemBatchable,
+        selectable: { hitVolume: 'bbox' },
+        // Authored objects host ceiling items on their undersides; catalog items do not.
+        faceHost: authoredItemFaceHost,
+        surfaces: {
+            top: {
+                height: (node) => {
+                    const item = node;
+                    return (item.asset.surface?.height ?? item.asset.dimensions[1]) * item.scale[1];
+                },
+            },
+        },
+        duplicable: { subtree: 'with-children' },
+        deletable: true,
+        mechanism: itemMechanism,
+        // Items participate in compositions — e.g. "table-with-plants",
+        // "shelf-with-books-on-top" — so they're presettable in their own
+        // right (and as descendants of presettable parents). The GLB-kind
+        // catalog still exists alongside; preset-flavoured items become
+        // siblings of GLB items inside the unified `items` table.
+        //
+        // Items can be hosted on walls (assets with `attachTo: 'wall'`)
+        // via `wallId` + `wallT`, or on a roof-segment wall face via
+        // `roofSegmentId`. When a composition that includes a wall-hosted
+        // item is saved as a preset (a sconce, a hanging shelf, etc.), the
+        // host app strips these via `getHostRefFields(def)` so the
+        // descendant re-attaches against the new host geometry at
+        // placement time.
+        hostRefFields: ['wallId', 'wallT', 'roofSegmentId', 'roofFace', 'blockFaceId'],
+        // Floor items get lifted by slabs underneath via the generic
+        // `<FloorElevationSystem>`. Wall- / ceiling-attached items live in
+        // their parent's local frame and skip the lift via `applies`.
+        floorPlaced: {
+            footprint: (node) => {
+                const item = node;
+                return { dimensions: getScaledDimensions(item), rotation: item.rotation };
+            },
+            applies: (node) => !node.asset.attachTo,
+            collides: true,
+        },
+        // Recessed ceiling fixtures cut a hole in their host ceiling. The viewer's
+        // CeilingSystem queries this capability on each child of a ceiling so it
+        // never needs to branch on `node.type`.
+        ceilingCut: {
+            buildCeilingHole(rawNode) {
+                const node = rawNode;
+                if (!node.asset.recessed || node.asset.attachTo !== 'ceiling')
+                    return null;
+                // Inset slightly so the fixture's trim (widest part, sitting in the
+                // ceiling plane) overlaps the solid ceiling around the opening and hides
+                // the cut edge. Same constant the old ceiling-system used.
+                const INSET = 0.82;
+                const [width, , depth] = getScaledDimensions(node);
+                const halfW = (width / 2) * INSET;
+                const halfD = (depth / 2) * INSET;
+                const cx = node.position[0];
+                const cz = node.position[2];
+                const yaw = node.rotation?.[1] ?? 0;
+                const cos = Math.cos(yaw);
+                const sin = Math.sin(yaw);
+                // Rotate the (inset) footprint corners about Y and translate to the
+                // item's plan position. Y-rotation of (dx, dz): (dx·cos + dz·sin, −dx·sin + dz·cos).
+                return [
+                    [-halfW, -halfD],
+                    [halfW, -halfD],
+                    [halfW, halfD],
+                    [-halfW, halfD],
+                ].map(([dx, dz]) => [cx + dx * cos + dz * sin, cz - dx * sin + dz * cos]);
+            },
+        },
+    },
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        // Same priority as the legacy ItemSystem.
+        priority: 2,
+    },
+    presentation: {
+        label: 'Item',
+        description: 'A catalog-backed item (furniture, fixtures, decorations).',
+        icon: { kind: 'url', src: '/icons/item.webp' },
+        paletteSection: 'furnish',
+        paletteOrder: 10,
+    },
+    mcp: {
+        description: 'A catalog-backed item with asset reference, transforms, and optional attachTo for wall/ceiling mounting.',
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/item/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAOpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AASzB;;;;;;;;;;;;;;GAcG;AACH,KAAK,SAAS,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AA2D3D,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,EACpB,KAAK,sxCAAyC,GAC7C,SAAS,GAAG,IAAI,CAyKlB;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA+HjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/item/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAGtB,KAAK,eAAe,EAOpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAKzB;;;;;;;;;;;;;;GAcG;AACH,KAAK,SAAS,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AA2D3D,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,EACpB,KAAK,sxCAAyC,GAC7C,SAAS,GAAG,IAAI,CAyKlB;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA+HjG"}

package/dist/item/floorplan.js

@@ -1,5 +1,5 @@
-import { getBlockFaceFrame, getEffectiveNode, getRoofWallFaceFrame, getScaledDimensions, getWallBodyCenterOffset, getWallLocalFaceZ, roofFacePointToSegment, scriptImages, useLiveTransforms, } from '@pascal-app/core';
-import { formatLinearMeasurement, readFloorplanContext, readFloorplanMetricNotationOverride, } from '@pascal-app/editor';
+import { formatLinearMeasurement, getBlockFaceFrame, getEffectiveNode, getRoofWallFaceFrame, getScaledDimensions, getWallBodyCenterOffset, getWallLocalFaceZ, roofFacePointToSegment, scriptImages, useLiveTransforms, } from '@pascal-app/core';
+import { readFloorplanContext, readFloorplanMetricNotationOverride } from '@pascal-app/editor';
 import { restingNodePlanFrame } from '../shared/resting-surface-plan.js';
 import { buildPlanItemSymbol, classifyPlanItem, PLAN_SYMBOL_METADATA_KEY } from './plan-symbols.js';
 // Plan-space rotation convention used by the legacy `rotatePlanVector`

package/dist/item/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/item/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,QAAQ,EAad,MAAM,kBAAkB,CAAA;AA2azB,eAAO,MAAM,YAAY,wBAAyB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAmEnE,CAAA;AA+CD,eAAO,MAAM,WAAW,aAAc;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAUvD,CAAA;AA6VD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,0BAGvB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACrC,gCAA+F,CAAA;eAEjF,YAAY"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/item/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,QAAQ,EAad,MAAM,kBAAkB,CAAA;AA4azB,eAAO,MAAM,YAAY,wBAAyB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAmEnE,CAAA;AA+CD,eAAO,MAAM,WAAW,aAAc;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAUvD,CAAA;AA6VD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,0BAGvB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACrC,gCAA+F,CAAA;eAEjF,YAAY"}

package/dist/item/renderer.js

@@ -1,7 +1,7 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { deriveSlotId, getScaledDimensions, isCutterName, isSlotMaterialName, itemClipRegistry, LIBRARY_MATERIAL_REF_PREFIX, SCENE_MATERIAL_REF_PREFIX, sceneRegistry, toLibraryMaterialRef, useInteractive, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { catalogLightSource, configureKtx2Support, createDefaultMaterial, createSurfaceRoleMaterial, ErrorBoundary, glassMaterial, materialCastsShadow, NodeRenderer, resolveCdnUrl, resolveMaterialRef, ScriptedClips, stampPascalTextureRef, useClipActions, useItemLightPool, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { catalogLightSource, configureKtx2Support, createDefaultMaterial, createSurfaceRoleMaterial, ErrorBoundary, getViewerConfig, glassMaterial, materialCastsShadow, NodeRenderer, resolveCdnUrl, resolveMaterialRef, ScriptedClips, stampPascalTextureRef, useClipActions, useItemLightPool, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useAnimations } from '@react-three/drei';
 import { Clone } from '@react-three/drei/core/Clone';
 import { useFrame, useLoader, useThree } from '@react-three/fiber';
@@ -114,8 +114,8 @@ const configureItemModelLoader = (loader, renderer) => {
     configureKtx2Support(loader, renderer);
     if (!itemDracoLoader) {
         itemDracoLoader = new DRACOLoader(loader.manager);
-        itemDracoLoader.setDecoderPath('https://www.gstatic.com/draco/versioned/decoders/1.5.5/');
     }
+    itemDracoLoader.setDecoderPath(getViewerConfig().decoders.dracoPath);
     loader.setDRACOLoader(itemDracoLoader);
 };
 const ITEM_TEXTURE_SLOTS = [