@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/item/renderer.js

@@ -1,18 +1,18 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { deriveSlotId, getScaledDimensions, isSlotMaterialName, itemClipRegistry, LIBRARY_MATERIAL_REF_PREFIX, SCENE_MATERIAL_REF_PREFIX, sceneRegistry, toLibraryMaterialRef, useInteractive, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { configureKtx2Support, createDefaultMaterial, createSurfaceRoleMaterial, ErrorBoundary, glassMaterial, NodeRenderer, resolveCdnUrl, resolveMaterialRef, stampPascalTextureRef, useItemLightPool, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+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';
 import { Clone } from '@react-three/drei/core/Clone';
 import { useFrame, useLoader, useThree } from '@react-three/fiber';
 import { Suspense, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
 import { MathUtils, Texture } from 'three';
-import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
 import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
 import { positionLocal, smoothstep, time } from 'three/tsl';
-import { BlockFaceHostFrame } from '../shared/block-face-host';
-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;
@@ -57,7 +57,7 @@ const captureItemMeshMaterials = (mesh) => {
     return next;
 };
 const isCapturedMaterialArray = (captured) => Array.isArray(captured.authoredMaterials);
-const isGlassMaterial = (material) => material === glassMaterial || material.name.toLowerCase() === 'glass';
+const isLegacyGlassMaterial = (material) => material === glassMaterial || material.name.toLowerCase() === 'glass';
 const clampGeometryGroups = (mesh, matCount) => {
     if (mesh.geometry.groups.length === 0)
         return;
@@ -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)
@@ -91,7 +90,7 @@ const resolveItemMaterial = (authoredMaterial, slotId, curatedRef, { colorPreset
     // slot-authored ones (no more strip-to-clay default).
     return authoredMaterial;
 };
-const BrokenItemFallback = ({ node }) => {
+const BrokenItemFallback = ({ node, events = true }) => {
     const handlers = useNodeEvents(node, 'item');
     const shading = useViewer((s) => s.shading);
     const isExporting = useViewer((s) => s.isExporting);
@@ -108,7 +107,7 @@ const BrokenItemFallback = ({ node }) => {
     // (observed baked into a prod artifact when an item GLB 504'd mid-capture).
     if (isExporting)
         return null;
-    return (_jsxs("mesh", { "position-y": h / 2, ...handlers, children: [_jsx("boxGeometry", { args: [w, h, d] }), _jsx("primitive", { attach: "material", object: material })] }));
+    return (_jsxs("mesh", { "position-y": h / 2, ...(events ? handlers : {}), children: [_jsx("boxGeometry", { args: [w, h, d] }), _jsx("primitive", { attach: "material", object: material })] }));
 };
 let itemDracoLoader = null;
 const configureItemModelLoader = (loader, renderer) => {
@@ -118,7 +117,6 @@ const configureItemModelLoader = (loader, renderer) => {
         itemDracoLoader.setDecoderPath('https://www.gstatic.com/draco/versioned/decoders/1.5.5/');
     }
     loader.setDRACOLoader(itemDracoLoader);
-    loader.setMeshoptDecoder(MeshoptDecoder);
 };
 const ITEM_TEXTURE_SLOTS = [
     'map',
@@ -223,7 +221,7 @@ const releaseUnavailableConsumer = (entries, key, onLastRelease) => {
         onLastRelease();
     }, 0);
 };
-const UnavailableItemModel = ({ markSettled, node, url, }) => {
+const UnavailableItemModel = ({ markSettled, node, url, events, }) => {
     useEffect(() => {
         retainUnavailableConsumer(unavailableFailureConsumers, node.id);
         if (url)
@@ -240,14 +238,14 @@ const UnavailableItemModel = ({ markSettled, node, url, }) => {
             }
         };
     }, [markSettled, node.id, url]);
-    return _jsx(BrokenItemFallback, { node: node });
+    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, }) => {
+const ModelWithRetry = ({ node, setSettled, events = true, }) => {
     const [renderFailed, setRenderFailed] = useState(false);
     const url = resolveCdnUrl(node.asset.src) || '';
     const markSettled = useCallback(() => setSettled(true), [setSettled]);
@@ -263,8 +261,8 @@ const ModelWithRetry = ({ node, setSettled, }) => {
         return () => useViewer.getState().clearItemLoadFailure(node.id);
     }, [markSettled, node.id, renderFailed, url]);
     if (!url)
-        return _jsx(UnavailableItemModel, { markSettled: markSettled, node: node, url: url });
-    return (_jsx(ErrorBoundary, { fallback: _jsx(BrokenItemFallback, { node: node }), onError: () => setRenderFailed(true), scope: "item-model", children: _jsx(Suspense, { fallback: _jsx(PreviewModel, { node: node }), children: _jsx(ModelRenderer, { markSettled: markSettled, node: node }) }) }));
+        return _jsx(UnavailableItemModel, { events: events, markSettled: markSettled, node: node, url: url });
+    return (_jsx(ErrorBoundary, { fallback: _jsx(BrokenItemFallback, { events: events, node: node }), onError: () => setRenderFailed(true), scope: "item-model", children: _jsx(Suspense, { fallback: _jsx(PreviewModel, { node: node }), children: _jsx(ModelRenderer, { events: events, markSettled: markSettled, node: node }) }) }));
 };
 export const ItemRenderer = ({ node: storeNode }) => {
     const ref = useRef(null);
@@ -354,15 +352,15 @@ const ClearPreviewModel = ({ node }) => {
     }, [shading]);
     return (_jsx("mesh", { material: material, "position-y": h / 2, children: _jsx("boxGeometry", { args: [w, h, d] }) }));
 };
-const ModelRenderer = ({ node, markSettled }) => {
+const ModelRenderer = ({ node, markSettled, events, }) => {
     const gltf = useItemGltf(resolveCdnUrl(node.asset.src) || '');
     const unavailable = getUnavailableItemAsset(gltf);
     if (unavailable) {
-        return _jsx(UnavailableItemModel, { markSettled: markSettled, node: node, url: unavailable.url });
+        return (_jsx(UnavailableItemModel, { events: events, markSettled: markSettled, node: node, url: unavailable.url }));
     }
-    return _jsx(LoadedModelRenderer, { gltf: gltf, markSettled: markSettled, node: node });
+    return _jsx(LoadedModelRenderer, { events: events, gltf: gltf, markSettled: markSettled, node: node });
 };
-const LoadedModelRenderer = ({ gltf: { scene, nodes, animations }, node, markSettled, }) => {
+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).
@@ -373,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);
@@ -406,11 +409,13 @@ const LoadedModelRenderer = ({ gltf: { scene, nodes, animations }, node, markSet
             if (!child.isMesh)
                 return;
             const mesh = child;
-            if (mesh.name === 'cutout') {
+            // `cutout` drives wall openings, `collider` the walkthrough; neither renders.
+            const name = typeof mesh.userData.name === 'string' ? mesh.userData.name : mesh.name;
+            const helper = isCutterName(name) || name === 'collider';
+            if (helper)
                 child.visible = false;
-            }
             const captured = captureItemMeshMaterials(mesh);
-            if (mesh.name !== 'cutout')
+            if (!helper)
                 meshEntries.push({ mesh, captured });
         });
         const materialOptions = {
@@ -421,43 +426,52 @@ const LoadedModelRenderer = ({ gltf: { scene, nodes, animations }, node, markSet
             textures,
         };
         for (const { mesh, captured } of meshEntries) {
-            let hasGlass = false;
+            let hasLegacyGlass = false;
             if (isCapturedMaterialArray(captured)) {
                 const nextMaterials = captured.authoredMaterials.map((authoredMaterial, index) => resolveItemMaterial(authoredMaterial, captured.slotIds[index] ?? null, captured.curatedRefs[index], materialOptions));
                 mesh.material = nextMaterials;
-                hasGlass = nextMaterials.some(isGlassMaterial);
+                hasLegacyGlass = nextMaterials.some(isLegacyGlassMaterial);
                 clampGeometryGroups(mesh, nextMaterials.length);
             }
             else {
                 const nextMaterial = resolveItemMaterial(captured.authoredMaterials, captured.slotIds, captured.curatedRefs, materialOptions);
                 mesh.material = nextMaterial;
-                hasGlass = isGlassMaterial(nextMaterial);
+                hasLegacyGlass = isLegacyGlassMaterial(nextMaterial);
             }
-            mesh.castShadow = !hasGlass;
-            mesh.receiveShadow = !hasGlass;
+            mesh.castShadow = materialCastsShadow(mesh.material);
+            mesh.receiveShadow = !hasLegacyGlass;
         }
     }, [shading, textures, colorPreset, node.slots, sceneMaterials]);
     const interactive = interactiveRef.current;
     const animEffect = interactive?.effects.find((e) => e.kind === 'animation') ?? null;
     const lightEffects = interactive?.effects.filter((e) => e.kind === 'light') ?? [];
-    // Expose this item's ambient clip (e.g. a fan's spin) to the GLB bake. The
-    // catalog GLB owns the clip; it isn't in the scene graph, so the export can't
-    // find it without this registry. The bake retargets it onto the baked subtree.
+    // Expose this item's clips to the GLB bake: the GLB owns them and they are
+    // not in the scene graph, so the export can't find them without this
+    // registry. A catalog item bakes its ambient clip (a fan's spin); an
+    // authored object bakes every clip, its opening played once.
+    const scripted = Boolean(node.source);
     useEffect(() => {
-        if (!animEffect)
+        const entries = scripted
+            ? animations.map((clip) => ({
+                clip,
+                loop: clip.name !== 'open' && clip.name !== 'close',
+                name: clip.name,
+            }))
+            : (() => {
+                const clipName = animEffect ? (animEffect.clips.on ?? animEffect.clips.loop) : undefined;
+                const clip = clipName ? animations.find((c) => c.name === clipName) : undefined;
+                return clip ? [{ clip, loop: true, name: 'loop' }] : [];
+            })();
+        if (entries.length === 0)
             return;
-        const clipName = animEffect.clips.on ?? animEffect.clips.loop;
-        const clip = clipName ? animations.find((c) => c.name === clipName) : undefined;
-        if (!clip)
-            return;
-        itemClipRegistry.set(node.id, { clip, loop: true });
+        itemClipRegistry.set(node.id, entries);
         return () => {
             itemClipRegistry.delete(node.id);
         };
-    }, [node.id, animEffect, animations]);
+    }, [node.id, animEffect, animations, scripted]);
     // useGLTF caches scenes, and Clone shares child geometry/material references.
     // Undo can unmount one item while another clone of the same asset still needs them.
-    return (_jsxs(_Fragment, { children: [_jsx("group", { scale: node.scale, children: _jsx(Clone, { dispose: null, object: scene, position: node.asset.offset, ref: ref, rotation: node.asset.rotation, scale: node.asset.scale || [1, 1, 1], ...handlers }) }), animations.length > 0 && (_jsx(ItemAnimation, { animations: animations, animEffect: animEffect, interactive: interactive ?? null, nodeId: node.id, rootRef: ref })), lightEffects.map((effect, i) => (_jsx(ItemLightRegistrar, { effect: effect, index: i, interactive: interactive, nodeId: node.id }, i)))] }));
+    return (_jsxs(_Fragment, { children: [_jsx("group", { scale: node.scale, children: _jsx(Clone, { dispose: null, object: scene, position: node.asset.offset, ref: ref, rotation: node.asset.rotation, scale: node.asset.scale || [1, 1, 1], ...(events ? handlers : {}) }) }), animations.length > 0 && scripted && interactive && (_jsx(ScriptedAnimations, { animations: animations, interactive: interactive, nodeId: node.id, rootRef: ref })), animations.length > 0 && !scripted && (_jsx(ItemAnimation, { animations: animations, animEffect: animEffect, interactive: interactive ?? null, nodeId: node.id, rootRef: ref })), lightEffects.map((effect, i) => (_jsx(ItemLightRegistrar, { effect: effect, index: i, interactive: interactive, nodeId: node.id, canRegister: canRegisterItemLight(node.metadata), localScale: scripted ? node.scale : undefined }, i)))] }));
 };
 const ItemAnimation = ({ nodeId, animEffect, interactive, animations, rootRef, }) => {
     const { actions } = useAnimations(animations, rootRef);
@@ -518,12 +532,28 @@ const ItemAnimation = ({ nodeId, animEffect, interactive, animations, rootRef, }
     });
     return null;
 };
