@pascal-app/nodes 1.0.4 → 1.0.5

package/dist/item/model-loader.js

@@ -1,10 +1,13 @@
+import { preserveGltfUnlit } from '@pascal-app/viewer';
 import { DefaultLoadingManager, Group, LoadingManager } from 'three';
 import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
 const ITEM_ASSET_UNAVAILABLE_KEY = 'pascalItemAssetUnavailable';
+const ITEM_RESOURCE_FAILURES_KEY = 'pascalItemResourceFailures';
 const DEFAULT_RETRY_DELAYS_MS = [1_000, 3_000];
 const itemLoadGenerations = new Map();
 const pendingItemModelLoads = new WeakMap();
+const malformedItemJsonErrors = new WeakSet();
 /** Active item transactions on this host manager, including their retry waits. */
 export function getPendingItemModelLoadCount(manager = DefaultLoadingManager) {
     return pendingItemModelLoads.get(manager) ?? 0;
@@ -12,6 +15,8 @@ export function getPendingItemModelLoadCount(manager = DefaultLoadingManager) {
 export function classifyItemModelLoadFailure(error) {
     if (!(error instanceof Error))
         return 'unexpected';
+    if (malformedItemJsonErrors.has(error))
+        return 'unavailable';
     const status = error.response?.status;
     if (status === 408 ||
         status === 425 ||
@@ -51,20 +56,56 @@ export function getUnavailableItemAsset(gltf) {
         ? { url: candidate.url, message: candidate.message }
         : null;
 }
+/** GLTFLoader can resolve a model after a referenced texture failed. */
+export function getItemResourceFailures(gltf) {
+    const failures = gltf.userData?.[ITEM_RESOURCE_FAILURES_KEY];
+    return Array.isArray(failures)
+        ? failures.filter((url) => typeof url === 'string')
+        : [];
+}
 export function cancelItemModelLoad(url) {
     itemLoadGenerations.set(url, (itemLoadGenerations.get(url) ?? 0) + 1);
 }
 export class ItemGLTFLoader extends GLTFLoader {
     hostManager;
     retryDelaysMs;
+    resourceFailureVersion = 0;
+    resourceFailures = new Map();
     constructor(manager, retryDelaysMs = DEFAULT_RETRY_DELAYS_MS) {
         super(new LoadingManager());
+        this.register(preserveGltfUnlit);
+        this.manager.onError = (url) => {
+            this.resourceFailures.set(url, ++this.resourceFailureVersion);
+        };
         this.setMeshoptDecoder(MeshoptDecoder);
         this.hostManager = manager ?? DefaultLoadingManager;
         this.retryDelaysMs = retryDelaysMs;
     }
+    parse(data, path, onLoad, onError) {
+        try {
+            super.parse(data, path, onLoad, onError);
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                const text = typeof data === 'string' ? data : new TextDecoder().decode(data);
+                // Confirm invalid asset JSON, rather than classifying a plugin's or
+                // consumer's SyntaxError as unavailable. Leave native GLB parsing alone.
+                if (typeof data === 'string' || !text.startsWith('glTF')) {
+                    try {
+                        JSON.parse(text);
+                    }
+                    catch (parseError) {
+                        if (parseError instanceof SyntaxError)
+                            malformedItemJsonErrors.add(error);
+                    }
+                }
+            }
+            throw error;
+        }
+    }
     load(url, onLoad, onProgress, onError) {
         const generation = itemLoadGenerations.get(url) ?? 0;
+        const resourceVersion = this.resourceFailureVersion;
         let retryCount = 0;
         let finished = false;
         const wasCancelled = () => (itemLoadGenerations.get(url) ?? 0) !== generation;
@@ -87,6 +128,14 @@ export class ItemGLTFLoader extends GLTFLoader {
             }
             finished = true;
             try {
+                // Keep the live model's existing fallback behavior; only make known
+                // missing resources observable to capture readiness. Concurrent loads
+                // on this manager are deliberately conservative.
+                const failures = [...this.resourceFailures]
+                    .filter(([failedUrl, version]) => failedUrl !== url && version > resourceVersion)
+                    .map(([failedUrl]) => failedUrl);
+                if (failures.length)
+                    gltf.userData[ITEM_RESOURCE_FAILURES_KEY] = failures;
                 onLoad(gltf);
             }
             finally {

package/dist/item/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/item/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,cAAc,EAKpB,MAAM,oBAAoB,CAAA;AAI3B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,MAAM,GAAE,OAAO,GAAG,SAEL,GACZ,cAAc,CAiFhB;AAED,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,+BAkEhE;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/item/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,cAAc,EAKpB,MAAM,oBAAoB,CAAA;AAI3B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,MAAM,GAAE,OAAO,GAAG,SAEL,GACZ,cAAc,CAiFhB;AAED,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,+BAkEhE;eAEc,YAAY"}

package/dist/item/paint.js

@@ -1,6 +1,6 @@
 import { generateSceneMaterialId, parseMaterialRef, slotPaintMaterial, toSceneMaterialRef, useScene, } from '@pascal-app/core';
 import { createMaterial, createMaterialFromPresetRef, useViewer } from '@pascal-app/viewer';
-import { swapPreviewMaterial } from '../shared/swap-preview-material';
+import { swapPreviewMaterial } from '../shared/swap-preview-material.js';
 function deepEqual(a, b) {
     if (Object.is(a, b))
         return true;

package/dist/item/panel.js

@@ -1,11 +1,11 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { getScaledDimensions, scriptImages, useScene, } from '@pascal-app/core';
 import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SliderControl, triggerSFX, useEditor, usePlacementNotice, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Link, Link2Off, Move, Trash2 } from 'lucide-react';
 import { useCallback, useRef, useState } from 'react';
-import { AuthoredParams } from './authored-params';
+import { AuthoredParams } from './authored-params.js';
 /**
  * Stage E inspector for item. 1:1 port of the legacy
  * `editor/components/ui/panels/item-panel.tsx`, relocated into the
@@ -66,7 +66,7 @@ export default function ItemPanel() {
     }, [selectedId, deleteNode, setSelection]);
     if (!(node && node.type === 'item' && selectedId))
         return null;
-    return (_jsxs(PanelWrapper, { icon: scriptImages(node)?.thumbnail ?? (node.asset.thumbnail || '/icons/item.webp'), onClose: handleClose, title: node.name || node.asset.name, width: 300, children: [fitWarning && (_jsxs("div", { className: "mx-1 mb-1 flex gap-2 rounded-lg bg-amber-400/10 px-3 py-2 text-xs", children: [_jsx("span", { className: "font-semibold text-amber-400", children: "!" }), _jsxs("div", { className: "flex flex-col gap-0.5", children: [_jsx("span", { className: "font-medium text-foreground", children: fitWarning.line }), fitWarning.detail && (_jsx("span", { className: "text-muted-foreground", children: fitWarning.detail }))] })] })), _jsx(AuthoredParams, { node: node }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["X", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[0] + 2, min: node.position[0] - 2, onChange: (value) => handleUpdate({ position: [value, node.position[1], node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[0] }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[1] + 2, min: node.position[1] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], value, node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[1] }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Z", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[2] + 2, min: node.position[2] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], node.position[1], value] }), precision: 2, step: 0.01, unit: "m", value: node.position[2] })] }), _jsxs(PanelSection, { title: "Rotation", children: [_jsx(TiltSlider, { axis: 0, label: "X", node: node, onUpdate: handleUpdate }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "rot" })] }), max: Math.round((node.rotation[1] * 180) / Math.PI) + 45, min: Math.round((node.rotation[1] * 180) / Math.PI) - 45, onChange: (degrees) => {
+    return (_jsxs(PanelWrapper, { icon: scriptImages(node)?.thumbnail ?? (node.asset.thumbnail || '/icons/item.webp'), onClose: handleClose, title: node.name || node.asset.name, width: 300, children: [fitWarning && (_jsxs("div", { className: "mx-1 mb-1 flex gap-2 rounded-lg bg-amber-400/10 px-3 py-2 text-xs", children: [_jsx("span", { className: "font-semibold text-amber-700 dark:text-amber-400", children: "!" }), _jsxs("div", { className: "flex flex-col gap-0.5", children: [_jsx("span", { className: "font-medium text-foreground", children: fitWarning.line }), fitWarning.detail && (_jsx("span", { className: "text-muted-foreground", children: fitWarning.detail }))] })] })), _jsx(AuthoredParams, { node: node }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["X", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[0] + 2, min: node.position[0] - 2, onChange: (value) => handleUpdate({ position: [value, node.position[1], node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[0] }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[1] + 2, min: node.position[1] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], value, node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[1] }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Z", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[2] + 2, min: node.position[2] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], node.position[1], value] }), precision: 2, step: 0.01, unit: "m", value: node.position[2] })] }), _jsxs(PanelSection, { title: "Rotation", children: [_jsx(TiltSlider, { axis: 0, label: "X", node: node, onUpdate: handleUpdate }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "rot" })] }), max: Math.round((node.rotation[1] * 180) / Math.PI) + 45, min: Math.round((node.rotation[1] * 180) / Math.PI) - 45, onChange: (degrees) => {
                             const radians = (degrees * Math.PI) / 180;
                             handleUpdate({ rotation: [node.rotation[0], radians, node.rotation[2]] });
                         }, precision: 0, step: 1, unit: "\u00B0", value: Math.round((node.rotation[1] * 180) / Math.PI) }), _jsx(TiltSlider, { axis: 2, label: "Z", node: node, onUpdate: handleUpdate }), _jsxs("div", { className: "flex gap-1.5 px-1 pt-2 pb-1", children: [_jsx(ActionButton, { label: "-45\u00B0", onClick: () => {
@@ -80,14 +80,14 @@ export default function ItemPanel() {
                                     const radians = ((currentDegrees + 45) * Math.PI) / 180;
                                     handleUpdate({ rotation: [node.rotation[0], radians, node.rotation[2]] });
                                 } })] })] }), _jsxs(PanelSection, { title: "Scale", children: [_jsxs("div", { className: "flex items-center justify-between px-2 pb-2", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Uniform Scale" }), _jsx("button", { className: uniformScale
-                                    ? 'flex h-6 w-6 items-center justify-center rounded-md bg-[#3e3e3e] text-muted-foreground transition-colors hover:text-foreground'
-                                    : 'flex h-6 w-6 items-center justify-center rounded-md bg-[#2C2C2E] text-muted-foreground transition-colors hover:bg-[#3e3e3e] hover:text-foreground', onClick: () => setUniformScale((v) => !v), type: "button", children: uniformScale ? _jsx(Link, { className: "h-3.5 w-3.5" }) : _jsx(Link2Off, { className: "h-3.5 w-3.5" }) })] }), uniformScale ? (_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["XYZ", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "scale" })] }), max: 10, min: 0.01, onChange: (value) => {
+                                    ? 'flex h-6 w-6 items-center justify-center rounded-md bg-black/8 dark:bg-[#3e3e3e] text-muted-foreground transition-colors hover:text-foreground'
+                                    : 'flex h-6 w-6 items-center justify-center rounded-md bg-black/4 dark:bg-[#2C2C2E] text-muted-foreground transition-colors hover:bg-black/8 dark:hover:bg-[#3e3e3e] hover:text-foreground', onClick: () => setUniformScale((v) => !v), type: "button", children: uniformScale ? _jsx(Link, { className: "h-3.5 w-3.5" }) : _jsx(Link2Off, { className: "h-3.5 w-3.5" }) })] }), uniformScale ? (_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["XYZ", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "scale" })] }), max: 10, min: 0.01, onChange: (value) => {
                             const v = Math.max(0.01, value);
                             handleUpdate({ scale: [v, v, v] });
                         }, precision: 2, step: 0.1, value: Math.round(node.scale[0] * 100) / 100 })) : (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["X", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "scale" })] }), max: 10, min: 0.01, onChange: (value) => handleUpdate({ scale: [Math.max(0.01, value), node.scale[1], node.scale[2]] }), precision: 2, step: 0.1, value: Math.round(node.scale[0] * 100) / 100 }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "scale" })] }), max: 10, min: 0.01, onChange: (value) => handleUpdate({ scale: [node.scale[0], Math.max(0.01, value), node.scale[2]] }), precision: 2, step: 0.1, value: Math.round(node.scale[1] * 100) / 100 }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Z", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "scale" })] }), max: 10, min: 0.01, onChange: (value) => handleUpdate({ scale: [node.scale[0], node.scale[1], Math.max(0.01, value)] }), precision: 2, step: 0.1, value: Math.round(node.scale[2] * 100) / 100 })] }))] }), _jsx(PanelSection, { title: "Info", children: _jsxs("div", { className: "flex items-center justify-between px-2 py-1 text-muted-foreground text-sm", children: [_jsx("span", { children: "Dimensions" }), (() => {
                             const [w, h, d] = getScaledDimensions(node);
-                            return (_jsxs("span", { className: "font-mono text-white", children: [Math.round(w * 100) / 100, "\u00D7", Math.round(h * 100) / 100, "\u00D7", Math.round(d * 100) / 100] }));
-                        })()] }) }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
+                            return (_jsxs("span", { className: "font-mono text-foreground dark:text-white", children: [Math.round(w * 100) / 100, "\u00D7", Math.round(h * 100) / 100, "\u00D7", Math.round(d * 100) / 100] }));
+                        })()] }) }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-600 dark:text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
 }
 /** Tilt about X or Z: aiming a spotlight, leaning a frame. Y stays the main turn above. */
 function TiltSlider({ axis, label, node, onUpdate, }) {

package/dist/item/parametrics.d.ts

@@ -1,5 +1,5 @@
 import type { ParametricDescriptor } from '@pascal-app/core';
-import type { ItemNode } from './schema';
+import type { ItemNode } from './schema.js';
 /**
  * Inspector descriptor for item. The fields shape (position / rotation /
  * scale sliders, catalog popover, move / duplicate / delete actions)

package/dist/item/parametrics.js

@@ -8,5 +8,5 @@
  */
 export const itemParametrics = {
     groups: [],
-    customPanel: () => import('./panel'),
+    customPanel: () => import('./panel.js'),
 };

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;AAsazB,eAAO,MAAM,YAAY,GAAI,qBAAqB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAmEnE,CAAA;AA+CD,eAAO,MAAM,WAAW,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAUvD,CAAA;AAyVD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,uBAG3B;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACrC,gCAA+F,CAAA;AAEhG,eAAe,YAAY,CAAA"}
+{"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"}

package/dist/item/renderer.js

@@ -1,5 +1,5 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+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 { useAnimations } from '@react-three/drei';
@@ -9,10 +9,10 @@ import { Suspense, useCallback, useEffect, useLayoutEffect, useMemo, useRef, use
 import { MathUtils, Texture } from 'three';
 import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
 import { positionLocal, smoothstep, time } from 'three/tsl';
-import { BlockFaceHostFrame } from '../shared/block-face-host';
-import { canRegisterItemLight } from '../shared/item-light-placement';
-import { RoofFaceHostFrame } from '../shared/roof-face-host';
-import { cancelItemModelLoad, getUnavailableItemAsset, ItemGLTFLoader } from './model-loader';
+import { BlockFaceHostFrame } from '../shared/block-face-host.js';
+import { canRegisterItemLight } from '../shared/item-light-placement.js';
+import { RoofFaceHostFrame } from '../shared/roof-face-host.js';
+import { cancelItemModelLoad, getItemResourceFailures, getUnavailableItemAsset, ItemGLTFLoader, } from './model-loader.js';
 const getAuthoredSlotId = (material) => isSlotMaterialName(material.name) ? deriveSlotId(material.name) : null;
 function curatedRefFromMaterial(material) {
     const raw = material.userData.pascal_material;
@@ -75,8 +75,7 @@ const resolveItemMaterial = (authoredMaterial, slotId, curatedRef, { colorPreset
     // Monochrome (textures off): collapse to the themed furnishing clay colour.
     if (!textures)
         return createSurfaceRoleMaterial('furnishing', colorPreset);
-    if (authoredMaterial.name.toLowerCase() === 'glass')
-        return glassMaterial;
+    // Authored material names do not opt an asset into a Pascal preset.
     if (slotId != null) {
         const override = resolveMaterialRef(nodeSlots?.[slotId], sceneMaterials, shading);
         if (override)
@@ -242,9 +241,9 @@ const UnavailableItemModel = ({ markSettled, node, url, events, }) => {
     return _jsx(BrokenItemFallback, { events: events, node: node });
 };
 /**
- * Expected network failures resolve through ItemGLTFLoader as an unavailable
- * scene so they never become React render errors. Parse and renderer failures
- * still reach this boundary and remain visible to developers.
+ * Expected network and malformed nonbinary JSON failures resolve through
+ * ItemGLTFLoader as an unavailable scene so they never become React render
+ * errors. Other parser and renderer failures still reach this boundary.
  */
 const ModelWithRetry = ({ node, setSettled, events = true, }) => {
     const [renderFailed, setRenderFailed] = useState(false);
@@ -361,7 +360,7 @@ const ModelRenderer = ({ node, markSettled, events, }) => {
     }
     return _jsx(LoadedModelRenderer, { events: events, gltf: gltf, markSettled: markSettled, node: node });
 };
-const LoadedModelRenderer = ({ gltf: { scene, nodes, animations }, node, markSettled, events, }) => {
+const LoadedModelRenderer = ({ gltf: { scene, nodes, animations, userData }, node, markSettled, events, }) => {
     const ref = useRef(null);
     // Mounting past the suspense gate means the GLB resolved — the item's build
     // work is done (`ItemSystem` may clear its dirty mark, scene-ready may fire).
@@ -372,8 +371,13 @@ const LoadedModelRenderer = ({ gltf: { scene, nodes, animations }, node, markSet
         const group = sceneRegistry.nodes.get(node.id);
         if (group)
             group.userData.itemHasAnimations = animations.length > 0;
+        const failedResources = getItemResourceFailures({ userData });
+        if (failedResources.length)
+            useViewer.getState().reportItemLoadFailure(node.id, failedResources[0]);
         markSettled();
-    }, [markSettled, node.id, animations]);
+        if (failedResources.length)
+            return () => useViewer.getState().clearItemLoadFailure(node.id);
+    }, [markSettled, node.id, animations, userData]);
     const shading = useViewer((s) => s.shading);
     const textures = useViewer((s) => s.textures);
     const colorPreset = useViewer((s) => s.colorPreset);

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/item/system.tsx"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,WAAW,mCAQhB,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/item/system.tsx"],"names":[],"mappings":"AAOA;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,WAAW,mCAYhB,CAAA;eAEc,WAAW"}

package/dist/item/system.js

@@ -1,7 +1,9 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { ItemLightSystem, ItemSystem } from '@pascal-app/viewer';
-import { NodeBatchSystem } from '../shared/node-batch/system';
+import { useEffect } from 'react';
+import { NodeBatchSystem } from '../shared/node-batch/system.js';
+import { registerWallObjectSceneCheck } from './wall-object-observations.js';
 /**
  * Registry-driven item system bundle.
  *
@@ -16,6 +18,9 @@ import { NodeBatchSystem } from '../shared/node-batch/system';
  *    every registered kind's system mounts scene-wide.
  */
 const ItemSystems = () => {
+    useEffect(() => {
+        registerWallObjectSceneCheck();
+    }, []);
     return (_jsxs(_Fragment, { children: [_jsx(ItemSystem, {}), _jsx(ItemLightSystem, {}), _jsx(NodeBatchSystem, {})] }));
 };
 export default ItemSystems;

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/item/tool.tsx"],"names":[],"mappings":"AA4CA,iBAAS,QAAQ,uCAIhB;AAED,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/item/tool.tsx"],"names":[],"mappings":"AAkDA,iBAAS,QAAQ,uCAIhB;eAEc,QAAQ"}

package/dist/item/tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { triggerSFX, useDraftNode, useEditor, usePlacementCoordinator } from '@pascal-app/editor';
+import { cameraFacingYaw, triggerSFX, useDraftNode, useEditor, usePlacementCoordinator, } from '@pascal-app/editor';
 /**
  * Registry-driven item placement tool. Mounted by `ToolManager` when
  * `useEditor.tool === 'item'` (the catalog picker is what selects which
@@ -25,9 +25,9 @@ function ItemPlacementContent({ selectedItem }) {
             // Only floor items get a draft on mount; wall / ceiling items are
             // created lazily by the placement coordinator when the cursor
             // enters a surface (so the draft doesn't appear at world origin
-            // before the first move event).
+            // before the first move event). A new floor item starts facing the view.
             if (selectedItem && !selectedItem.attachTo) {
-                draftNode.create(gridPosition, selectedItem);
+                draftNode.create(gridPosition, selectedItem, [0, cameraFacingYaw(), 0]);
             }
         },
         onCommitted: () => {

package/dist/item/wall-object-observations.d.ts

@@ -0,0 +1,6 @@
+import { type AnyNode } from '@pascal-app/core';
+import { type WallObjectObservation } from '@pascal-app/core/agent-operations';
+/** Actual settled mesh evidence, in each direct straight host wall's local frame. */
+export declare function wallObjectRenderedObservations(nodes: Readonly<Record<string, AnyNode>>): WallObjectObservation[];
+export declare function registerWallObjectSceneCheck(): void;
+//# sourceMappingURL=wall-object-observations.d.ts.map

package/dist/item/wall-object-observations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-object-observations.d.ts","sourceRoot":"","sources":["../../src/item/wall-object-observations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAQb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,qBAAqB,EAE3B,MAAM,mCAAmC,CAAA;AA2N1C,qFAAqF;AACrF,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,qBAAqB,EAAE,CA4EzB;AAED,wBAAgB,4BAA4B,IAAI,IAAI,CAMnD"}

package/dist/item/wall-object-observations.js

@@ -0,0 +1,260 @@
+import { isCutterName, itemClipRegistry, sceneRegistry, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { registerSceneCheck, wallObjectObservations, } from '@pascal-app/core/agent-operations';
+import { BATCHED_LAYER, SCENE_LAYER, useViewer } from '@pascal-app/viewer';
+import { BackSide, DoubleSide, Matrix4, Vector3, } from 'three';
+const MAX_ITEM_TRIANGLES = 20_000;
+const MAX_SCENE_TRIANGLES = 100_000;
+const MAX_ITEM_OBJECTS = 2_000;
+function helper(object) {
+    const name = typeof object.userData.name === 'string' ? object.userData.name : object.name;
+    return (isCutterName(name) ||
+        name === 'collider' ||
+        isCutterName(object.name) ||
+        object.name === 'collider');
+}
+function visibleMaterial(material) {
+    return Boolean(material?.visible && material.opacity > 0);
+}
+function deformedMaterial(material) {
+    const shader = material;
+    return Boolean(shader.isShaderMaterial ||
+        shader.positionNode ||
+        (shader.displacementMap && shader.displacementScale !== 0) ||
+        shader.wireframe);
+}
+/** Read current transforms without updating the live hierarchy's matrices. */
+function worldMatrix(object, matrices) {
+    const cached = matrices.get(object);
+    if (cached)
+        return cached;
+    const matrix = !object.matrixWorldAutoUpdate
+        ? object.matrixWorld.clone()
+        : object.matrixAutoUpdate
+            ? new Matrix4().compose(object.position, object.quaternion, object.scale)
+            : object.matrix.clone();
+    if (object.matrixWorldAutoUpdate && object.parent)
+        matrix.premultiply(worldMatrix(object.parent, matrices));
+    matrices.set(object, matrix);
+    return matrix;
+}
+function visibleBranch(object) {
+    for (let ancestor = object; ancestor; ancestor = ancestor.parent)
+        if (!ancestor.visible)
+            return false;
+    return true;
+}
+function belongsToHost(object, host) {
+    for (let parent = object.parent; parent; parent = parent.parent)
+        if (parent === host)
+            return true;
+    return false;
+}
+function geometryInWall(root, inverseHost, registeredRoots, matrices, budget) {
+    const result = { corners: [], faces: [] };
+    let triangles = 0;
+    let objects = 0;
+    let unsupported = false;
+    const a = new Vector3();
+    const b = new Vector3();
+    const c = new Vector3();
+    const ab = new Vector3();
+    const ac = new Vector3();
+    const normal = new Vector3();
+    const visit = (object) => {
+        if (unsupported || !object.visible || helper(object))
+            return;
+        // Hosted nodes have their own geometry/placement; never attribute it to their owner.
+        if (object !== root && registeredRoots.has(object))
+            return;
+        if (++objects > MAX_ITEM_OBJECTS) {
+            unsupported = true;
+            return;
+        }
+        if (object.animations.length > 0) {
+            unsupported = true;
+            return;
+        }
+        const mesh = object;
+        // Wall-attached items currently draw themselves (item batches require a level parent).
+        // If that changes, a hidden packed source cannot establish the batch's current pose.
+        if (mesh.isMesh && mesh.layers.isEnabled(BATCHED_LAYER)) {
+            unsupported = true;
+            return;
+        }
+        if (mesh.isMesh && mesh.layers.isEnabled(SCENE_LAYER)) {
+            const geometry = mesh.geometry;
+            const position = geometry?.getAttribute('position');
+            const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+            if (materials.some(visibleMaterial)) {
+                if (mesh.isSkinnedMesh ||
+                    mesh.isInstancedMesh ||
+                    mesh.isBatchedMesh ||
+                    !position ||
+                    position.itemSize < 3 ||
+                    Object.values(geometry.morphAttributes).some((attributes) => attributes.length > 0) ||
+                    materials.some((material) => visibleMaterial(material) && deformedMaterial(material))) {
+                    unsupported = true;
+                    return;
+                }
+                const transform = new Matrix4().multiplyMatrices(inverseHost, worldMatrix(mesh, matrices));
+                const determinant = transform.determinant();
+                if (!Number.isFinite(determinant) || determinant === 0) {
+                    unsupported = true;
+                    return;
+                }
+                const index = geometry.index;
+                const count = index?.count ?? position.count;
+                const drawStart = Math.max(0, geometry.drawRange.start);
+                const drawEnd = Math.min(count, drawStart + geometry.drawRange.count);
+                const groups = Array.isArray(mesh.material)
+                    ? geometry.groups
+                    : [{ start: 0, count, materialIndex: 0 }];
+                const seenVertices = new Set();
+                for (const group of groups) {
+                    const material = materials[group.materialIndex ?? 0];
+                    if (!visibleMaterial(material))
+                        continue;
+                    const start = Math.max(drawStart, group.start);
+                    const end = Math.min(drawEnd, group.start + group.count);
+                    const groupTriangles = Math.floor((end - start) / 3);
+                    if (groupTriangles <= 0)
+                        continue;
+                    triangles += groupTriangles;
+                    budget.triangles += groupTriangles;
+                    if (triangles > MAX_ITEM_TRIANGLES || budget.triangles > MAX_SCENE_TRIANGLES) {
+                        unsupported = true;
+                        return;
+                    }
+                    for (let offset = start; offset + 2 < end; offset += 3) {
+                        const indices = [0, 1, 2].map((i) => (index ? index.getX(offset + i) : offset + i));
+                        if (indices.some((i) => !Number.isInteger(i) || i < 0 || i >= position.count)) {
+                            unsupported = true;
+                            return;
+                        }
+                        const vertices = [a, b, c];
+                        for (let i = 0; i < 3; i++) {
+                            const vertex = vertices[i];
+                            vertex.fromBufferAttribute(position, indices[i]).applyMatrix4(transform);
+                            if (![vertex.x, vertex.y, vertex.z].every(Number.isFinite)) {
+                                unsupported = true;
+                                return;
+                            }
+                        }
+                        normal.crossVectors(ab.subVectors(b, a), ac.subVectors(c, a));
+                        if (!Number.isFinite(normal.lengthSq())) {
+                            unsupported = true;
+                            return;
+                        }
+                        if (normal.lengthSq() <= 1e-20)
+                            continue;
+                        for (let i = 0; i < 3; i++) {
+                            const vertexIndex = indices[i];
+                            if (seenVertices.has(vertexIndex))
+                                continue;
+                            seenVertices.add(vertexIndex);
+                            result.corners.push(vertices[i].toArray());
+                        }
+                        normal.normalize();
+                        // A shallow tilt can span centimetres despite a wall-parallel-looking normal.
+                        if (Math.abs(normal.z) < 0.999 ||
+                            Math.max(a.z, b.z, c.z) - Math.min(a.z, b.z, c.z) > 1e-5)
+                            continue;
+                        // Three reverses front-face winding for mirrored meshes; BackSide then reverses
+                        // the rendered side again. DoubleSide represents both real sides of this triangle.
+                        if (determinant < 0)
+                            normal.negate();
+                        if (material.side === BackSide)
+                            normal.negate();
+                        const face = {
+                            normal: normal.toArray(),
+                            depth: (a.z + b.z + c.z) / 3,
+                            polygon: vertices.map((vertex) => [vertex.x, vertex.y]),
+                        };
+                        result.faces.push(face);
+                        if (material.side === DoubleSide)
+                            result.faces.push({
+                                ...face,
+                                normal: [-normal.x, -normal.y, -normal.z],
+                            });
+                    }
+                }
+            }
+        }
+        for (const child of object.children)
+            visit(child);
+    };
+    visit(root);
+    // Partial bounds from an oversized/deformed item are not evidence of its complete body.
+    return unsupported || result.corners.length === 0 ? null : result;
+}
+/** Actual settled mesh evidence, in each direct straight host wall's local frame. */
+export function wallObjectRenderedObservations(nodes) {
+    const current = useScene.getState();
+    const overrides = useLiveNodeOverrides.getState();
+    const transforms = useLiveTransforms.getState();
+    const failures = useViewer.getState().itemLoadFailures;
+    const registeredRoots = new Set(sceneRegistry.nodes.values());
+    const matrices = new Map();
+    const rendered = {};
+    const budget = { triangles: 0 };
+    for (const item of Object.values(nodes)) {
+        if (budget.triangles > MAX_SCENE_TRIANGLES)
+            break;
+        if (item.type !== 'item' ||
+            item.visible === false ||
+            item.roomClearPreview === true ||
+            (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side') ||
+            current.nodes[item.id] !== item ||
+            failures[item.id] ||
+            itemClipRegistry.has(item.id) ||
+            item.asset.interactive?.effects.some((effect) => effect.kind === 'animation'))
+            continue;
+        const host = item.parentId ? nodes[item.parentId] : undefined;
+        if (host?.type !== 'wall' ||
+            host.visible === false ||
+            host.curveOffset ||
+            current.nodes[host.id] !== host)
+            continue;
+        if (overrides.get(item.id) ||
+            overrides.get(host.id) ||
+            transforms.get(item.id) ||
+            transforms.get(host.id) ||
+            current.dirtyNodes.has(item.id) ||
+            current.dirtyNodes.has(host.id))
+            continue;
+        const root = sceneRegistry.nodes.get(item.id);
+        const hostRoot = sceneRegistry.nodes.get(host.id);
+        if (!root ||
+            !hostRoot ||
+            root.userData.itemModelSettled !== true ||
+            root.userData.itemHasAnimations === true ||
+            !visibleBranch(root) ||
+            !belongsToHost(root, hostRoot))
+            continue;
+        const hostMatrix = worldMatrix(hostRoot, matrices);
+        const determinant = hostMatrix.determinant();
+        if (!Number.isFinite(determinant) || determinant === 0)
+            continue;
+        const geometry = geometryInWall(root, hostMatrix.clone().invert(), registeredRoots, matrices, budget);
+        if (geometry)
+            rendered[item.id] = geometry;
+    }
+    return wallObjectObservations(nodes, rendered).filter((observation) => {
+        if (!rendered[observation.itemId])
+            return false;
+        if (observation.type === 'item_wall_coplanar_face' ||
+            observation.type === 'item_wall_object_coplanar_face')
+            return true;
+        const item = nodes[observation.itemId];
+        return (item?.type === 'item' &&
+            !item.source &&
+            (observation.type === 'item_wall_body_overlap' || observation.type === 'item_through_wall'));
+    });
+}
+export function registerWallObjectSceneCheck() {
+    registerSceneCheck({
+        name: 'wall-object-rendered-faces',
+        order: 50,
+        run: (nodes) => wallObjectRenderedObservations(nodes),
+    });
+}

package/dist/lean-to-extension/assembly.d.ts

@@ -1,6 +1,6 @@
 import { type AnyNode, type ColumnNode as ColumnNodeType, type DownspoutNode as DownspoutNodeType, type GutterNode as GutterNodeType, type LeanToExtensionNode, type RoofNode as RoofNodeType, type RoofSegmentNode as RoofSegmentNodeType, type WallNode } from '@pascal-app/core';
-import { type FreestandingCanopyJoint } from './canopy-joint';
-import { type LeanToCornerJoint, type LeanToCornerSide } from './corner-joint';
+import { type FreestandingCanopyJoint } from './canopy-joint.js';
+import { type LeanToCornerJoint, type LeanToCornerSide } from './corner-joint.js';
 export declare const LEFT_CORNER_POST_INDEX = -1001;
 export declare const RIGHT_CORNER_POST_INDEX = -1002;
 export declare function leanToCornerPostIndex(side: LeanToCornerSide): number;

package/dist/lean-to-extension/assembly.js

@@ -1,12 +1,12 @@
 import { COLUMN_PRESETS, ColumnNode, DownspoutNode, GutterNode, generateId, getLevelElevations, getWallBaseElevationForNodes, heightAt, levelBaseElevationAt, RoofNode, RoofSegmentNode, spatialGridManager, terrainFieldOf, } from '@pascal-app/core';
-import { resolveEaveSnap } from '../gutter/eave-snap';
-import { isLeanToPostOmitted } from '../shared/lean-to-post-omissions';
-import { getRoofTopSurfaceY } from '../shared/roof-surface';
-import { bendLocalPoint, bendRotationYAtLocalX, isCurvedLeanTo } from './arc';
-import { canopyCornerJointMetadata, FREESTANDING_CANOPY_JOINTS_KEY, resolveCanopyGutterJointLayout, resolveCanopyRoofPlaneJointLayout, resolveFreestandingCanopyJoints, } from './canopy-joint';
-import { isClosedLoopLeanTo } from './conical-host';
-import { applyLeanToCornerRoofPieces, LEAN_TO_CORNER_JOINTS_KEY, leanToCornerJointMetadata, resolveLeanToCornerJoints, } from './corner-joint';
-import { isDualSlopeLeanToCanopy, leanToWallLocalPose, resolveLeanToLayout } from './layout';
+import { resolveEaveSnap } from '../gutter/eave-snap.js';
+import { isLeanToPostOmitted } from '../shared/lean-to-post-omissions.js';
+import { getRoofTopSurfaceY } from '../shared/roof-surface.js';
+import { bendLocalPoint, bendRotationYAtLocalX, isCurvedLeanTo } from './arc.js';
+import { canopyCornerJointMetadata, FREESTANDING_CANOPY_JOINTS_KEY, resolveCanopyGutterJointLayout, resolveCanopyRoofPlaneJointLayout, resolveFreestandingCanopyJoints, } from './canopy-joint.js';
+import { isClosedLoopLeanTo } from './conical-host.js';
+import { applyLeanToCornerRoofPieces, LEAN_TO_CORNER_JOINTS_KEY, leanToCornerJointMetadata, resolveLeanToCornerJoints, } from './corner-joint.js';
+import { isDualSlopeLeanToCanopy, leanToWallLocalPose, resolveLeanToLayout } from './layout.js';
 const MANAGED_BY_KEY = 'managedByLeanTo';
 const MANAGED_ROLE_KEY = 'leanToRole';
 const SELECTION_PROXY_KEY = 'nodeSelectionProxyId';

package/dist/lean-to-extension/canopy-joint.d.ts

@@ -1,5 +1,5 @@
 import { type AnyNode, type LeanToExtensionNode, type RoofSegmentTrim } from '@pascal-app/core';
-import type { LeanToCornerSide } from './corner-joint';
+import type { LeanToCornerSide } from './corner-joint.js';
 export declare const FREESTANDING_CANOPY_JOINTS_KEY = "leanToFreestandingCanopyJoints";
 export type CanopySide = 'positive' | 'negative';
 export type FreestandingCanopyJoint = {

package/dist/lean-to-extension/canopy-joint.js

@@ -1,5 +1,5 @@
 import { normalizeRoofSegmentTrim, } from '@pascal-app/core';
-import { resolveLeanToLayout } from './layout';
+import { resolveLeanToLayout } from './layout.js';
 const ENDPOINT_TOLERANCE = 0.05;
 const PROFILE_TOLERANCE = 1e-4;
 const DIRECTION_TOLERANCE = 1e-6;