-const ItemLightRegistrar = ({ nodeId, effect, interactive, index, }) => {
+/** An authored object's clips, played through the shared `ScriptedClips`. */
+const ScriptedAnimations = ({ nodeId, interactive, animations, rootRef, }) => {
+    const actions = useClipActions(animations, rootRef);
+    return _jsx(ScriptedClips, { actions: actions, interactive: interactive, nodeId: nodeId });
+};
+const ItemLightRegistrar = ({ nodeId, effect, interactive, index, canRegister, localScale, }) => {
     useEffect(() => {
+        if (!canRegister)
+            return;
         const key = `${nodeId}:${index}`;
-        useItemLightPool.getState().register(key, nodeId, effect, interactive);
+        useItemLightPool
+            .getState()
+            .register(catalogLightSource(key, nodeId, effect, interactive, localScale));
         return () => useItemLightPool.getState().unregister(key);
-    }, [nodeId, index, effect, interactive]);
+    }, [nodeId, index, effect, interactive, canRegister, localScale]);
     return null;
 };
+/**
+ * An artifact rendered through the item's model path (GLB, paint slots,
+ * clips, lights, load settling) for a node that is not an item: a window or
+ * door built from a script. `view` is that node seen as an item; the host
+ * node keeps its own registry entry and pointer events.
+ */
+export const ScriptedModel = ({ view, setSettled, }) => _jsx(ModelWithRetry, { events: false, node: view, setSettled: setSettled }, view.asset.src);
 export default ItemRenderer;

package/dist/item/script-param-defaults.d.ts

@@ -0,0 +1,12 @@
+import type { GeometryScriptParamSpec, GeometryScriptParamValue } from '@pascal-app/core';
+/**
+ * The value a param takes when the object is built without one: the script's
+ * declared default, clamped to its range as the compile does, so a default
+ * declared outside its own range still compares equal after a reset.
+ */
+export declare function scriptDefault(spec: GeometryScriptParamSpec): GeometryScriptParamValue;
+/** Whether `value` is what the script gives the param by default (a missing value is). */
+export declare function isScriptDefault(spec: GeometryScriptParamSpec, value: GeometryScriptParamValue | undefined): boolean;
+/** The edit that puts every param changed from its script default back to it. */
+export declare function scriptDefaultsPatch(specs: GeometryScriptParamSpec[], params: Record<string, GeometryScriptParamValue>): Record<string, GeometryScriptParamValue>;
+//# sourceMappingURL=script-param-defaults.d.ts.map

package/dist/item/script-param-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-param-defaults.d.ts","sourceRoot":"","sources":["../../src/item/script-param-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAA;AAEzF;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,uBAAuB,GAAG,wBAAwB,CAMrF;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,CAC7B,IAAI,EAAE,uBAAuB,EAC7B,KAAK,EAAE,wBAAwB,GAAG,SAAS,GAC1C,OAAO,CAOT;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,uBAAuB,EAAE,EAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,GAC/C,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAM1C"}

package/dist/item/script-param-defaults.js

@@ -0,0 +1,34 @@
+/**
+ * The value a param takes when the object is built without one: the script's
+ * declared default, clamped to its range as the compile does, so a default
+ * declared outside its own range still compares equal after a reset.
+ */
+export function scriptDefault(spec) {
+    let value = spec.default;
+    if (typeof value !== 'number')
+        return value;
+    if (spec.min !== undefined)
+        value = Math.max(spec.min, value);
+    if (spec.max !== undefined)
+        value = Math.min(spec.max, value);
+    return value;
+}
+/** Whether `value` is what the script gives the param by default (a missing value is). */
+export function isScriptDefault(spec, value) {
+    if (value === undefined)
+        return true;
+    const fallback = scriptDefault(spec);
+    if (typeof value === 'number' && typeof fallback === 'number') {
+        return Math.abs(value - fallback) < 1e-9;
+    }
+    return value === fallback;
+}
+/** The edit that puts every param changed from its script default back to it. */
+export function scriptDefaultsPatch(specs, params) {
+    const patch = {};
+    for (const spec of specs) {
+        if (!isScriptDefault(spec, params[spec.id]))
+            patch[spec.id] = scriptDefault(spec);
+    }
+    return patch;
+}

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),
+    });
+}