From 78d42bc6556952bec2716fb23ceb85d2bc628b79 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Thu, 1 Oct 2026 21:00:20 +0300
Subject: [PATCH 1/3] [feat] 33 P2: animated, functional pack items
 (door/toggle/oneshot/loop), no autoplay

- behaviorCore.js (pure, vitest 18): normalizeBehavior, the pose as a pure function of
  {on, at, from, n} + the session clock, nextState, frameSlabs/passageThrough (the doorway
  cut out of a one-piece frame, through the wall's depth)
- packBehavior.js: per-frame pose driver (rest pose in Edit whatever the shared state),
  a core click handler in moduleSDK's one dispatch (desktop Interact click, Play tap, VR
  laser/poke), proximity (1.5 m) and knock (VR hand >= 0.6 m/s) triggers, the `behavior`
  wire message (latest-wins on sessionNow), a kinematic box per moving node that follows
  the swing while a sim runs + the frame as custom slab colliders, a local Animation-panel
  preview (never sent/saved), the per-item sound
- animatedImports: NOTHING AUTOPLAYS on placement any more (the first clip used to start
  and loop); behavior roots skip the transport; spec (+ live state on the wire, + the
  lod-editor's userData.lod) ride objectfile, the save snapshot and the undo entry
- fileHandler: animated imports land at the drop point; opts.behavior from the pack row
- packs/Explorer/explorerDrop: the row's spec travels to placement; an "animated" badge on
  cards and list rows
- gameSfx: + door gate slide lever lid; wireValidate `behavior` shape; ROOM_SCOPED;
  vrGameInput treats behavior roots as clickable; api.behavior {list, state, trigger}
- suites: pack-behavior (new; test-door.glb built with gltf-transform), animated-models and
  animation-persist press play first now, game-audio expects 25 sounds

WIP at the budget checkpoint: pack-behavior ran 41 pass / 8 fail before the priming fix in
this commit. 7.2 (the first walk resolved on the plane tier: charController's lazy physics
import; primed now, not re-run). 7.6 (the reopen click on the frame post did not toggle)
cascades into 8.2/9.1/11.2/13.1/13.2 - next window's first job. Counterfactuals already
green: 7.7 (uncut frame = a wall when open), 2.3/12.1 (no autoplay), 14.1 (slow hand).
svelte-check 333/47 (= base), vitest 396/396, check-storage clean.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/App.svelte                                |   7 +-
 src/components/Scene.svelte                   |   3 +
 src/components/editors/AnimationWindow.svelte |  18 +-
 src/components/editors/Explorer.svelte        |  46 +-
 src/lib/animatedImports.js                    | 128 +++-
 src/lib/behaviorCore.js                       | 263 ++++++++
 src/lib/explorerDrop.js                       |   5 +-
 src/lib/fileHandler.svelte.js                 |  22 +-
 src/lib/gameSfx.js                            |  42 +-
 src/lib/moduleSDK.js                          |  32 +
 src/lib/packBehavior.js                       | 600 ++++++++++++++++++
 src/lib/packs.js                              |   6 +-
 src/lib/peerHandler.svelte.js                 |   5 +
 src/lib/peerScenes.js                         |   2 +-
 src/lib/vrGameInput.js                        |   3 +-
 src/lib/wireValidate.js                       |   9 +
 tests/e2e/animated-models.test.cjs            |  13 +-
 tests/e2e/animation-persist.test.cjs          |  14 +-
 tests/e2e/fixtures/build-test-door.mjs        |  91 +++
 tests/e2e/fixtures/test-door.glb              | Bin 0 -> 5440 bytes
 tests/e2e/game-audio.test.cjs                 |   4 +-
 tests/e2e/pack-behavior.test.cjs              | 372 +++++++++++
 tests/unit/behaviorCore.test.js               | 141 ++++
 23 files changed, 1791 insertions(+), 35 deletions(-)
 create mode 100644 src/lib/behaviorCore.js
 create mode 100644 src/lib/packBehavior.js
 create mode 100644 tests/e2e/fixtures/build-test-door.mjs
 create mode 100644 tests/e2e/fixtures/test-door.glb
 create mode 100644 tests/e2e/pack-behavior.test.cjs
 create mode 100644 tests/unit/behaviorCore.test.js

diff --git a/src/App.svelte b/src/App.svelte
index 4d640087..ec2cbb33 100644
--- a/src/App.svelte
+++ b/src/App.svelte
@@ -494,9 +494,10 @@ import { startMusicToolbox } from './lib/musicToolbox'
 			import('./lib/moduleWorld'),
 			import('./lib/playSpawn'),
 			import('./lib/packRefs'),
-			import('./lib/lod')
-      ]).then(([sceneStore, appStore, flowStore, meshEdit, vrControls, autosave, voiceChat, audioEngineLib, musicClockLib, audioDevicesLib, audioPatchLib, vrPatchLib, musicToolboxLib, micCaptureLib, annotationsHandler, flowRuntime, history, materialsHandler, objectActions, commandsHandler, moduleSDK, drawModeLib, pathCapture, lockControl, prefabsLib, physics, jointsLib, possessLib, handModelsLib, terrainSculptLib, userModulesLib, environmentLib, sceneMusicLib, animatedImports, fileHandler, fileWindowsLib, sceneBounds, cameraClip, ping, sessionsLib, geometryEdit, lightParams, shadowDefaultsLib, paletteLib, viewModeLib, inputRuntimeLib, shortcutsLib, themesLib, vrRadialMenu, vrPaletteLib, vrWindowPosesLib, vrKeyboardLib, faceEditLib, meshToolParamsLib, avatarModelLib, explorerLib, bottomDock, explorerDrop, assetShare, soundRuntime, dungeonPlay, sceneAssetsLib, THREE, GLTFExporterModule, snappingLib, flowSocketsLib, networkQualityLib, packsLib, customNodesLib, nodesHandlerLib, nodeCatalogLib, objectMenuLib, animationPreviewLib, aiProvidersLib, aiToolsLib, aiAssistantLib, meshProvidersLib, meshJobsLib, flowGraphsLib, objectFlowLib, peerServerLib, cloudHooksLib, cloudPluginLib, connectionStateLib, peerApprovalLib, particleRuntimeLib, particleActionsLib, particlePresetsLib, versionLib, whatsNewLib, confirmDialogLib, scenePhysicsLib, playInteractLib, moveSmoothingLib, knockLib, playSettingsLib, colliderSpecLib, colliderHelpersLib, colliderEditLib, editSessionLib, trackpadNavLib, vrSleeveLib, gridSettingsLib, viewPrefsLib, cameraBookmarksLib, cameraObjectsLib, cameraHelpersLib, onionSkinLib, cameraPreviewLib, addObjectsLib, cameraPipLib, inputDeviceLib, sceneTemplatesLib, bvhPickingLib, multiTransformLib, objectOriginLib, moduleGalleryLib, uvEditorLib, uvUnwrapLib, meshTopologyLib, meshBudgetLib, proportionalLib, proportionalRingLib, scenePickLib, snapEngineLib, meshPivotLib, selectionPrefsLib, editOverlaysLib, objectPermissionsLib, scenePostLib, postEffectsLib, viewportOverridesLib, postprocessingModule, shaderBackendsLib, shaderGraphLib, shaderSyncLib, shaderTexturesLib, shaderCatalogLib, unitsLib, postBackendsLib, workspaceLib, editResumeLib, moduleRequirementsLib, hudDocsLib, hudSyncLib, idbLib, hudKindsLib, hudImagesLib, gameStateLib, gameSyncLib, hudActionsLib, moduleNodeIOLib, moduleToolboxesLib, splineTubeLib, splineToolLib, splineEditLib, terrainCarveLib, flattenActionsLib, hudViewportDragLib, gamepadPrefsLib, charControllerLib, hudRichTextLib, moduleHudKindsLib, hudMinimapLib, hudArrangeLib, gamePresenceLib, levelsLib, peerVarsLib, projectManifestLib, projectFileLib, transientObjectsLib, spawnerLib, triggerSyncLib, saveNameLib, sceneIdentityLib, importDuplicatesLib, peerScenesLib, sharedLibraryLib, transferLedgerLib, explorerViewLib, filePreviewLib, saveAsLib, windowTabsLib, colocationLib, colocationCalibrateLib, colocationPresenceLib, xrAnchorsLib, colocationAnchorsLib, colocationNudgeLib, mountedVolumesLib, storageUsageLib, scenePrivacyLib, touchControlsLib, playModeLib, objectListNavLib, inviteLinksLib, helperLayerLib, explorerClipboardLib, lookPresenceLib, postGraphsLib, postGraphPresetsLib, materialSharingLib, diagnosticsLib, wireValidateLib, wireErrorsLib, safeStorageLib, sceneBudgetLib, overloadGuardLib, qualityGovernorLib, importBudgetLib, importGateLib, decimateLib, playCursorLib, gameStorageLib, gameKitLib, moduleWorldLib, playSpawnLib, packRefsLib, lodLib]) => {
-        window.__stores = { ...sceneStore, ...appStore, ...flowStore, meshEdit, vrControls, autosave, voiceChat, audioEngine: audioEngineLib, musicClock: musicClockLib, audioDevices: audioDevicesLib, audioPatch: audioPatchLib, vrPatch: vrPatchLib, musicToolbox: musicToolboxLib, micCapture: micCaptureLib, annotationsHandler, flowRuntime, history, materialsHandler, objectActions, commandsHandler, moduleSDK, drawMode: drawModeLib, pathCapture, lockControl, prefabs: prefabsLib, physics, joints: jointsLib, possess: possessLib, handModels: handModelsLib, terrainSculpt: terrainSculptLib, userModules: userModulesLib, environment: environmentLib, sceneMusic: sceneMusicLib, animatedImports, fileHandler, fileWindows: fileWindowsLib, sceneBounds, cameraClip, ping, sessions: sessionsLib, geometryEdit, lightParams, shadowDefaults: shadowDefaultsLib, palette: paletteLib, viewModeCtl: viewModeLib, inputRuntime: inputRuntimeLib, shortcutsRegistry: shortcutsLib, themes: themesLib, vrRadialMenu, vrPalette: vrPaletteLib, vrWindowPoses: vrWindowPosesLib, vrKeyboard: vrKeyboardLib, faceEdit: faceEditLib, meshToolParams: meshToolParamsLib, avatarModel: avatarModelLib, explorer: explorerLib, bottomDock, explorerDrop, assetShare, soundRuntime, dungeonPlay, sceneAssets: sceneAssetsLib, THREE, GLTFExporterModule, snapping: snappingLib, flowSockets: flowSocketsLib, networkQuality: networkQualityLib, packs: packsLib, customNodes: customNodesLib, nodesHandler: nodesHandlerLib, nodeCatalog: nodeCatalogLib, objectMenu: objectMenuLib, animationPreview: animationPreviewLib, aiProviders: aiProvidersLib, aiTools: aiToolsLib, aiAssistant: aiAssistantLib, meshProviders: meshProvidersLib, meshJobs: meshJobsLib, flowGraphsCtl: flowGraphsLib, objectFlow: objectFlowLib, peerServer: peerServerLib, cloudHooks: cloudHooksLib, cloudPlugin: cloudPluginLib, connectionState: connectionStateLib, peerApproval: peerApprovalLib, particleRuntime: particleRuntimeLib, particleActions: particleActionsLib, particlePresets: particlePresetsLib, version: versionLib, whatsNew: whatsNewLib, confirmDialog: confirmDialogLib, scenePhysics: scenePhysicsLib, playInteract: playInteractLib, moveSmoothing: moveSmoothingLib, knock: knockLib, playSettings: playSettingsLib, colliderSpec: colliderSpecLib, colliderHelpers: colliderHelpersLib, colliderEdit: colliderEditLib, editSession: editSessionLib, trackpadNav: trackpadNavLib, vrSleeve: vrSleeveLib, gridSettings: gridSettingsLib, viewPrefs: viewPrefsLib, cameraBookmarks: cameraBookmarksLib, cameraObjects: cameraObjectsLib, cameraHelpers: cameraHelpersLib, onionSkin: onionSkinLib, cameraPreview: cameraPreviewLib, addObjects: addObjectsLib, cameraPip: cameraPipLib, inputDevice: inputDeviceLib, sceneTemplates: sceneTemplatesLib, bvhPicking: bvhPickingLib, multiTransform: multiTransformLib, objectOrigin: objectOriginLib, moduleGallery: moduleGalleryLib, uvEditor: uvEditorLib, uvUnwrap: uvUnwrapLib, meshTopology: meshTopologyLib, meshBudget: meshBudgetLib, proportional: proportionalLib, proportionalRing: proportionalRingLib, scenePick: scenePickLib, snapEngine: snapEngineLib, meshPivot: meshPivotLib, selectionPrefs: selectionPrefsLib, editOverlays: editOverlaysLib, objectPermissions: objectPermissionsLib, scenePost: scenePostLib, postEffects: postEffectsLib, viewportOverrides: viewportOverridesLib, postprocessing: postprocessingModule, shaderBackends: shaderBackendsLib, shaderGraph: shaderGraphLib, shaderSync: shaderSyncLib, shaderTextures: shaderTexturesLib, shaderCatalog: shaderCatalogLib, units: unitsLib, postBackends: postBackendsLib, workspace: workspaceLib, editResume: editResumeLib, moduleRequirements: moduleRequirementsLib, hudDocs: hudDocsLib, hudSync: hudSyncLib, idb: idbLib, hudKinds: hudKindsLib, hudImages: hudImagesLib, gameState: gameStateLib, gameSync: gameSyncLib, hudActions: hudActionsLib, moduleNodeIO: moduleNodeIOLib, moduleToolboxes: moduleToolboxesLib, splineTube: splineTubeLib, splineTool: splineToolLib, splineEdit: splineEditLib, terrainCarve: terrainCarveLib, flattenActions: flattenActionsLib, hudViewportDrag: hudViewportDragLib, gamepadPrefs: gamepadPrefsLib, charController: charControllerLib, hudRichText: hudRichTextLib, moduleHudKinds: moduleHudKindsLib, hudMinimap: hudMinimapLib, hudArrange: hudArrangeLib, gamePresence: gamePresenceLib, levels: levelsLib, peerVars: peerVarsLib, projectManifest: projectManifestLib, projectFile: projectFileLib, transientObjects: transientObjectsLib, spawner: spawnerLib, triggerSync: triggerSyncLib, saveName: saveNameLib, sceneIdentity: sceneIdentityLib, importDuplicates: importDuplicatesLib, peerScenes: peerScenesLib, sharedLibrary: sharedLibraryLib, transferLedger: transferLedgerLib, explorerView: explorerViewLib, filePreview: filePreviewLib, saveAs: saveAsLib, windowTabs: windowTabsLib, colocation: colocationLib, colocationCalibrate: colocationCalibrateLib, colocationPresence: colocationPresenceLib, xrAnchors: xrAnchorsLib, colocationAnchors: colocationAnchorsLib, colocationNudge: colocationNudgeLib, mountedVolumes: mountedVolumesLib, storageUsage: storageUsageLib, scenePrivacy: scenePrivacyLib, touchControls: touchControlsLib, playMode: playModeLib, objectListNav: objectListNavLib, inviteLinks: inviteLinksLib, helperLayer: helperLayerLib, explorerClipboard: explorerClipboardLib, lookPresence: lookPresenceLib, postGraphs: postGraphsLib, postGraphPresets: postGraphPresetsLib, materialSharing: materialSharingLib, diagnostics: diagnosticsLib, wireValidate: wireValidateLib, wireErrors: wireErrorsLib, safeStorage: safeStorageLib, sceneBudget: sceneBudgetLib, overloadGuard: overloadGuardLib, qualityGovernor: qualityGovernorLib, importBudget: importBudgetLib, importGate: importGateLib, decimate: decimateLib, playCursor: playCursorLib, gameStorage: gameStorageLib, gameKit: gameKitLib, moduleWorld: moduleWorldLib, playSpawn: playSpawnLib, packRefs: packRefsLib, lod: lodLib }
+			import('./lib/lod'),
+			import('./lib/packBehavior')
+      ]).then(([sceneStore, appStore, flowStore, meshEdit, vrControls, autosave, voiceChat, audioEngineLib, musicClockLib, audioDevicesLib, audioPatchLib, vrPatchLib, musicToolboxLib, micCaptureLib, annotationsHandler, flowRuntime, history, materialsHandler, objectActions, commandsHandler, moduleSDK, drawModeLib, pathCapture, lockControl, prefabsLib, physics, jointsLib, possessLib, handModelsLib, terrainSculptLib, userModulesLib, environmentLib, sceneMusicLib, animatedImports, fileHandler, fileWindowsLib, sceneBounds, cameraClip, ping, sessionsLib, geometryEdit, lightParams, shadowDefaultsLib, paletteLib, viewModeLib, inputRuntimeLib, shortcutsLib, themesLib, vrRadialMenu, vrPaletteLib, vrWindowPosesLib, vrKeyboardLib, faceEditLib, meshToolParamsLib, avatarModelLib, explorerLib, bottomDock, explorerDrop, assetShare, soundRuntime, dungeonPlay, sceneAssetsLib, THREE, GLTFExporterModule, snappingLib, flowSocketsLib, networkQualityLib, packsLib, customNodesLib, nodesHandlerLib, nodeCatalogLib, objectMenuLib, animationPreviewLib, aiProvidersLib, aiToolsLib, aiAssistantLib, meshProvidersLib, meshJobsLib, flowGraphsLib, objectFlowLib, peerServerLib, cloudHooksLib, cloudPluginLib, connectionStateLib, peerApprovalLib, particleRuntimeLib, particleActionsLib, particlePresetsLib, versionLib, whatsNewLib, confirmDialogLib, scenePhysicsLib, playInteractLib, moveSmoothingLib, knockLib, playSettingsLib, colliderSpecLib, colliderHelpersLib, colliderEditLib, editSessionLib, trackpadNavLib, vrSleeveLib, gridSettingsLib, viewPrefsLib, cameraBookmarksLib, cameraObjectsLib, cameraHelpersLib, onionSkinLib, cameraPreviewLib, addObjectsLib, cameraPipLib, inputDeviceLib, sceneTemplatesLib, bvhPickingLib, multiTransformLib, objectOriginLib, moduleGalleryLib, uvEditorLib, uvUnwrapLib, meshTopologyLib, meshBudgetLib, proportionalLib, proportionalRingLib, scenePickLib, snapEngineLib, meshPivotLib, selectionPrefsLib, editOverlaysLib, objectPermissionsLib, scenePostLib, postEffectsLib, viewportOverridesLib, postprocessingModule, shaderBackendsLib, shaderGraphLib, shaderSyncLib, shaderTexturesLib, shaderCatalogLib, unitsLib, postBackendsLib, workspaceLib, editResumeLib, moduleRequirementsLib, hudDocsLib, hudSyncLib, idbLib, hudKindsLib, hudImagesLib, gameStateLib, gameSyncLib, hudActionsLib, moduleNodeIOLib, moduleToolboxesLib, splineTubeLib, splineToolLib, splineEditLib, terrainCarveLib, flattenActionsLib, hudViewportDragLib, gamepadPrefsLib, charControllerLib, hudRichTextLib, moduleHudKindsLib, hudMinimapLib, hudArrangeLib, gamePresenceLib, levelsLib, peerVarsLib, projectManifestLib, projectFileLib, transientObjectsLib, spawnerLib, triggerSyncLib, saveNameLib, sceneIdentityLib, importDuplicatesLib, peerScenesLib, sharedLibraryLib, transferLedgerLib, explorerViewLib, filePreviewLib, saveAsLib, windowTabsLib, colocationLib, colocationCalibrateLib, colocationPresenceLib, xrAnchorsLib, colocationAnchorsLib, colocationNudgeLib, mountedVolumesLib, storageUsageLib, scenePrivacyLib, touchControlsLib, playModeLib, objectListNavLib, inviteLinksLib, helperLayerLib, explorerClipboardLib, lookPresenceLib, postGraphsLib, postGraphPresetsLib, materialSharingLib, diagnosticsLib, wireValidateLib, wireErrorsLib, safeStorageLib, sceneBudgetLib, overloadGuardLib, qualityGovernorLib, importBudgetLib, importGateLib, decimateLib, playCursorLib, gameStorageLib, gameKitLib, moduleWorldLib, playSpawnLib, packRefsLib, lodLib, packBehaviorLib]) => {
+        window.__stores = { ...sceneStore, ...appStore, ...flowStore, meshEdit, vrControls, autosave, voiceChat, audioEngine: audioEngineLib, musicClock: musicClockLib, audioDevices: audioDevicesLib, audioPatch: audioPatchLib, vrPatch: vrPatchLib, musicToolbox: musicToolboxLib, micCapture: micCaptureLib, annotationsHandler, flowRuntime, history, materialsHandler, objectActions, commandsHandler, moduleSDK, drawMode: drawModeLib, pathCapture, lockControl, prefabs: prefabsLib, physics, joints: jointsLib, possess: possessLib, handModels: handModelsLib, terrainSculpt: terrainSculptLib, userModules: userModulesLib, environment: environmentLib, sceneMusic: sceneMusicLib, animatedImports, fileHandler, fileWindows: fileWindowsLib, sceneBounds, cameraClip, ping, sessions: sessionsLib, geometryEdit, lightParams, shadowDefaults: shadowDefaultsLib, palette: paletteLib, viewModeCtl: viewModeLib, inputRuntime: inputRuntimeLib, shortcutsRegistry: shortcutsLib, themes: themesLib, vrRadialMenu, vrPalette: vrPaletteLib, vrWindowPoses: vrWindowPosesLib, vrKeyboard: vrKeyboardLib, faceEdit: faceEditLib, meshToolParams: meshToolParamsLib, avatarModel: avatarModelLib, explorer: explorerLib, bottomDock, explorerDrop, assetShare, soundRuntime, dungeonPlay, sceneAssets: sceneAssetsLib, THREE, GLTFExporterModule, snapping: snappingLib, flowSockets: flowSocketsLib, networkQuality: networkQualityLib, packs: packsLib, customNodes: customNodesLib, nodesHandler: nodesHandlerLib, nodeCatalog: nodeCatalogLib, objectMenu: objectMenuLib, animationPreview: animationPreviewLib, aiProviders: aiProvidersLib, aiTools: aiToolsLib, aiAssistant: aiAssistantLib, meshProviders: meshProvidersLib, meshJobs: meshJobsLib, flowGraphsCtl: flowGraphsLib, objectFlow: objectFlowLib, peerServer: peerServerLib, cloudHooks: cloudHooksLib, cloudPlugin: cloudPluginLib, connectionState: connectionStateLib, peerApproval: peerApprovalLib, particleRuntime: particleRuntimeLib, particleActions: particleActionsLib, particlePresets: particlePresetsLib, version: versionLib, whatsNew: whatsNewLib, confirmDialog: confirmDialogLib, scenePhysics: scenePhysicsLib, playInteract: playInteractLib, moveSmoothing: moveSmoothingLib, knock: knockLib, playSettings: playSettingsLib, colliderSpec: colliderSpecLib, colliderHelpers: colliderHelpersLib, colliderEdit: colliderEditLib, editSession: editSessionLib, trackpadNav: trackpadNavLib, vrSleeve: vrSleeveLib, gridSettings: gridSettingsLib, viewPrefs: viewPrefsLib, cameraBookmarks: cameraBookmarksLib, cameraObjects: cameraObjectsLib, cameraHelpers: cameraHelpersLib, onionSkin: onionSkinLib, cameraPreview: cameraPreviewLib, addObjects: addObjectsLib, cameraPip: cameraPipLib, inputDevice: inputDeviceLib, sceneTemplates: sceneTemplatesLib, bvhPicking: bvhPickingLib, multiTransform: multiTransformLib, objectOrigin: objectOriginLib, moduleGallery: moduleGalleryLib, uvEditor: uvEditorLib, uvUnwrap: uvUnwrapLib, meshTopology: meshTopologyLib, meshBudget: meshBudgetLib, proportional: proportionalLib, proportionalRing: proportionalRingLib, scenePick: scenePickLib, snapEngine: snapEngineLib, meshPivot: meshPivotLib, selectionPrefs: selectionPrefsLib, editOverlays: editOverlaysLib, objectPermissions: objectPermissionsLib, scenePost: scenePostLib, postEffects: postEffectsLib, viewportOverrides: viewportOverridesLib, postprocessing: postprocessingModule, shaderBackends: shaderBackendsLib, shaderGraph: shaderGraphLib, shaderSync: shaderSyncLib, shaderTextures: shaderTexturesLib, shaderCatalog: shaderCatalogLib, units: unitsLib, postBackends: postBackendsLib, workspace: workspaceLib, editResume: editResumeLib, moduleRequirements: moduleRequirementsLib, hudDocs: hudDocsLib, hudSync: hudSyncLib, idb: idbLib, hudKinds: hudKindsLib, hudImages: hudImagesLib, gameState: gameStateLib, gameSync: gameSyncLib, hudActions: hudActionsLib, moduleNodeIO: moduleNodeIOLib, moduleToolboxes: moduleToolboxesLib, splineTube: splineTubeLib, splineTool: splineToolLib, splineEdit: splineEditLib, terrainCarve: terrainCarveLib, flattenActions: flattenActionsLib, hudViewportDrag: hudViewportDragLib, gamepadPrefs: gamepadPrefsLib, charController: charControllerLib, hudRichText: hudRichTextLib, moduleHudKinds: moduleHudKindsLib, hudMinimap: hudMinimapLib, hudArrange: hudArrangeLib, gamePresence: gamePresenceLib, levels: levelsLib, peerVars: peerVarsLib, projectManifest: projectManifestLib, projectFile: projectFileLib, transientObjects: transientObjectsLib, spawner: spawnerLib, triggerSync: triggerSyncLib, saveName: saveNameLib, sceneIdentity: sceneIdentityLib, importDuplicates: importDuplicatesLib, peerScenes: peerScenesLib, sharedLibrary: sharedLibraryLib, transferLedger: transferLedgerLib, explorerView: explorerViewLib, filePreview: filePreviewLib, saveAs: saveAsLib, windowTabs: windowTabsLib, colocation: colocationLib, colocationCalibrate: colocationCalibrateLib, colocationPresence: colocationPresenceLib, xrAnchors: xrAnchorsLib, colocationAnchors: colocationAnchorsLib, colocationNudge: colocationNudgeLib, mountedVolumes: mountedVolumesLib, storageUsage: storageUsageLib, scenePrivacy: scenePrivacyLib, touchControls: touchControlsLib, playMode: playModeLib, objectListNav: objectListNavLib, inviteLinks: inviteLinksLib, helperLayer: helperLayerLib, explorerClipboard: explorerClipboardLib, lookPresence: lookPresenceLib, postGraphs: postGraphsLib, postGraphPresets: postGraphPresetsLib, materialSharing: materialSharingLib, diagnostics: diagnosticsLib, wireValidate: wireValidateLib, wireErrors: wireErrorsLib, safeStorage: safeStorageLib, sceneBudget: sceneBudgetLib, overloadGuard: overloadGuardLib, qualityGovernor: qualityGovernorLib, importBudget: importBudgetLib, importGate: importGateLib, decimate: decimateLib, playCursor: playCursorLib, gameStorage: gameStorageLib, gameKit: gameKitLib, moduleWorld: moduleWorldLib, playSpawn: playSpawnLib, packRefs: packRefsLib, lod: lodLib, packBehavior: packBehaviorLib }
       })
     }
   })
diff --git a/src/components/Scene.svelte b/src/components/Scene.svelte
index b47e1714..b225a63a 100644
--- a/src/components/Scene.svelte
+++ b/src/components/Scene.svelte
@@ -40,6 +40,7 @@
 	import { moduleInteractiveGroups, fireClickMiss, runClickHandlers } from '$lib/moduleSDK';
 	import { updateSpatialAudio } from '$lib/voiceChat';
 	import { tickAnimatedMixers } from '$lib/animatedImports';
+	import { startPackBehaviors, tickPackBehaviors } from '$lib/packBehavior';
 	import { tickAnimationPreview, captureAutoKey, playheadOf } from '$lib/animationPreview';
 	import { drawMode, drawTool, strokePointFromRay, endStroke, setDrawScene } from '$lib/drawMode';
 	import { splinePlaceFromRay, splineToolActive, finishSpline } from '$lib/splineTool';
@@ -388,6 +389,7 @@
 		updateVRControls(); // also manages ray/hover visibility outside sessions
 		updateSpatialAudio(camera.current, scene); // voices follow avatars (throttled)
 		tickAnimatedMixers(); // imported clips run on the synced clock
+		tickPackBehaviors(); // 33 P2: doors/lids/levers pose from their shared state (rest in Edit)
 		tickAnimationPreview(); // Animation window: local transform preview (not synced)
 		tickMeshEdit(); // vertex handles follow the object if it moves (119)
 		tickEditWireframe(); // ...and the edit wireframe stays parented to it (faceEdit)
@@ -1435,6 +1437,7 @@
 		// A2: the hand that hit gets a buzz — LOCAL, the same seam shape as the hand poses
 		startKnock({ hands: handSnapshot, heldUuids: () => [carriedUuid(), vrGrabbedUuid()], haptic: hapticKnock });
 		startClap({ hands: handSnapshot }); // 31: the same hand seam
+		startPackBehaviors({ hands: handSnapshot }); // 33 P2: functional pack items (the knock reads hands)
 		// 30b: game feel in VR (a frame hook + a trigger hook through vrControls' registries)
 		startVrGameInput();
 
diff --git a/src/components/editors/AnimationWindow.svelte b/src/components/editors/AnimationWindow.svelte
index f7829e7c..9087370b 100644
--- a/src/components/editors/AnimationWindow.svelte
+++ b/src/components/editors/AnimationWindow.svelte
@@ -32,7 +32,7 @@
 	// posed from the synced clock) — the window used to ignore them entirely, so
 	// a rigged model showed "no movements yet" and its own animations were
 	// reachable only from the Inspector.
-	import { animatedObjects, setAnimationState, clipInfo } from '$lib/animatedImports';
+	import { animatedObjects, setAnimationState, clipInfo, behaviorOf } from '$lib/animatedImports';
 	import {
 		SkipBack, SkipForward, StepBack, StepForward, Play, Pause, Square, Rewind, ZoomIn, ZoomOut, Maximize2,
 		SquareDashed, Lasso, Ghost
@@ -142,6 +142,13 @@
 		$animatedObjects;
 		return target ? clipInfo(target.uuid) : [];
 	});
+	// 33 P2: a FUNCTIONAL item (a door, a lid) has no transport: its clip buttons PREVIEW
+	// locally (never sent, never saved, back to rest at the end) — it plays for real only
+	// on its trigger, in Interact or Play
+	const behavior = $derived.by(() => {
+		$animatedObjects;
+		return target ? behaviorOf(target.uuid) : null;
+	});
 
 	// transport is per object now (N objects can play at once); the playhead time
 	// comes from the per-frame `playheads` store, the transport state does not.
@@ -1863,7 +1870,7 @@
 							{#each clips as clip (clip.name)}
 								<button
 									class="flex w-full items-center justify-between gap-2 rounded-sm px-2 py-1 text-left text-xs hover:bg-gray-700/60 {clipState?.clip === clip.name ? 'bg-primary-900/40 text-primary-200' : 'text-gray-300'}"
-									title="Play this clip — on every peer"
+									title={behavior ? 'Preview this clip here — not sent, not saved' : 'Play this clip — on every peer'}
 									onclick={() => target && setAnimationState(target.uuid, { clip: clip.name, playing: true })}
 								>
 									<span class="min-w-0 truncate">{clip.name}</span>
@@ -1871,6 +1878,13 @@
 								</button>
 							{/each}
 						</div>
+						{#if behavior}
+							<p id="animation-behavior-note" class="px-2 pb-1 text-[10px] leading-snug text-amber-300/90">
+								{behavior.type === 'loop' && behavior.autoplay ? 'Ambient loop' : 'Functional item'} — runs in
+								Interact or Play{behavior.type === 'loop' && behavior.autoplay ? '' : ' on its ' + behavior.trigger}.
+								Here ▶ previews it once; nothing is sent or saved.
+							</p>
+						{/if}
 						<div class="flex items-center gap-2 px-2 pb-1">
 							<button
 								id="clip-play"
diff --git a/src/components/editors/Explorer.svelte b/src/components/editors/Explorer.svelte
index 1b2b2135..89c288a8 100644
--- a/src/components/editors/Explorer.svelte
+++ b/src/components/editors/Explorer.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { Box, Boxes, Download, ExternalLink, Folder, FolderTree, Gift, Globe, HardDrive, House, LayoutGrid, List, LoaderCircle, PackageOpen, RefreshCw, Save, Share2, X } from '@lucide/svelte';
+	import { Box, Boxes, Download, ExternalLink, Folder, FolderTree, Gift, Globe, HardDrive, House, LayoutGrid, List, LoaderCircle, PackageOpen, Play, RefreshCw, Save, Share2, X } from '@lucide/svelte';
 	import Icon from '../ui/Icon.svelte';
 	// Explorer (95, tree v2 in 106): dockable asset browser — real file-manager
 	// tree on the left (inline create/rename, expand/collapse, drag re-parent,
@@ -962,6 +962,26 @@
 	});
 	// pack-item thumbnail: imported items carry a dataURL; default items resolve
 	// webp -> png -> screenshot via the <img> onerror cursor, else a placeholder icon
+	// 33 P2: the "animated" badge's words — what the item does and what sets it off, so a
+	// door reads differently from a fan before anyone places it
+	const BEHAVIOR_WORDS: Record<string, string> = {
+		door: 'Opens and closes',
+		toggle: 'Switches on and off',
+		oneshot: 'Plays once',
+		loop: 'Loops'
+	};
+	const TRIGGER_WORDS: Record<string, string> = {
+		click: 'on a click',
+		proximity: 'when you walk up to it',
+		knock: 'when you knock on it'
+	};
+	function behaviorTitle(spec: any): string {
+		if (!spec) return '';
+		const what = BEHAVIOR_WORDS[spec.type] ?? 'Animated';
+		const when = spec.type === 'loop' && spec.autoplay ? 'by itself' : (TRIGGER_WORDS[spec.trigger] ?? 'on a click');
+		return 'Animated — ' + what.toLowerCase() + ' ' + when + ' in Interact or Play (never in Edit)';
+	}
+
 	function packThumb(item: any): string | null {
 		if (item.resolvedThumb) return item.resolvedThumb; // P2: cached resolution
 		if (item.thumbnail) return item.thumbnail;
@@ -5292,7 +5312,9 @@
 			kind: item.kind,
 			name: item.name,
 			prefabId: item.prefabId ?? null,
-			url: item.glbUrl ?? null
+			url: item.glbUrl ?? null,
+			// 33 P2: a functional pack item's spec rides the drag to the drop
+			...(item.behavior ? { behavior: item.behavior } : {})
 		};
 	}
 	/**
@@ -5703,7 +5725,8 @@
 			}
 			// 30c: the placed piece carries its pack reference (packRefs.js)
 			await importFile(new File([await res.blob()], item.name + '.glb'), item.name, 'glb', undefined, undefined, {
-				packRef: packRefFromUrl(item.glbUrl, { pack: item.packName, item: item.name })
+				packRef: packRefFromUrl(item.glbUrl, { pack: item.packName, item: item.name }),
+				behavior: item.behavior ?? null // 33 P2
 			});
 			dismiss();
 		} catch {
@@ -6366,6 +6389,13 @@
 						<!-- the same status the card carries in its corners, folded into ONE inline dot:
 						     a row has no corners, and four possible dots on one line is noise. The
 						     precedence is the card's own, top to bottom. -->
+						{#if !isFolder && item.behavior}
+							<span
+								class="explorer-animated shrink-0 text-amber-300"
+								title={behaviorTitle(item.behavior)}
+								data-behavior={item.behavior.type}
+							><Play size={10} aria-hidden="true" /></span>
+						{/if}
 						{#if !isFolder}
 							{#if item.volumeItem}
 								<span
@@ -7479,6 +7509,16 @@
 									</span>
 								{/if}
 							{/if}
+							{#if item.behavior}
+								<!-- 33 P2: an ANIMATED, functional item (a door, a lid, a fan). Top LEFT: a
+								     pack card has no scene dots, so that corner is free on every card that
+								     can carry this. -->
+								<span
+									class="explorer-animated absolute left-1 top-1 flex h-4 w-4 items-center justify-center rounded-full bg-gray-900/80 text-amber-300"
+									title={behaviorTitle(item.behavior)}
+									data-behavior={item.behavior.type}
+								><Play size={9} aria-hidden="true" /></span>
+							{/if}
 							{#if item.packEntry}
 								{#if packThumb(item)}
 									<!-- N6: lazily resolve webp -> png -> screenshot via onerror; P2: cache the winner -->
diff --git a/src/lib/animatedImports.js b/src/lib/animatedImports.js
index 31bb6077..2b23569a 100644
--- a/src/lib/animatedImports.js
+++ b/src/lib/animatedImports.js
@@ -8,6 +8,7 @@ import { objectsGroup, pokeScene } from '../stores/sceneStore';
 import { peers, showToast } from '../stores/appStore';
 import { registerHistoryKind, recordEntry } from './history';
 import { runtimeNow } from './moduleSDK';
+import { normalizeBehavior } from './behaviorCore';
 
 // Animated imports (GLTF/GLB and, since 17-D2, FBX). Rigs cannot survive the
 // per-node GLTF sync (bones are children and the exporter round-trip is lossy),
@@ -30,6 +31,70 @@ const fileKinds = new Map();
 /** @type {Map<string, {mixer: any, actions: Record<string, any>, durations: Record<string, number>}>} */
 const mixers = new Map();
 
+// ---- 33 P2: animated FUNCTIONAL items (a door, a chest, a lever, a fan) ---------------
+// An import whose root carries a `behavior` (stamped from the pack item's row, or from the
+// GLB's own scene extras) is driven by packBehavior.js, never by the transport below: the
+// transport is a looping clip on the synced clock, which is exactly what a door must NOT do.
+// The spec travels WITH the bytes (objectfile / save entry / undo entry) because it lives
+// in the pack row, not in the file. packBehavior reaches in through the two hooks.
+/** @type {Map<string, import('./behaviorCore').BehaviorSpec>} rootUuid -> spec */
+const behaviors = new Map();
+/** @type {{state: ((uuid: string) => any) | null, apply: ((uuid: string, state: any) => void) | null, preview: ((uuid: string, clip?: string) => void) | null, registered: ((uuid: string) => void) | null}} */
+const behaviorHooks = { state: null, apply: null, preview: null, registered: null };
+
+/** packBehavior plugs in here (it imports this module, so the edge cannot run the other way)
+ * @param {Partial<typeof behaviorHooks>} hooks */
+export function setBehaviorHooks(hooks) {
+	Object.assign(behaviorHooks, hooks);
+}
+
+/** @param {string} uuid @returns {import('./behaviorCore').BehaviorSpec | null} */
+export function behaviorOf(uuid) {
+	return behaviors.get(uuid) ?? null;
+}
+
+/** every root driven by a behavior @returns {string[]} */
+export function behaviorUuids() {
+	return [...behaviors.keys()];
+}
+
+/** the live registry, for the per-frame tick (iterate, never mutate — no copy per frame)
+ * @returns {ReadonlyMap<string, import('./behaviorCore').BehaviorSpec>} */
+export function behaviorRegistry() {
+	return behaviors;
+}
+
+/** the live mixer record (packBehavior poses through it) @param {string} uuid */
+export function animatedRecordOf(uuid) {
+	return mixers.get(uuid) ?? null;
+}
+
+/** the spec + live state a message/save carries for this root (both absent = none) @param {string} uuid */
+function behaviorFields(uuid) {
+	const spec = behaviors.get(uuid);
+	if (!spec) return {};
+	const state = behaviorHooks.state?.(uuid) ?? null;
+	return { behavior: spec, ...(state ? { behaviorState: state } : {}) };
+}
+
+/**
+ * 33 (for 33-lod-editor): the root's LOD group (`userData.lod`, plain JSON validated by
+ * lodGroupCore on the reading side) travels beside the bytes for the same reason the
+ * behavior spec does — the peer RE-PARSES the file, so anything stamped on the root after
+ * the parse is otherwise lost on peers, after a reload and across an undo. Absent = none,
+ * so every message without one is byte-identical.
+ * @param {any} root @returns {{lod?: any}}
+ */
+function rootDataFields(root) {
+	const lod = root?.userData?.lod;
+	if (!lod || typeof lod !== 'object') return {};
+	try {
+		return { lod: JSON.parse(JSON.stringify(lod)) };
+	} catch {
+		return {};
+	}
+}
+
 /** GLTFLoader with draco + meshopt decoders wired */
 export function createGltfLoader() {
 	const loader = new GLTFLoader();
@@ -93,7 +158,11 @@ export function animatedImportPayload(uuid) {
 }
 
 /**
- * Track an imported animated root: keep bytes, build the mixer, autoplay.
+ * Track an imported animated root: keep bytes, build the mixer. 33 P2: NOTHING AUTOPLAYS
+ * any more — placing an animated GLB used to start (and loop) its FIRST clip at once, which
+ * is how a door swung forever the moment it landed. The clip is selected, not playing; the
+ * Animation panel's play button (or a Play Animation node) starts it. A root carrying a
+ * `behavior` is handed to packBehavior instead (see the block above).
  * @param {any} root @param {any[]} animations @param {ArrayBuffer} bytes
  * @param {'gltf'|'fbx'} [kind] which parser those bytes need (default gltf)
  */
@@ -111,12 +180,21 @@ export function registerAnimatedImport(root, animations, bytes, kind = 'gltf') {
 	});
 	mixers.set(root.uuid, { mixer, actions, durations });
 	root.userData.animatedClips = animations.map((c) => c.name);
-	const first = animations[0]?.name;
+	const spec = normalizeBehavior(root.userData.behavior);
+	if (spec && !actions[spec.clip]) {
+		// a behavior naming a clip the file does not have drives nothing — say so once
+		console.log('behavior clip "' + spec.clip + '" not in', root.name, Object.keys(actions));
+	}
+	if (spec && actions[spec.clip]) {
+		root.userData.behavior = spec;
+		behaviors.set(root.uuid, spec);
+	} else delete root.userData.behavior;
+	const first = spec && actions[spec.clip] ? spec.clip : animations[0]?.name;
 	animatedObjects.update((map) => ({
 		...map,
-		[root.uuid]: { clips: animations.map((c) => c.name), clip: first, playing: true, speed: 1 }
+		[root.uuid]: { clips: animations.map((c) => c.name), clip: first, playing: false, speed: 1 }
 	}));
-	if (first) actions[first].play();
+	if (behaviors.has(root.uuid)) behaviorHooks.registered?.(root.uuid);
 }
 
 /** Per-frame from the scene loop: pose = pure function of the synced clock */
@@ -124,6 +202,7 @@ export function tickAnimatedMixers() {
 	const states = get(animatedObjects);
 	const time = runtimeNow();
 	mixers.forEach(({ mixer, durations }, uuid) => {
+		if (behaviors.has(uuid)) return; // 33 P2: packBehavior poses these
 		const state = states[uuid];
 		if (!state || !state.playing || !state.clip) return;
 		const duration = durations[state.clip] || 1;
@@ -139,6 +218,13 @@ export function setAnimationState(uuid, next, replicate = true) {
 	const entry = get(animatedObjects)[uuid];
 	const record = mixers.get(uuid);
 	if (!entry || !record) return;
+	// 33 P2: a functional item has no transport. Pressing play on one in the Animation panel
+	// or the Inspector is a LOCAL PREVIEW — never sent, never saved, back to rest at the end
+	// (the user's rule: previewing a door in Edit must not leave it open in the file)
+	if (behaviors.has(uuid)) {
+		if (replicate && (next.playing || next.clip)) behaviorHooks.preview?.(uuid, next.clip ?? entry.clip);
+		return;
+	}
 	const state = { ...entry, ...next };
 	animatedObjects.update((map) => ({ ...map, [uuid]: state }));
 	if (next.clip && next.clip !== entry.clip) {
@@ -175,11 +261,13 @@ export async function applyObjectFile(data) {
 		// animation on every walk-in for no gain.
 		if (!data.override) return;
 		if (data.name) held.name = data.name;
+		if (data.lod && typeof data.lod === 'object') held.userData.lod = data.lod;
 		if (data.pos) held.position.fromArray(data.pos);
 		if (data.rot) held.rotation.set(data.rot[0], data.rot[1], data.rot[2]);
 		if (data.scale) held.scale.fromArray(data.scale);
 		pokeScene();
-		if (data.anim) setAnimationState(data.uuid, data.anim, false);
+		if (data.behaviorState && behaviors.has(data.uuid)) behaviorHooks.apply?.(data.uuid, data.behaviorState);
+		else if (data.anim) setAnimationState(data.uuid, data.anim, false);
 		return;
 	}
 	try {
@@ -188,13 +276,20 @@ export async function applyObjectFile(data) {
 		const { root, animations } = await parseAnimatedBytes(bytes, data.kind);
 		root.uuid = data.uuid;
 		root.name = data.name ?? 'Animated import';
+		// 33 P2: the spec rides the message (it lives in the pack row, not the file); absent =
+		// whatever the file's own extras say, or nothing
+		const spec = normalizeBehavior(data.behavior);
+		if (spec) root.userData.behavior = spec;
+		if (data.lod && typeof data.lod === 'object') root.userData.lod = data.lod;
 		if (data.pos) root.position.fromArray(data.pos);
 		if (data.rot) root.rotation.set(data.rot[0], data.rot[1], data.rot[2]);
 		if (data.scale) root.scale.fromArray(data.scale);
 		group.add(root);
 		pokeScene();
 		registerAnimatedImport(root, animations, bytes, data.kind === 'fbx' ? 'fbx' : 'gltf');
-		if (data.anim) setAnimationState(data.uuid, data.anim, false);
+		if (behaviors.has(data.uuid)) {
+			if (data.behaviorState) behaviorHooks.apply?.(data.uuid, data.behaviorState);
+		} else if (data.anim) setAnimationState(data.uuid, data.anim, false);
 	} catch (error) {
 		console.log('objectfile parse failed', error);
 		showToast('Could not load an animated model from a peer');
@@ -219,7 +314,10 @@ export function sendAnimatedImport(conn, root, opts = {}) {
 		pos: root.position.toArray(),
 		rot: [root.rotation.x, root.rotation.y, root.rotation.z],
 		scale: root.scale.toArray(),
-		anim: state ? { clip: state.clip, playing: state.playing, speed: state.speed } : null
+		anim: state ? { clip: state.clip, playing: state.playing, speed: state.speed } : null,
+		// 33 P2: additive — absent for every import without a behavior / a LOD group
+		...behaviorFields(root.uuid),
+		...rootDataFields(root)
 	});
 }
 
@@ -286,6 +384,10 @@ export function animatedImportsSnapshot(group) {
 			rot: [child.rotation.x, child.rotation.y, child.rotation.z],
 			scale: child.scale.toArray(),
 			anim: state ? { clip: state.clip, playing: state.playing, speed: state.speed } : null,
+			// 33 P2: the SPEC is saved (it is not in the bytes); the open/shut state is runtime
+			// and never is — a scene saved with its door open reopens shut
+			...(behaviors.has(child.uuid) ? { behavior: behaviors.get(child.uuid) } : {}),
+			...rootDataFields(child),
 			bytes: bytesToBase64(bytes)
 		});
 	}
@@ -320,7 +422,9 @@ export async function animatedImportsRestore(entries, replicate = true) {
 				pos: entry.pos,
 				rot: entry.rot,
 				scale: entry.scale,
-				anim: entry.anim
+				anim: entry.anim,
+				behavior: entry.behavior,
+				lod: entry.lod
 			});
 			const root = get(objectsGroup)?.getObjectByProperty('uuid', entry.uuid);
 			if (root && replicate && peer) sendAnimatedImport(peer, root); // peers reparse the same file
@@ -335,6 +439,7 @@ export async function animatedImportsRestore(entries, replicate = true) {
 
 /** Cleanup when the object is removed @param {string} uuid */
 export function dropAnimatedImport(uuid) {
+	behaviors.delete(uuid);
 	fileBytes.delete(uuid);
 	fileKinds.delete(uuid);
 	mixers.delete(uuid);
@@ -347,6 +452,7 @@ export function dropAnimatedImport(uuid) {
 
 /** Scene was wiped — forget every registry entry */
 export function dropAllAnimatedImports() {
+	behaviors.clear();
 	fileBytes.clear();
 	fileKinds.clear();
 	mixers.clear();
@@ -371,7 +477,9 @@ registerHistoryKind('animimport', (entry, state) => {
 			// `fileKind` — reusing `kind` would break the registry dispatch.
 			kind: entry.fileKind,
 			buffer: entry.buffer,
-			pos: entry.pos
+			pos: entry.pos,
+			behavior: entry.behavior,
+			lod: entry.lod
 		}).then(() => {
 			const root = get(objectsGroup)?.getObjectByProperty('uuid', entry.uuid);
 			if (root && peer) sendAnimatedImport(peer, root); // peer.send broadcasts
@@ -397,6 +505,8 @@ export function recordAnimatedImport(root) {
 		fileKind: animatedImportKind(root.uuid),
 		buffer: fileBytes.get(root.uuid),
 		pos: root.position.toArray(),
+		...(behaviors.has(root.uuid) ? { behavior: behaviors.get(root.uuid) } : {}),
+		...rootDataFields(root),
 		before: { present: false },
 		after: { present: true }
 	});
diff --git a/src/lib/behaviorCore.js b/src/lib/behaviorCore.js
new file mode 100644
index 00000000..d3640826
--- /dev/null
+++ b/src/lib/behaviorCore.js
@@ -0,0 +1,263 @@
+// 33 P2 — ANIMATED, FUNCTIONAL PACK ITEMS: the pure half (imports NOTHING, so vitest
+// covers it with no browser). The runtime that drives the mixer, the wire, the triggers
+// and the colliders is packBehavior.js.
+//
+// THE CONTRACT (roadmap 33, P2): a pack item MAY carry
+//   behavior: {type: 'door'|'toggle'|'oneshot'|'loop', clip, closeClip?, trigger:
+//              'click'|'proximity'|'knock', autoplay: false, sound?, collider?: 'follow'}
+// and the rule the user asked for: NOTHING plays on placement, on load or in Edit, and
+// nothing loops unless it is an ambient `loop` with `autoplay: true`.
+//
+// THE STATE is runtime and shared: `{on, at, from, n}` — `on` is open/running, `at` the
+// SESSION ms of the last trigger (sessionNow, so every peer evaluates the same moment),
+// `from` where the movement started in OPEN-clip seconds (a door closed half-way opens
+// from where it is, not from shut), `n` the trigger count (a oneshot's identity, and the
+// tie-break for two triggers in one millisecond). Every pose is a pure function of
+// (spec, state, durations, now) — determinism is the netcode, so a toggle is ONE message.
+
+export const BEHAVIOR_TYPES = ['door', 'toggle', 'oneshot', 'loop'];
+export const BEHAVIOR_TRIGGERS = ['click', 'proximity', 'knock'];
+/** the proximity trigger's radius (metres from the object's box) */
+export const PROXIMITY_RADIUS = 1.5;
+/** the slowest hand that counts as a knock (m/s) */
+export const KNOCK_SPEED = 0.6;
+const NAME_MAX = 64;
+
+/**
+ * @typedef {{type: 'door'|'toggle'|'oneshot'|'loop', clip: string, closeClip: string | null,
+ *   trigger: 'click'|'proximity'|'knock', autoplay: boolean, sound: string | null,
+ *   collider: 'follow' | null}} BehaviorSpec
+ * @typedef {{on: boolean, at: number, from: number, n: number}} BehaviorState
+ */
+
+/** @param {any} v */
+function clipName(v) {
+	return typeof v === 'string' && v.trim() ? v.trim().slice(0, NAME_MAX) : null;
+}
+
+/**
+ * The ONE boundary: a pack row, GLB extras or a wire message in, a clean spec or null out.
+ * Unknown keys are dropped (the spec is small and fully understood); a missing `clip` is
+ * null — there is nothing to drive. `autoplay` is honoured ONLY for `loop` (the rule).
+ * `collider` defaults to 'follow' for a door (a door you cannot walk through when it is open
+ * is not a door) and to none otherwise.
+ * @param {any} raw @returns {BehaviorSpec | null}
+ */
+export function normalizeBehavior(raw) {
+	if (!raw || typeof raw !== 'object') return null;
+	const type = BEHAVIOR_TYPES.includes(raw.type) ? raw.type : null;
+	const clip = clipName(raw.clip);
+	if (!type || !clip) return null;
+	const trigger = BEHAVIOR_TRIGGERS.includes(raw.trigger) ? raw.trigger : 'click';
+	const closeClip = type === 'door' || type === 'toggle' ? clipName(raw.closeClip) : null;
+	const collider =
+		raw.collider === 'follow' || (raw.collider === undefined && type === 'door') ? 'follow' : null;
+	return {
+		type,
+		clip,
+		closeClip: closeClip && closeClip !== clip ? closeClip : null,
+		trigger,
+		autoplay: type === 'loop' && raw.autoplay === true,
+		sound: clipName(raw.sound),
+		collider
+	};
+}
+
+/** @returns {BehaviorState} the state before anything happened */
+export function restState() {
+	return { on: false, at: 0, from: 0, n: 0 };
+}
+
+/** @param {any} raw @returns {BehaviorState | null} a wire/save state, checked */
+export function normalizeState(raw) {
+	if (!raw || typeof raw !== 'object') return null;
+	const at = Number(raw.at);
+	const from = Number(raw.from);
+	const n = Number(raw.n);
+	if (!Number.isFinite(at) || !Number.isFinite(from) || !Number.isFinite(n)) return null;
+	return { on: raw.on === true, at, from: Math.max(0, from), n: Math.max(0, Math.floor(n)) };
+}
+
+/**
+ * Latest wins: the newer stamp, then the higher count (two triggers inside one ms).
+ * @param {BehaviorState | null} mine @param {BehaviorState} theirs @returns {boolean}
+ */
+export function stateIsNewer(mine, theirs) {
+	if (!mine) return true;
+	if (theirs.at !== mine.at) return theirs.at > mine.at;
+	return theirs.n > mine.n;
+}
+
+/** @param {number} v @param {number} lo @param {number} hi */
+function clamp(v, lo, hi) {
+	return Math.min(hi, Math.max(lo, v));
+}
+
+/**
+ * How far along the OPEN clip a door/toggle is now (seconds, 0 = shut, `open` = full).
+ * Moves at clip speed from `from` toward the end the state points at.
+ * @param {BehaviorState} state @param {number} openDur @param {number} nowMs
+ */
+export function openPosition(state, openDur, nowMs) {
+	const dur = Math.max(1e-3, openDur);
+	if (!state.n) return 0;
+	const elapsed = Math.max(0, (nowMs - state.at) / 1000);
+	const from = clamp(state.from, 0, dur);
+	return state.on ? Math.min(dur, from + elapsed) : Math.max(0, from - elapsed);
+}
+
+/**
+ * THE POSE: which clip to show and at what time. `active` false is Edit (the user's rule:
+ * the rest pose, whatever the shared state says) — and the rest pose is the OPEN clip at 0.
+ * `durations` maps clip name -> seconds. A `closeClip` is played while closing, mapped so a
+ * half-open door closes from half-way: progress through it = 1 - openPosition / openDur.
+ * @param {BehaviorSpec} spec @param {BehaviorState} state
+ * @param {Record<string, number>} durations @param {number} nowMs @param {boolean} active
+ * @returns {{clip: string, time: number, moving: boolean}}
+ */
+export function poseAt(spec, state, durations, nowMs, active) {
+	const dur = Math.max(1e-3, durations[spec.clip] ?? 1);
+	const rest = { clip: spec.clip, time: 0, moving: false };
+	if (!active) return rest;
+	const elapsed = Math.max(0, (nowMs - state.at) / 1000);
+	if (spec.type === 'loop') {
+		const running = spec.autoplay || state.on;
+		if (!running) return rest;
+		// ambient loops share the session clock's phase; a triggered one starts at its stamp
+		const t = spec.autoplay ? nowMs / 1000 : elapsed;
+		return { clip: spec.clip, time: ((t % dur) + dur) % dur, moving: true };
+	}
+	if (spec.type === 'oneshot') {
+		if (!state.n) return rest;
+		const time = Math.min(dur, elapsed);
+		return { clip: spec.clip, time, moving: time < dur };
+	}
+	// door / toggle
+	const pos = openPosition(state, dur, nowMs);
+	const moving = state.n > 0 && (state.on ? pos < dur : pos > 0);
+	if (!state.on && spec.closeClip && durations[spec.closeClip] && state.n) {
+		const cdur = Math.max(1e-3, durations[spec.closeClip]);
+		return { clip: spec.closeClip, time: (1 - pos / dur) * cdur, moving };
+	}
+	return { clip: spec.clip, time: pos, moving };
+}
+
+/**
+ * The next state after a trigger at `nowMs` (the press, a knock, the proximity edge).
+ * `want` forces a direction (proximity: true on the rising edge, false on the falling one);
+ * undefined toggles. A oneshot always restarts; a loop starts/stops. Returns null when
+ * nothing would change (a proximity open on an already-open door).
+ * @param {BehaviorSpec} spec @param {BehaviorState} state @param {Record<string, number>} durations
+ * @param {number} nowMs @param {boolean} [want] @returns {BehaviorState | null}
+ */
+export function nextState(spec, state, durations, nowMs, want) {
+	const n = state.n + 1;
+	if (spec.type === 'oneshot') return { on: true, at: nowMs, from: 0, n };
+	if (spec.type === 'loop') {
+		if (spec.autoplay) return null; // ambient: nothing to trigger
+		const on = want === undefined ? !state.on : want;
+		return on === state.on && state.n ? null : { on, at: nowMs, from: 0, n };
+	}
+	const on = want === undefined ? !state.on : want;
+	if (on === state.on && state.n) return null;
+	const dur = Math.max(1e-3, durations[spec.clip] ?? 1);
+	return { on, at: nowMs, from: openPosition(state, dur, nowMs), n };
+}
+
+/**
+ * A box MINUS a box, as slabs: the part of `outer` not covered by `hole`, in up to six
+ * axis-aligned pieces (below/above the hole on x, then y, then z, each later axis inside
+ * the earlier ones' range). Slabs thinner than `minSize` are dropped — along a door's
+ * thickness the hole spans (nearly) the whole frame, so those slabs would be slivers.
+ * Boxes are [minx, miny, minz, maxx, maxy, maxz]. Used to cut a doorway out of a frame
+ * whose mesh is one piece (two posts and a lintel make ONE box, which would block the
+ * opening forever).
+ * @param {number[]} outer @param {number[]} hole @param {number} [minSize]
+ * @returns {number[][]}
+ */
+export function boxMinusBox(outer, hole, minSize = 0.01) {
+	const h = [0, 1, 2].map((a) => [clamp(hole[a], outer[a], outer[a + 3]), clamp(hole[a + 3], outer[a], outer[a + 3])]);
+	if (h.some(([lo, hi]) => hi - lo <= 0)) return [outer.slice()]; // no overlap
+	/** @type {number[][]} */
+	const out = [];
+	const cur = outer.slice();
+	for (let a = 0; a < 3; a++) {
+		const [lo, hi] = h[a];
+		if (lo - cur[a] >= minSize) {
+			const s = cur.slice();
+			s[a + 3] = lo;
+			out.push(s);
+		}
+		if (cur[a + 3] - hi >= minSize) {
+			const s = cur.slice();
+			s[a] = hi;
+			out.push(s);
+		}
+		cur[a] = lo;
+		cur[a + 3] = hi;
+	}
+	return out;
+}
+
+/** does box `a` overlap box `b` (strictly, by more than `eps`)? @param {number[]} a @param {number[]} b */
+export function boxesOverlap(a, b, eps = 1e-4) {
+	for (let i = 0; i < 3; i++) if (a[i + 3] - eps <= b[i] || b[i + 3] - eps <= a[i]) return false;
+	return true;
+}
+
+/**
+ * The frame's collider pieces: each static box, minus every moving part's REST box it
+ * overlaps (a moving part that sits inside a static mesh's box is a doorway, a lid, a
+ * hatch — the opening must stay open). Pure over boxes in the object's local frame.
+ * @param {number[][]} staticBoxes @param {number[][]} movingBoxes @returns {number[][]}
+ */
+export function frameSlabs(staticBoxes, movingBoxes) {
+	/** @type {number[][]} */
+	let pieces = staticBoxes.map((b) => b.slice());
+	for (const hole of movingBoxes) {
+		/** @type {number[][]} */
+		const next = [];
+		for (const piece of pieces) {
+			if (boxesOverlap(piece, hole)) next.push(...boxMinusBox(piece, passageThrough(piece, hole)));
+			else next.push(piece);
+		}
+		pieces = next;
+	}
+	return pieces;
+}
+
+/** a frame no deeper than this is a wall/doorway the opening passes THROUGH */
+const PASSAGE_DEPTH = 0.6;
+
+/**
+ * A door leaf is thinner than the frame it hangs in (the frame is the wall's depth), so
+ * cutting just the leaf's box leaves a sliver in front of and behind it that still blocks
+ * the doorway. When the moving part's THIN axis lies inside a shallow static box, the hole
+ * runs through that box's whole depth on that axis. A lid sitting ON a chest never enters
+ * here (they only touch), and a deep box keeps its exact hole.
+ * @param {number[]} piece @param {number[]} hole @returns {number[]}
+ */
+export function passageThrough(piece, hole) {
+	let thin = 0;
+	for (let a = 1; a < 3; a++) if (hole[a + 3] - hole[a] < hole[thin + 3] - hole[thin]) thin = a;
+	const depth = piece[thin + 3] - piece[thin];
+	const inside = hole[thin] >= piece[thin] - 1e-4 && hole[thin + 3] <= piece[thin + 3] + 1e-4;
+	if (depth > PASSAGE_DEPTH || !inside) return hole;
+	const out = hole.slice();
+	out[thin] = piece[thin];
+	out[thin + 3] = piece[thin + 3];
+	return out;
+}
+
+/** the 8 corners of a box as a flat xyz list (a custom collider piece is a hull of points)
+ * @param {number[]} b @returns {number[]} */
+export function boxCorners(b) {
+	const out = [];
+	for (const x of [b[0], b[3]]) for (const y of [b[1], b[4]]) for (const z of [b[2], b[5]]) out.push(x, y, z);
+	return out;
+}
+
+/** The sound a trigger plays when the item names none, per type. @param {BehaviorSpec} spec */
+export function defaultSound(spec) {
+	return spec.type === 'door' ? 'door' : spec.type === 'oneshot' ? 'lever' : spec.type === 'toggle' ? 'click' : null;
+}
diff --git a/src/lib/explorerDrop.js b/src/lib/explorerDrop.js
index b3de320d..776f65ca 100644
--- a/src/lib/explorerDrop.js
+++ b/src/lib/explorerDrop.js
@@ -166,7 +166,7 @@ function spreadPoint(point, i, count) {
  * shape, so this is the only consumer that had to learn anything. The raycast happens
  * ONCE and every item is placed relative to that one point: raycasting per item would
  * ask the scene where to put an object while the previous ones were still arriving.
- * @param {{id?: string, kind: string, name: string, prefabId?: string | null, url?: string | null, items?: any[]}} payload
+ * @param {{id?: string, kind: string, name: string, prefabId?: string | null, url?: string | null, behavior?: any, items?: any[]}} payload
  * @param {number} clientX @param {number} clientY
  */
 export async function dropExplorerItem(payload, clientX, clientY) {
@@ -209,7 +209,8 @@ async function placeExplorerPayload(payload, target) {
 			// 30c: the placed piece carries its pack reference, so a save and the wire write it
 			// as a small stub instead of the whole model (packRefs.js)
 			importFile(new File([await res.blob()], name + '.glb'), name, undefined, target.point ?? undefined, undefined, {
-				packRef: packRefFromUrl(payload.url, { item: name })
+				packRef: packRefFromUrl(payload.url, { item: name }),
+				behavior: payload.behavior ?? null // 33 P2
 			});
 			dismiss();
 		} catch {
diff --git a/src/lib/fileHandler.svelte.js b/src/lib/fileHandler.svelte.js
index 2a085ab8..b01b69b6 100644
--- a/src/lib/fileHandler.svelte.js
+++ b/src/lib/fileHandler.svelte.js
@@ -331,10 +331,15 @@ export async function loadFile(url, name) {
  * message (rigs cannot survive the per-node pipeline).
  * @param {any} result @param {ArrayBuffer} buffer @param {string=} name
  * @param {'gltf'|'fbx'=} kind which parser the bytes need on the other side (17-D2)
+ * @param {number[]=} position 33 P2: the drop point
  */
-function addAnimatedImport(result, buffer, name, kind) {
+function addAnimatedImport(result, buffer, name, kind, position) {
 	const root = result.scene;
 	root.name = name ?? 'Animated import';
+	// 33 P2: an animated model lands where it was dropped, like every other import (the
+	// position used to be ignored on this path, so a door dropped at the cursor appeared at
+	// the origin). Set BEFORE the sync so peers receive the placed transform.
+	if (position) root.position.fromArray(position);
 	sceneObjects.add(root);
 	pokeScene();
 	controls.attach(root);
@@ -345,7 +350,12 @@ function addAnimatedImport(result, buffer, name, kind) {
 	// 15-K3: the selection SET drives the outline + Ctrl+D — keep it in sync
 	selectedObjects.set([root.uuid]);
 	peer.send({ type: 'lock', uuid: root.uuid, peerId: peer.peer.id });
-	showToast('Animated model: ' + result.animations.length + ' clip(s), playing the first');
+	// 33 P2: nothing autoplays any more (registerAnimatedImport); say what does play it
+	showToast(
+		root.userData.behavior
+			? 'Placed "' + root.name + '" — it opens with a click in Interact or Play'
+			: 'Animated model: ' + result.animations.length + ' clip(s) — play them from the Animation panel'
+	);
 }
 
 /** Shared tail for every import format: add to the scene, select, replicate.
@@ -668,7 +678,8 @@ function defaultImportName(extension, name) {
  * @param {any} file @param {string=} name @param {string=} ext - explicit extension when the blob has no name (Library)
  * @param {number[]=} position - world drop point (Explorer drag-out, 96)
  * @param {any[]=} extras - companion files picked/dropped alongside (.mtl + its textures)
- * @param {{reduce?: boolean | import('./importBudget').ReductionPlan, packRef?: import('./packRefs').PackRef | null}} [opts]
+ * @param {{reduce?: boolean | import('./importBudget').ReductionPlan, packRef?: import('./packRefs').PackRef | null, behavior?: any}} [opts]
+ *   `behavior` (33 P2): the pack item's functional spec — a door, a lid, a fan
  *   26-F: `reduce` imports REDUCED. 30c: `packRef` names the PACK ITEM this file is — the
  *   placed root then carries the reference (packRefs.js), so a save and the wire write it
  *   as a small stub. Ignored for an animated or a reduced import (neither IS the file).
@@ -711,7 +722,10 @@ export async function importFile(file, name, ext, position, extras, opts = {}) {
 		// 30c: stamp the pack reference BEFORE addImported, which is what replicates it
 		if (opts.packRef && !parsed.animated && typeof file?.arrayBuffer === 'function')
 			stampPackRef(parsed.root, opts.packRef, await hashBytes(await file.arrayBuffer()));
-		if (parsed.animated) addAnimatedImport(parsed.animated.result, parsed.animated.buffer, label, parsed.animated.kind);
+		// 33 P2: a pack item's `behavior` (its row) wins over one in the file's own extras
+		if (opts.behavior && parsed.animated) parsed.root.userData.behavior = opts.behavior;
+		if (parsed.animated)
+			addAnimatedImport(parsed.animated.result, parsed.animated.buffer, label, parsed.animated.kind, position);
 		else addImported(parsed.root, label, position);
 		for (const note of parsed.notes) showToast(note);
 		return parsed.root.uuid;
diff --git a/src/lib/gameSfx.js b/src/lib/gameSfx.js
index 7fd164f5..7f643a0c 100644
--- a/src/lib/gameSfx.js
+++ b/src/lib/gameSfx.js
@@ -1,4 +1,4 @@
-// 30b (vr-play) C5 — THE GAME SOUND SET. Twenty procedural WebAudio effects a game can
+// 30b (vr-play) C5 — THE GAME SOUND SET. Twenty (33 P2: twenty-five) procedural WebAudio effects a game can
 // name (`api.playSound('coin')`), with NO asset files: every sound is oscillators, a
 // shared noise buffer, filters and envelopes, built fresh per play on the app's one
 // AudioContext (audioEngine — a second context would have its own listener and clock).
@@ -46,7 +46,14 @@ export const GAME_SOUNDS = [
 	'ring',
 	'sparkle',
 	'hurt',
-	'portal'
+	'portal',
+	// 33 P2: the sounds a functional pack item names (a door, an iron gate, a sci-fi slide,
+	// a lever, a chest lid) — `click` covers buttons and plates
+	'door',
+	'gate',
+	'slide',
+	'lever',
+	'lid'
 ];
 const SOUND_SET = new Set(GAME_SOUNDS);
 
@@ -282,6 +289,37 @@ export function buildGameSound(ctx, dest, name, t0) {
 			tone(ctx, dest, { freq: 270, to: 1950, type: 'triangle', t0: t0 + 0.05, dur: 0.85, peak: 0.08, attack: 0.3 });
 			noise(ctx, dest, { t0, dur: 0.9, peak: 0.08, attack: 0.4, filter: 'bandpass', freq: 800, to: 4000, q: 2 });
 			return 0.95;
+		// 33 P2 — the functional-item set
+		case 'door':
+			// wood: a creak (a slow sawtooth wobble through a narrow band) then a soft thud
+			tone(ctx, dest, { freq: 210, to: 260, type: 'sawtooth', t0, dur: 0.5, peak: 0.06, attack: 0.08, vibrato: { rate: 23, depth: 18 } });
+			noise(ctx, dest, { t0, dur: 0.45, peak: 0.08, attack: 0.1, filter: 'bandpass', freq: 900, q: 6, flutter: 17 });
+			tone(ctx, dest, { freq: 110, to: 60, t0: t0 + 0.5, dur: 0.18, peak: 0.35, attack: 0.003 });
+			noise(ctx, dest, { t0: t0 + 0.5, dur: 0.08, peak: 0.2, freq: 700, to: 200, attack: 0.002 });
+			return 0.72;
+		case 'gate':
+			// iron: an inharmonic clank and a short scrape
+			[310, 310 * 2.32, 310 * 4.1].forEach((f, i) =>
+				tone(ctx, dest, { freq: f, t0, dur: 0.6 - i * 0.15, peak: 0.14 - i * 0.03, attack: 0.002 })
+			);
+			noise(ctx, dest, { t0: t0 + 0.04, dur: 0.35, peak: 0.12, attack: 0.02, filter: 'bandpass', freq: 2400, q: 3 });
+			return 0.65;
+		case 'slide':
+			// sci-fi: a pneumatic hiss over a gliding hum
+			noise(ctx, dest, { t0, dur: 0.6, peak: 0.25, attack: 0.03, filter: 'highpass', freq: 3500, to: 1500 });
+			tone(ctx, dest, { freq: 140, to: 220, type: 'triangle', t0, dur: 0.55, peak: 0.12, attack: 0.05 });
+			return 0.65;
+		case 'lever':
+			// a ratchet of clicks into a heavy clunk
+			[0, 0.05, 0.1].forEach((d) => noise(ctx, dest, { t0: t0 + d, dur: 0.03, peak: 0.15, filter: 'highpass', freq: 2500, attack: 0.001 }));
+			tone(ctx, dest, { freq: 130, to: 70, type: 'square', t0: t0 + 0.16, dur: 0.16, peak: 0.18, attack: 0.002 });
+			noise(ctx, dest, { t0: t0 + 0.16, dur: 0.1, peak: 0.25, freq: 900, to: 250, attack: 0.002 });
+			return 0.36;
+		case 'lid':
+			// a chest lid: a short high creak and a light knock
+			tone(ctx, dest, { freq: 420, to: 520, type: 'sawtooth', t0, dur: 0.3, peak: 0.05, attack: 0.05, vibrato: { rate: 31, depth: 25 } });
+			tone(ctx, dest, { freq: 180, to: 90, t0: t0 + 0.3, dur: 0.12, peak: 0.25, attack: 0.002 });
+			return 0.45;
 		default:
 			return -1;
 	}
diff --git a/src/lib/moduleSDK.js b/src/lib/moduleSDK.js
index 6dde8928..105c7918 100644
--- a/src/lib/moduleSDK.js
+++ b/src/lib/moduleSDK.js
@@ -264,6 +264,7 @@ function removeSceneRootGroup(name) {
 /** @type {any} */ let jointsRef = null;
 /** @type {any} */ let objectActionsRef = null;
 /** @type {any} */ let pingAudioRef = null;
+/** @type {any} */ let packBehaviorRef = null; // 33 P2 (api.behavior)
 /** @type {any} */ let audioEngineRef = null;
 /** @type {any} */ let musicClockRef = null;
 /** @type {any} */ let audioDevicesRef = null;
@@ -298,6 +299,7 @@ if (typeof window !== 'undefined') {
 	import('./joints').then((m) => (jointsRef = m));
 	import('./objectActions').then((m) => (objectActionsRef = m));
 	import('./pingAudio').then((m) => (pingAudioRef = m));
+	import('./packBehavior').then((m) => (packBehaviorRef = m));
 	// 23-A5: the audio stack — engine (a leaf, but kept dynamic with its siblings so the
 	// four resolve together), clock, devices, patch, and the sample loader
 	import('./audioEngine').then((m) => (audioEngineRef = m));
@@ -1440,6 +1442,36 @@ function makeApi(moduleId, moduleName = moduleId) {
 			onDispose(() => handle.remove());
 			return handle;
 		},
+		/**
+		 * 33 P2: FUNCTIONAL PACK ITEMS — a door, a chest lid, a lever, a fan placed from a pack
+		 * (an item carrying a `behavior`). `list()` -> `[{uuid, type, trigger, open}]`;
+		 * `state(uuid)` -> `{on, at, n}` or null before anything triggered it;
+		 * `trigger(uuid, open?)` toggles it (or forces `open` true/false) exactly as a player's
+		 * click would — REPLICATED (one `behavior` message, every peer poses it from the same
+		 * stamp), so call it on ONE peer. Returns whether anything changed. Nothing here moves in
+		 * Edit: a peer in Edit renders the rest pose whatever the state says.
+		 */
+		behavior: {
+			list() {
+				const ref = packBehaviorRef;
+				if (!ref) return [];
+				return ref.packBehaviorDebug().items.map((/** @type {any} */ it) => ({
+					uuid: it.uuid,
+					type: it.spec?.type,
+					trigger: it.spec?.trigger,
+					open: !!it.state?.on
+				}));
+			},
+			/** @param {string} uuid */
+			state(uuid) {
+				const s = packBehaviorRef?.behaviorState(uuid);
+				return s ? { on: s.on, at: s.at, n: s.n } : null;
+			},
+			/** @param {string} uuid @param {boolean} [open] */
+			trigger(uuid, open) {
+				return !!packBehaviorRef?.triggerBehavior(String(uuid), typeof open === 'boolean' ? open : undefined);
+			}
+		},
 		/**
 		 * 31-perf K4: the ADAPTIVE QUALITY LEVEL on this device, so a module can cut its own
 		 * effects/particles/draw distance when the frame rate cannot hold. `level` is 0 (best)
diff --git a/src/lib/packBehavior.js b/src/lib/packBehavior.js
new file mode 100644
index 00000000..93f2a47e
--- /dev/null
+++ b/src/lib/packBehavior.js
@@ -0,0 +1,600 @@
+// 33 P2 — ANIMATED, FUNCTIONAL PACK ITEMS: the runtime. A door you click open, a chest
+// lid, a lever, a fan. The pure rules (normalize, timing, the doorway maths) live in
+// behaviorCore.js; this file feeds them and acts on the answer.
+//
+// WHAT DRIVES WHAT
+//  · The SPEC rides the placed root (`userData.behavior`, registered by animatedImports
+//    from the pack row or the GLB's own extras). animatedImports skips these roots in its
+//    looping transport; THIS file poses them, every frame, through the same mixer.
+//  · The STATE `{on, at, from, n}` is runtime and SHARED: one `behavior` message per
+//    trigger, latest-wins on a sessionNow() stamp, every pose a pure function of it — so a
+//    door swings in phase on every peer with no stream. A late joiner gets it as an additive
+//    `behaviorState` on the objectfile message (animatedImports' behaviorFields). It is
+//    never saved and never undone: a scene saved with a door open reopens shut.
+//  · THE USER'S RULE: nothing moves in EDIT. A peer in Edit renders the rest pose whatever
+//    the shared state says (gameFeelActive is LOCAL), so authoring never sees a door swing,
+//    and an ambient loop only runs in Interact/Play. The Animation panel can PREVIEW a clip
+//    in Edit — local, never sent, back to rest at the end.
+//
+// TRIGGERS (Interact/Play only): click — every click path (the desktop Interact click, the
+// Play tap, the VR laser/trigger and the hold-and-sweep poke) reaches moduleSDK's ONE
+// dispatch, where a core handler is pushed; knock — a VR hand moving into a moving part at
+// >= KNOCK_SPEED (a desktop click still knocks); proximity — the local player within 1.5 m
+// opens on the rising edge, the falling edge closes, a click still toggles.
+//
+// COLLIDERS (`collider: 'follow'`): the frame is a CUSTOM compound collider of slab boxes
+// with the doorway cut out (behaviorCore.frameSlabs), stamped on `userData.physics` at
+// registration on every peer (deterministic from the file, so nothing travels), and each
+// moving node gets its own KINEMATIC box in the live rapier world that follows the node
+// every frame. physics.js skips colliders it does not own (physicsRuntime's contract), and
+// the walker's capsule collides with everything in the world — so an open door lets you
+// through and a shut one stops you. Only while a simulation runs, which is the only time
+// the walker collides with anything at all (charController's tiers, unchanged).
+import * as THREE from 'three';
+import { get } from 'svelte/store';
+import { objectsGroup, globalCamera } from '../stores/sceneStore';
+import { peers } from '../stores/appStore';
+import { sessionNow } from './sessionClock';
+import { gameFeelActive } from './gameFeel';
+import { behaviorOf, behaviorUuids, behaviorRegistry, animatedRecordOf, setBehaviorHooks } from './animatedImports';
+import {
+	normalizeState,
+	restState,
+	stateIsNewer,
+	poseAt,
+	nextState,
+	frameSlabs,
+	boxCorners,
+	defaultSound,
+	PROXIMITY_RADIUS,
+	KNOCK_SPEED
+} from './behaviorCore';
+import { playGameSound } from './gameSfx';
+import { moduleClickHandlers } from './moduleSDK';
+
+/** @type {Map<string, import('./behaviorCore').BehaviorState>} */
+const states = new Map();
+/** @type {Map<string, any>} uuid -> the placed root (re-found when a registration repeats) */
+const roots = new Map();
+/** @type {Map<string, number>} uuid -> when we last looked and found NO root (a deleted item:
+ * the registry keeps it, and a tree search per frame per ghost would be a per-frame cost) */
+const missingAt = new Map();
+/** @type {Map<string, string>} uuid -> the pose last written ("clip@time"), so an idle door costs nothing */
+const lastPose = new Map();
+/** @type {Map<string, any>} uuid -> the action last driven (switching clip stops it) */
+const lastAction = new Map();
+/** @type {Map<string, {clip: string, start: number}>} LOCAL Animation-panel previews */
+const previews = new Map();
+/** @type {Map<string, boolean>} proximity: was the player inside last frame */
+const near = new Map();
+/** @type {Map<string, number>} knock cooldown: uuid -> performance.now() it may fire again */
+const knockReady = new Map();
+/** @type {Map<string, {box: THREE.Box3, at: number}>} world boxes for proximity, refreshed */
+const boxCache = new Map();
+const stats = { triggers: 0, received: 0, stale: 0, poses: 0, sounds: 0, knocks: 0, colliderBuilds: 0 };
+
+/** the leftover after a clip end before a preview hands the pose back */
+const PREVIEW_HOLD = 0.4;
+const KNOCK_COOLDOWN_MS = 800;
+const BOX_REFRESH_MS = 500;
+
+/** @type {((hand: 'left'|'right') => any) | null} */
+let hands = null;
+/** @type {any} */ let physicsRef = null;
+/** @type {any} */ let flowRef = null;
+let started = false;
+
+/* ------------------------------------------------------------------ helpers ------ */
+
+/** the placed root for a uuid (cached, re-validated: an undo re-adds a NEW object) @param {string} uuid */
+function rootOf(uuid) {
+	const cached = roots.get(uuid);
+	if (cached && cached.parent) return cached;
+	const now = performance.now();
+	if (now - (missingAt.get(uuid) ?? -Infinity) < 1000) return null;
+	const found = get(objectsGroup)?.getObjectByProperty('uuid', uuid) ?? null;
+	if (found) {
+		roots.set(uuid, found);
+		missingAt.delete(uuid);
+	} else {
+		roots.delete(uuid);
+		missingAt.set(uuid, now);
+	}
+	return found;
+}
+
+/** the behavior root a clicked mesh belongs to, or null @param {any} mesh */
+export function behaviorRootOf(mesh) {
+	for (let node = mesh; node; node = node.parent) if (node.uuid && behaviorOf(node.uuid)) return node;
+	return null;
+}
+
+/** the nodes a clip animates (the MOVING parts), by the track names @param {any} root @param {any[]} clips */
+function movingNodesOf(root, clips) {
+	/** @type {Set<any>} */
+	const out = new Set();
+	for (const clip of clips) {
+		for (const track of clip?.tracks ?? []) {
+			// a weights-only track (a banner's morph) moves no collider
+			if (track.name.endsWith('.morphTargetInfluences')) continue;
+			const parsed = THREE.PropertyBinding.parseTrackName(track.name);
+			const node = parsed.nodeName ? THREE.PropertyBinding.findNode(root, parsed.nodeName) : null;
+			if (node && node !== root) out.add(node);
+		}
+	}
+	return [...out];
+}
+
+/** the spec's clips as AnimationClips @param {string} uuid */
+function specClips(uuid) {
+	const spec = behaviorOf(uuid);
+	const record = animatedRecordOf(uuid);
+	if (!spec || !record) return [];
+	/** @type {string[]} */
+	const names = spec.closeClip ? [spec.clip, spec.closeClip] : [spec.clip];
+	return names.map((name) => record.actions[name]?.getClip?.()).filter(Boolean);
+}
+
+/**
+ * Write a pose: `clip` at `time` seconds. The action is played, its time SET, and the
+ * mixer updated by 0 — an exact evaluation with no accumulated drift and no loop wrap.
+ * @param {string} uuid @param {string} clip @param {number} time
+ */
+function writePose(uuid, clip, time) {
+	const record = animatedRecordOf(uuid);
+	const action = record?.actions?.[clip];
+	if (!action) return;
+	const dur = action.getClip().duration;
+	const t = Math.min(dur, Math.max(0, time));
+	const key = clip + '@' + t.toFixed(4);
+	if (lastPose.get(uuid) === key) return;
+	const previous = lastAction.get(uuid);
+	if (previous && previous !== action) previous.stop();
+	if (!action.isScheduled() || !action.enabled) {
+		action.reset();
+		action.setLoop(THREE.LoopOnce, 1);
+		action.clampWhenFinished = true;
+		action.play();
+	}
+	action.paused = false;
+	action.time = t;
+	record.mixer.update(0);
+	lastAction.set(uuid, action);
+	lastPose.set(uuid, key);
+	stats.poses++;
+}
+
+/** play the item's sound at the object @param {string} uuid */
+function soundFor(uuid) {
+	const spec = behaviorOf(uuid);
+	const name = spec?.sound ?? (spec ? defaultSound(spec) : null);
+	if (!name) return;
+	const root = rootOf(uuid);
+	const at = root ? root.getWorldPosition(new THREE.Vector3()).toArray() : null;
+	if (playGameSound(name, at)) stats.sounds++;
+}
+
+/* ------------------------------------------------------------------ the state ---- */
+
+/** the current shared state (a copy) @param {string} uuid */
+export function behaviorState(uuid) {
+	const s = states.get(uuid);
+	return s ? { ...s } : null;
+}
+
+/**
+ * TRIGGER: the click, the knock, the proximity edge. Applies locally, sends ONE message,
+ * plays the sound here (every receiver plays its own). `want` forces a direction.
+ * @param {string} uuid @param {boolean} [want] @returns {boolean} did anything change
+ */
+export function triggerBehavior(uuid, want) {
+	const spec = behaviorOf(uuid);
+	const record = animatedRecordOf(uuid);
+	if (!spec || !record) return false;
+	const next = nextState(spec, states.get(uuid) ?? restState(), record.durations, sessionNow(), want);
+	if (!next) return false;
+	states.set(uuid, next);
+	stats.triggers++;
+	soundFor(uuid);
+	/** @type {any} */
+	const peer = get(peers);
+	peer?.send?.({ type: 'behavior', uuid, on: next.on, at: next.at, from: next.from, n: next.n });
+	return true;
+}
+
+/**
+ * Receive side of `behavior` (and of a late joiner's `behaviorState`). Latest wins; a
+ * FRESH remote trigger also sounds here (a stale one — a joiner's history — does not).
+ * @param {any} data @param {{sound?: boolean}} [opts] @returns {boolean} applied
+ */
+export function applyBehaviorState(data, opts = {}) {
+	const uuid = data?.uuid;
+	const state = normalizeState(data);
+	if (typeof uuid !== 'string' || !state) return false;
+	if (!stateIsNewer(states.get(uuid) ?? null, state)) {
+		stats.stale++;
+		return false;
+	}
+	states.set(uuid, state);
+	stats.received++;
+	if (opts.sound !== false && behaviorOf(uuid) && Math.abs(sessionNow() - state.at) < 1500) soundFor(uuid);
+	return true;
+}
+
+/** the wire applier (peerHandler) @param {any} data */
+export function applyRemoteBehavior(data) {
+	return applyBehaviorState(data);
+}
+
+/**
+ * LOCAL preview from the Animation panel / Inspector play button: plays `clip` once and
+ * hands the pose back. Never sent, never saved, works in Edit (that is what it is for).
+ * @param {string} uuid @param {string} [clip]
+ */
+export function previewBehavior(uuid, clip) {
+	const spec = behaviorOf(uuid);
+	const record = animatedRecordOf(uuid);
+	if (!spec || !record) return false;
+	const name = clip && record.actions[clip] ? clip : spec.clip;
+	previews.set(uuid, { clip: name, start: performance.now() });
+	return true;
+}
+
+/** stop a preview at once @param {string} uuid */
+export function stopBehaviorPreview(uuid) {
+	previews.delete(uuid);
+}
+
+/* ------------------------------------------------------------------ colliders ---- */
+
+/** local box of `object`'s meshes in the frame of `frame` (scale removed with it) @param {any} object @param {any} frame @param {(m: any) => boolean} [filter] */
+function boxInFrame(object, frame, filter) {
+	frame.updateWorldMatrix(true, true);
+	const inv = new THREE.Matrix4().copy(frame.matrixWorld).invert();
+	const box = new THREE.Box3();
+	const m = new THREE.Matrix4();
+	const piece = new THREE.Box3();
+	object.traverse((/** @type {any} */ node) => {
+		if (!node.isMesh || !node.geometry) return;
+		if (filter && !filter(node)) return;
+		if (!node.geometry.boundingBox) node.geometry.computeBoundingBox();
+		piece.copy(node.geometry.boundingBox).applyMatrix4(m.multiplyMatrices(inv, node.matrixWorld));
+		box.union(piece);
+	});
+	return box;
+}
+
+/** @param {THREE.Box3} b @returns {number[]} */
+const boxArray = (b) => [b.min.x, b.min.y, b.min.z, b.max.x, b.max.y, b.max.z];
+
+/**
+ * The frame's collider: static meshes' boxes minus the moving parts' REST boxes, as a
+ * custom compound collider on `userData.physics` (local to the root, the customPieces
+ * convention: scale is baked by physics). Never overrides a collider the user chose.
+ * @param {string} uuid
+ */
+function stampFrameCollider(uuid) {
+	const spec = behaviorOf(uuid);
+	const root = rootOf(uuid);
+	if (!spec || spec.collider !== 'follow' || !root) return;
+	if (root.userData.physics?.collider && !root.userData.physics.__behaviorFrame) return;
+	const moving = movingNodesOf(root, specClips(uuid));
+	if (!moving.length) return;
+	const movingSet = new Set();
+	for (const node of moving) node.traverse((/** @type {any} */ n) => movingSet.add(n));
+	/** @type {number[][]} */
+	const statics = [];
+	root.traverse((/** @type {any} */ node) => {
+		if (!node.isMesh || movingSet.has(node)) return;
+		const b = boxInFrame(node, root);
+		if (!b.isEmpty()) statics.push(boxArray(b));
+	});
+	const holes = moving.map((node) => boxArray(boxInFrame(node, root))).filter((b) => b[3] > b[0]);
+	const slabs = frameSlabs(statics, holes).slice(0, 50); // CUSTOM_MAX_FLOATS / 24
+	if (!slabs.length) return;
+	/** @type {number[]} */
+	const verts = [];
+	/** @type {number[][]} */
+	const pieces = [];
+	for (const s of slabs) {
+		pieces.push([verts.length, 24]);
+		verts.push(...boxCorners(s).map((v) => Math.round(v * 1e5) / 1e5));
+	}
+	root.userData.physics = {
+		...(root.userData.physics ?? {}),
+		collider: 'custom',
+		colliderVerts: verts,
+		colliderPieces: pieces,
+		// marks the collider as OURS, so a re-registration may restamp it and a user's own
+		// pick is never overwritten
+		__behaviorFrame: true
+	};
+}
+
+/** @type {{world: any, parts: {uuid: string, node: any, body: any, last?: {pos: THREE.Vector3, quat: THREE.Quaternion}}[]} | null} */
+let built = null;
+
+/** the live rapier world, or null @returns {any} */
+function runtime() {
+	try {
+		return physicsRef?.physicsRuntime?.() ?? null;
+	} catch {
+		return null;
+	}
+}
+
+/** (re)build a kinematic box per moving node of every follow-item into `rt.world` @param {any} rt */
+function buildPartColliders(rt) {
+	const { world, RAPIER } = rt;
+	built = { world, parts: [] };
+	stats.colliderBuilds++;
+	const pos = new THREE.Vector3();
+	const quat = new THREE.Quaternion();
+	const scale = new THREE.Vector3();
+	for (const uuid of behaviorUuids()) {
+		const spec = behaviorOf(uuid);
+		const root = rootOf(uuid);
+		if (!spec || spec.collider !== 'follow' || !root) continue;
+		for (const node of movingNodesOf(root, specClips(uuid))) {
+			const local = boxInFrame(node, node);
+			if (local.isEmpty()) continue;
+			node.updateWorldMatrix(true, false);
+			node.matrixWorld.decompose(pos, quat, scale);
+			const size = local.getSize(new THREE.Vector3()).multiply(scale).multiplyScalar(0.5);
+			const centre = local.getCenter(new THREE.Vector3()).multiply(scale);
+			try {
+				const body = world.createRigidBody(
+					RAPIER.RigidBodyDesc.kinematicPositionBased()
+						.setTranslation(pos.x, pos.y, pos.z)
+						.setRotation({ x: quat.x, y: quat.y, z: quat.z, w: quat.w })
+				);
+				world.createCollider(
+					RAPIER.ColliderDesc.cuboid(Math.max(0.01, size.x), Math.max(0.01, size.y), Math.max(0.01, size.z)).setTranslation(
+						centre.x,
+						centre.y,
+						centre.z
+					),
+					body
+				);
+				built.parts.push({ uuid, node, body });
+			} catch (error) {
+				console.log('behavior collider failed', error);
+			}
+		}
+	}
+}
+
+// per-frame temps (no allocation in the hot path — MODULES.md's performance rule)
+const _pos = new THREE.Vector3();
+const _quat = new THREE.Quaternion();
+const _scale = new THREE.Vector3();
+/** set when a registration (or a removal) changes what must be followed */
+let collidersDirty = true;
+
+/** one frame of the followed colliders */
+function tickColliders() {
+	const rt = runtime();
+	if (!rt) {
+		built = null; // the world is gone with its bodies (stopSimulation frees it)
+		return;
+	}
+	let stale = !built || built.world !== rt.world || collidersDirty;
+	if (!stale && built) for (const part of built.parts) if (!part.node.parent || !rootOf(part.uuid)) stale = true;
+	let moved = false;
+	if (stale) {
+		collidersDirty = false;
+		if (built && built.world === rt.world)
+			for (const part of built.parts) {
+				try {
+					rt.world.removeRigidBody(part.body);
+				} catch {}
+			}
+		buildPartColliders(rt);
+	}
+	if (!built) return;
+	for (const part of built.parts) {
+		part.node.updateWorldMatrix(true, false);
+		part.node.matrixWorld.decompose(_pos, _quat, _scale);
+		// a part that has not moved since the last write costs nothing
+		if (part.last && _pos.equals(part.last.pos) && _quat.equals(part.last.quat)) continue;
+		part.last ??= { pos: new THREE.Vector3(), quat: new THREE.Quaternion() };
+		part.last.pos.copy(_pos);
+		part.last.quat.copy(_quat);
+		try {
+			// rapier copies vectors in: THREE's own {x,y,z(,w)} shapes are accepted as-is
+			part.body.setNextKinematicTranslation(_pos);
+			part.body.setNextKinematicRotation(_quat);
+			// the walker queries colliders between steps: teleport too, so a query this frame
+			// already sees the leaf where it is drawn
+			part.body.setTranslation(_pos, true);
+			part.body.setRotation(_quat, true);
+			moved = true;
+		} catch {}
+	}
+	if (moved) {
+		try {
+			rt.world.propagateModifiedBodyPositionsToColliders?.();
+		} catch {}
+	}
+}
+
+/* ------------------------------------------------------------------ triggers ----- */
+
+const _player = new THREE.Vector3();
+
+/** world box of a root, cached briefly (proximity) @param {string} uuid @param {any} root */
+function worldBox(uuid, root) {
+	const now = performance.now();
+	const cached = boxCache.get(uuid);
+	if (cached && now - cached.at < BOX_REFRESH_MS) return cached.box;
+	const box = new THREE.Box3().setFromObject(root);
+	boxCache.set(uuid, { box, at: now });
+	return box;
+}
+
+/** hand samples, reused every frame: `now` is this frame's, `prev` the one before */
+const handSamples = {
+	left: { now: { pos: new THREE.Vector3(), t: 0, ok: false }, prev: { pos: new THREE.Vector3(), t: 0, ok: false } },
+	right: { now: { pos: new THREE.Vector3(), t: 0, ok: false }, prev: { pos: new THREE.Vector3(), t: 0, ok: false } }
+};
+const _knockBox = new THREE.Box3();
+const HAND_LIST = [handSamples.left, handSamples.right];
+const HAND_NAMES = /** @type {const} */ (['left', 'right']);
+
+/** one frame of the proximity and knock triggers @param {string} uuid @param {any} spec @param {any} root */
+function tickTriggers(uuid, spec, root) {
+	if (spec.trigger === 'proximity') {
+		const camera = /** @type {any} */ (get(globalCamera));
+		if (!camera) return;
+		camera.getWorldPosition(_player);
+		const inside = worldBox(uuid, root).distanceToPoint(_player) <= PROXIMITY_RADIUS;
+		const was = near.get(uuid) ?? false;
+		if (inside !== was) {
+			near.set(uuid, inside);
+			triggerBehavior(uuid, spec.type === 'oneshot' ? undefined : inside);
+		}
+		return;
+	}
+	if (spec.trigger === 'knock' && hands) {
+		const now = performance.now();
+		if ((knockReady.get(uuid) ?? 0) > now) return;
+		_knockBox.copy(worldBox(uuid, root)).expandByScalar(0.05);
+		for (const sample of HAND_LIST) {
+			const { now: cur, prev } = sample;
+			if (!cur.ok || !prev.ok || cur.t <= prev.t) continue;
+			const speed = (cur.pos.distanceTo(prev.pos) / (cur.t - prev.t)) * 1000;
+			// the ENTRY edge: inside now, outside last frame, moving fast enough
+			if (_knockBox.containsPoint(cur.pos) && !_knockBox.containsPoint(prev.pos) && speed >= KNOCK_SPEED) {
+				knockReady.set(uuid, now + KNOCK_COOLDOWN_MS);
+				stats.knocks++;
+				triggerBehavior(uuid);
+				return;
+			}
+		}
+	}
+}
+
+/** this frame's hand poses (the previous frame's become `prev`) — no allocation */
+function sampleHands() {
+	if (!hands) return;
+	const t = performance.now();
+	for (const hand of HAND_NAMES) {
+		const sample = handSamples[hand];
+		sample.prev.pos.copy(sample.now.pos);
+		sample.prev.t = sample.now.t;
+		sample.prev.ok = sample.now.ok;
+		const snap = hands(hand);
+		sample.now.ok = !!snap?.position;
+		if (sample.now.ok) {
+			sample.now.pos.fromArray(snap.position);
+			sample.now.t = t;
+		}
+	}
+}
+
+/* ------------------------------------------------------------------ the frame ---- */
+
+/** Per frame from Scene's loop (beside tickAnimatedMixers). Cheap when nothing moves. */
+export function tickPackBehaviors() {
+	const registry = behaviorRegistry();
+	if (!registry.size) {
+		if (built) built = null;
+		return;
+	}
+	const active = gameFeelActive();
+	const now = sessionNow();
+	if (active && hands) sampleHands();
+	for (const [uuid, spec] of registry) {
+		const record = animatedRecordOf(uuid);
+		const root = rootOf(uuid);
+		if (!spec || !record || !root) continue;
+		if (active && spec.trigger !== 'click') tickTriggers(uuid, spec, root);
+		if (!active) near.delete(uuid);
+		const preview = previews.get(uuid);
+		if (preview) {
+			const dur = record.durations[preview.clip] ?? 1;
+			const t = (performance.now() - preview.start) / 1000;
+			if (t <= dur + PREVIEW_HOLD) {
+				writePose(uuid, preview.clip, t);
+				continue;
+			}
+			previews.delete(uuid);
+		}
+		const pose = poseAt(spec, states.get(uuid) ?? restState(), record.durations, now, active);
+		writePose(uuid, pose.clip, pose.time);
+	}
+	if (physicsRef) tickColliders();
+}
+
+/* ------------------------------------------------------------------ the click ---- */
+
+/**
+ * The core click handler in moduleSDK's ONE dispatch (pushed raw, so it hears every mode;
+ * it gates itself). Consumes the click it acts on, then pulses the object's On Click so an
+ * author can still hang a sound or a counter on the door.
+ * @param {any} mesh @returns {boolean}
+ */
+function onBehaviorClick(mesh) {
+	if (!gameFeelActive()) return false;
+	const root = behaviorRootOf(mesh);
+	if (!root) return false;
+	const spec = behaviorOf(root.uuid);
+	if (!spec || (spec.type === 'loop' && spec.autoplay)) return false;
+	// proximity doors still answer a click (a toggle by hand); knock doors take a desktop
+	// click as the knock (a desktop has no hands)
+	if (!triggerBehavior(root.uuid)) return false;
+	try {
+		flowRef?.fireObjectClick?.(root.uuid);
+	} catch {}
+	return true;
+}
+
+/**
+ * Start once (Scene.svelte, beside the knock). `hands` is vrControls.handSnapshot, passed
+ * in so this file never imports vrControls.
+ * @param {{hands?: (hand: 'left'|'right') => any}} [options]
+ */
+export function startPackBehaviors(options = {}) {
+	if (options.hands) hands = options.hands;
+	if (started) return;
+	started = true;
+	setBehaviorHooks({
+		state: (uuid) => behaviorState(uuid),
+		apply: (uuid, state) => applyBehaviorState({ ...state, uuid }, { sound: false }),
+		preview: (uuid, clip) => previewBehavior(uuid, clip),
+		registered: (uuid) => {
+			roots.delete(uuid);
+			missingAt.delete(uuid);
+			lastPose.delete(uuid);
+			lastAction.delete(uuid);
+			const record = animatedRecordOf(uuid);
+			const spec = behaviorOf(uuid);
+			// the rest pose NOW, so the frame collider is measured with the part shut
+			if (record && spec) writePose(uuid, spec.clip, 0);
+			stampFrameCollider(uuid);
+			collidersDirty = true; // a new part to follow: rebuild against the live world
+		}
+	});
+	// a registration that happened before we started (a restore during boot)
+	for (const uuid of behaviorUuids()) stampFrameCollider(uuid);
+	moduleClickHandlers.push(onBehaviorClick);
+	// primed (physics and flowRuntime sit in history's cycle family)
+	import('./physics').then((m) => (physicsRef = m)).catch(() => {});
+	import('./flowRuntime').then((m) => (flowRef = m)).catch(() => {});
+}
+
+/** the suites' view @returns {any} */
+export function packBehaviorDebug() {
+	return {
+		...stats,
+		items: behaviorUuids().map((uuid) => ({
+			uuid,
+			spec: behaviorOf(uuid),
+			state: behaviorState(uuid),
+			pose: lastPose.get(uuid) ?? null,
+			preview: previews.has(uuid),
+			physics: rootOf(uuid)?.userData?.physics ?? null
+		})),
+		colliders: built ? built.parts.map((p) => ({ uuid: p.uuid, node: p.node.name, handle: p.body.handle })) : []
+	};
+}
diff --git a/src/lib/packs.js b/src/lib/packs.js
index 2ea82efe..34db621e 100644
--- a/src/lib/packs.js
+++ b/src/lib/packs.js
@@ -2,6 +2,7 @@ import { writable, get } from 'svelte/store';
 import { contentBase } from './contentBase';
 import { addItemFromBytes, createFolder, explorerFolders } from './explorer';
 import { safeStorage } from './safeStorage';
+import { normalizeBehavior } from './behaviorCore';
 
 // N6 (roadmap 7 / ship-qa D1): object packs. Two sources, one normalized model:
 //  - DEFAULT packs from static/libraryList.json (bundled today; the model bytes
@@ -288,7 +289,10 @@ export async function loadPackItems(pack) {
 					glbUrl: /^https?:\/\//.test(glb) ? glb : `${pack.base}/${o.name}/glTF-Binary/${glb}`,
 					thumbs: thumbCandidates(pack, o),
 					resolvedThumb: cachedThumb(pack.name, o.name), // P2: skip re-probing if known
-					packName: pack.name
+					packName: pack.name,
+					// 33 P2: a functional item (door, lid, lever, fan) — null for a plain prop.
+					// Normalized HERE so the Explorer badge and the placement agree on one spec.
+					behavior: normalizeBehavior(o.behavior)
 				};
 			});
 	}
diff --git a/src/lib/peerHandler.svelte.js b/src/lib/peerHandler.svelte.js
index 6001d0ed..0f0d2a5f 100644
--- a/src/lib/peerHandler.svelte.js
+++ b/src/lib/peerHandler.svelte.js
@@ -95,6 +95,7 @@ import { applySessionProposal, applySessionAnswer, deferUntilShareChoice, localS
 import { applyRemoteGeometry } from '$lib/geometryEdit';
 import { applyLightTarget } from '$lib/lightParams';
 import { applyObjectFile } from '$lib/animatedImports';
+import { applyRemoteBehavior } from '$lib/packBehavior';
 import { lockedObjects, selectedObject, peerHands, objectsGroup, pokeScene } from '../stores/sceneStore';
 import { addMessage, peers, userdata, pendingApprovals, waitingForApproval, showToast } from '../stores/appStore';
 import { get } from 'svelte/store';
@@ -936,6 +937,10 @@ export class PeerConnection {
 					});
 				} else if(data.type == 'objectfile') {
 					applyObjectFile(data);
+				} else if(data.type == 'behavior') {
+					// 33 P2: a functional pack item was triggered (a door, a lid, a lever).
+					// Latest-wins on the sessionNow stamp; every peer derives the pose itself.
+					applyRemoteBehavior(data);
 				} else if(data.type == 'object') {
 					createObject(data, data.uuids, data.override, data.groupuuid, data.pos, data.rot, data.scale);
 				} else if(data.type == 'objectParameters') {
diff --git a/src/lib/peerScenes.js b/src/lib/peerScenes.js
index edc0e033..73c66a19 100644
--- a/src/lib/peerScenes.js
+++ b/src/lib/peerScenes.js
@@ -615,7 +615,7 @@ export function roomsOfSession(map, mine, host) {
 export const ROOM_SCOPED = new Set([
 	// object lifecycle & geometry
 	'create', 'light', 'group', 'object', 'objectfile', 'duplicate', 'delete', 'name',
-	'move', 'throw', 'hit', 'simulate', 'color', 'objectParameters', 'geometry', 'lighttarget',
+	'move', 'throw', 'hit', 'behavior', 'simulate', 'color', 'objectParameters', 'geometry', 'lighttarget',
 	'verts', 'meshgeo', 'uvpaint', 'uvpaintend', 'splineedit', 'drawlive', 'drawend',
 	'clearscene', 'loading',
 	// flow
diff --git a/src/lib/vrGameInput.js b/src/lib/vrGameInput.js
index aa8c0e9e..dd6b4f30 100644
--- a/src/lib/vrGameInput.js
+++ b/src/lib/vrGameInput.js
@@ -75,7 +75,8 @@ export function clickTargetOf(hit) {
 	const top = topLevelObjectOf(mesh);
 	if (!top) return null;
 	if (deviceBetween(mesh, top)) return { kind: 'object', key: mesh.uuid, mesh, top, point: hit.point, distance: hit.distance ?? 0, group: null };
-	if (top.userData?.clickable === true || objectHasOnClick(top.uuid))
+	// 33 P2: a functional pack item (a door, a lever) is pressed like a button
+	if (top.userData?.clickable === true || top.userData?.behavior || objectHasOnClick(top.uuid))
 		return { kind: 'object', key: top.uuid, mesh, top, point: hit.point, distance: hit.distance ?? 0, group: null };
 	return null;
 }
diff --git a/src/lib/wireValidate.js b/src/lib/wireValidate.js
index 93fb3a4a..bd66ffc9 100644
--- a/src/lib/wireValidate.js
+++ b/src/lib/wireValidate.js
@@ -142,6 +142,15 @@ export const VALIDATORS = {
 	triggers: (d) => !!d.triggers && typeof d.triggers === 'object',
 	peervars: (d) => typeof d.peerId === 'string',
 	playmode: (d) => typeof d.peerId === 'string',
+	// 33 P2: a functional pack item was triggered (a door opened). The state is evaluated
+	// as a POSE every frame, so a non-finite stamp would put a door at NaN forever.
+	behavior: (d) =>
+		isUuid(d.uuid) &&
+		typeof d.on === 'boolean' &&
+		Number.isFinite(d.at) &&
+		Number.isFinite(d.from) &&
+		Number.isInteger(d.n) &&
+		d.n >= 0,
 	camera: (d) => typeof d.peerId === 'string' && isVec3(d.position) && isFiniteArray(d.rotation, 3)
 };
 
diff --git a/tests/e2e/animated-models.test.cjs b/tests/e2e/animated-models.test.cjs
index 1d3d008a..76fb7c05 100644
--- a/tests/e2e/animated-models.test.cjs
+++ b/tests/e2e/animated-models.test.cjs
@@ -1,4 +1,5 @@
-// Phase 51: animated model import — clips play on the synced clock everywhere,
+// Phase 51: animated model import — clips play on the synced clock everywhere (33 P2: once
+// PLAYED — placement no longer autoplays),
 // raw-bytes replication (incl. late joiners), pause/clip state syncs, undo works.
 const h = require('./helpers.cjs');
 
@@ -61,7 +62,15 @@ h.run(async () => {
 	await h.eventually(() => animState(A.page), (s) => s?.clips?.includes('slide'), 'animated import registered on A');
 	const { uuid } = await animState(A.page);
 
-	// the clip actually animates on A
+	// 33 P2: NOTHING AUTOPLAYS on placement any more — the clip is selected, not playing,
+	// and the model stands still until somebody presses play
+	h.check((await animState(A.page)).playing === false, '33: the import is NOT playing on placement');
+	const s1 = await moverX(A.page, uuid);
+	await A.page.waitForTimeout(400);
+	h.check(s1 === (await moverX(A.page, uuid)), '33: ...and the model stands still');
+	await A.page.evaluate((uuid) => window.__stores.animatedImports.setAnimationState(uuid, { playing: true }), uuid);
+
+	// the clip actually animates on A once played
 	const a1 = await moverX(A.page, uuid);
 	await A.page.waitForTimeout(400);
 	const a2 = await moverX(A.page, uuid);
diff --git a/tests/e2e/animation-persist.test.cjs b/tests/e2e/animation-persist.test.cjs
index 8c4fd492..2add4226 100644
--- a/tests/e2e/animation-persist.test.cjs
+++ b/tests/e2e/animation-persist.test.cjs
@@ -75,7 +75,10 @@ h.run(async () => {
 	// import it, and author a movement track on a second object
 	await A.page.evaluate(async (bytes) => {
 		const w = window.__stores;
-		await w.fileHandler.importFile(new File([new Uint8Array(bytes)], 'rig.glb'), 'Rig');
+		const rig = await w.fileHandler.importFile(new File([new Uint8Array(bytes)], 'rig.glb'), 'Rig');
+		// 33 P2: placement no longer autoplays — press play, as a user would, so the save
+		// below carries a PLAYING transport (what this suite round-trips)
+		w.animatedImports.setAnimationState(rig, { playing: true });
 		await new Promise((r) => setTimeout(r, 600));
 		w.commandsHandler.sceneCommand('/create Box 1 1 1');
 		await new Promise((r) => setTimeout(r, 300));
@@ -182,12 +185,17 @@ h.run(async () => {
 			if (m?.parameter === 'animation') window.__sent.push(m.playing);
 			return orig(m);
 		};
+		// 33 P2: an import no longer autoplays, so the first press PLAYS and the second pauses
+		document.querySelector('#clip-play')?.click();
+		await new Promise((r) => setTimeout(r, 400));
+		const mid = await new Promise((r) => w.animatedImports.animatedObjects.subscribe(r)());
 		document.querySelector('#clip-play')?.click();
 		await new Promise((r) => setTimeout(r, 400));
 		const imported = await new Promise((r) => w.animatedImports.animatedObjects.subscribe(r)());
-		return { sent: window.__sent.slice(), playing: Object.values(imported)[0]?.playing };
+		return { sent: window.__sent.slice(), started: Object.values(mid)[0]?.playing, playing: Object.values(imported)[0]?.playing };
 	});
-	h.check(picked.sent.length >= 1, `the clip transport replicates (${picked.sent.length} message(s))`);
+	h.check(picked.sent.length >= 2, `the clip transport replicates (${picked.sent.length} message(s))`);
+	h.check(picked.started === true, `the first press plays it (playing ${picked.started})`);
 	h.check(picked.playing === false, `and pausing actually paused it (playing ${picked.playing})`);
 
 	await h.finish(browser);
diff --git a/tests/e2e/fixtures/build-test-door.mjs b/tests/e2e/fixtures/build-test-door.mjs
new file mode 100644
index 00000000..8249bd0f
--- /dev/null
+++ b/tests/e2e/fixtures/build-test-door.mjs
@@ -0,0 +1,91 @@
+// Builds tests/e2e/fixtures/test-door.glb: the contract-P2 test door the pack-behavior suite places.
+// A FRAME (one mesh, two posts + a lintel, so the collider has to cut the doorway out of it)
+// and a LEAF node whose origin is the hinge (vertices offset to +x), with three clips:
+// `idle` (static, FIRST - what anim-kit ships), `open` (0 -> -90 deg about Y over 1 s) and
+// `close` (the reverse). The doorway is x in [-0.5, 0.5], y in [0, 2], z in [-0.05, 0.05].
+//
+// Run (gltf-transform is not a core dependency; any checkout of it works):
+//   GLTF_TRANSFORM=/path/to/node_modules/@gltf-transform/core node tests/e2e/fixtures/build-test-door.mjs
+import { writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const corePath = process.env.GLTF_TRANSFORM;
+if (!corePath) throw new Error('set GLTF_TRANSFORM to @gltf-transform/core');
+const { Document, NodeIO } = await import(join(corePath, 'dist/index.js'));
+
+const doc = new Document();
+const buffer = doc.createBuffer();
+
+/** axis-aligned boxes merged into one primitive: [[minx,miny,minz,maxx,maxy,maxz], ...] */
+function boxesPrim(boxes, material) {
+	const pos = [];
+	const nrm = [];
+	const idx = [];
+	for (const [x0, y0, z0, x1, y1, z1] of boxes) {
+		const faces = [
+			[[1, 0, 0], [[x1, y0, z0], [x1, y1, z0], [x1, y1, z1], [x1, y0, z1]]],
+			[[-1, 0, 0], [[x0, y0, z1], [x0, y1, z1], [x0, y1, z0], [x0, y0, z0]]],
+			[[0, 1, 0], [[x0, y1, z0], [x0, y1, z1], [x1, y1, z1], [x1, y1, z0]]],
+			[[0, -1, 0], [[x0, y0, z1], [x0, y0, z0], [x1, y0, z0], [x1, y0, z1]]],
+			[[0, 0, 1], [[x0, y0, z1], [x1, y0, z1], [x1, y1, z1], [x0, y1, z1]]],
+			[[0, 0, -1], [[x1, y0, z0], [x0, y0, z0], [x0, y1, z0], [x1, y1, z0]]]
+		];
+		for (const [n, quad] of faces) {
+			const base = pos.length / 3;
+			for (const v of quad) {
+				pos.push(...v);
+				nrm.push(...n);
+			}
+			idx.push(base, base + 1, base + 2, base, base + 2, base + 3);
+		}
+	}
+	const prim = doc
+		.createPrimitive()
+		.setAttribute('POSITION', doc.createAccessor().setType('VEC3').setArray(new Float32Array(pos)).setBuffer(buffer))
+		.setAttribute('NORMAL', doc.createAccessor().setType('VEC3').setArray(new Float32Array(nrm)).setBuffer(buffer))
+		.setIndices(doc.createAccessor().setType('SCALAR').setArray(new Uint16Array(idx)).setBuffer(buffer))
+		.setMaterial(material);
+	return prim;
+}
+
+const wood = doc.createMaterial('Wood').setBaseColorFactor([0.55, 0.36, 0.2, 1]).setRoughnessFactor(0.8);
+const stone = doc.createMaterial('Stone').setBaseColorFactor([0.6, 0.6, 0.62, 1]).setRoughnessFactor(0.9);
+
+const frameMesh = doc.createMesh('Frame').addPrimitive(
+	boxesPrim(
+		[
+			[-0.65, 0, -0.1, -0.5, 2.15, 0.1], // left post
+			[0.5, 0, -0.1, 0.65, 2.15, 0.1], // right post
+			[-0.5, 2.0, -0.1, 0.5, 2.15, 0.1] // lintel
+		],
+		stone
+	)
+);
+const leafMesh = doc.createMesh('Leaf').addPrimitive(boxesPrim([[0.02, 0.01, -0.04, 0.98, 1.98, 0.04]], wood));
+
+const frame = doc.createNode('Frame').setMesh(frameMesh);
+const leaf = doc.createNode('Leaf').setMesh(leafMesh).setTranslation([-0.5, 0, 0]);
+const root = doc.createNode('TestDoor').addChild(frame).addChild(leaf);
+doc.createScene('Scene').addChild(root);
+
+/** a rotation clip about Y on the leaf @param {string} name @param {number[]} times @param {number[]} degs */
+function yClip(name, times, degs) {
+	const quats = [];
+	for (const d of degs) {
+		const h = (d * Math.PI) / 360;
+		quats.push(0, Math.sin(h), 0, Math.cos(h));
+	}
+	const input = doc.createAccessor().setType('SCALAR').setArray(new Float32Array(times)).setBuffer(buffer);
+	const output = doc.createAccessor().setType('VEC4').setArray(new Float32Array(quats)).setBuffer(buffer);
+	const sampler = doc.createAnimationSampler().setInput(input).setOutput(output).setInterpolation('LINEAR');
+	const channel = doc.createAnimationChannel().setTargetNode(leaf).setTargetPath('rotation').setSampler(sampler);
+	doc.createAnimation(name).addSampler(sampler).addChannel(channel);
+}
+yClip('idle', [0, 1], [0, 0]);
+yClip('open', [0, 1], [0, -90]);
+yClip('close', [0, 1], [-90, 0]);
+
+const out = join(dirname(fileURLToPath(import.meta.url)), 'test-door.glb');
+writeFileSync(out, await new NodeIO().writeBinary(doc));
+console.log('wrote', out);
diff --git a/tests/e2e/fixtures/test-door.glb b/tests/e2e/fixtures/test-door.glb
new file mode 100644
index 0000000000000000000000000000000000000000..2eafd06186ca541484d6a35b1466a935ab248650
GIT binary patch
literal 5440
zcmcgw-EtH~6h0!NL`6kGMa4KMDlY5%?ChU}Bm|<dLSm5=UQk?2HnYi8?apk?PEbs3
z6%XJ8sJHqWsk{JQbL}&DZI$2Y>E8L>tsqEOZ8Q1$^mo4V)6-Mz^fs4|5z)dKqMv7o
zzTH?~+t-}o(2cbAzP97~Zs<fosI|2nm|ort9e>yj!v5^NTGg)VT1C6(hC?s#VPWF$
zQAKk)9d|ek!lBl_v#&+>2QJob-&nF>+zI-Fz<2#<Q^2-i)*0OM;jUp;w7&BrcInl6
zt;M5JH|(ZSGmVN_HEf+n%eLx`nq|~0desn!t{b(MZWwjLybA^oQtn(Xq0lQp%eHLo
zb-QkO+jD==+ImIXx*xgg-L6Q1KB_!!2vgV$Gex(tw79x>t28IpI46eQgrJl@W3s*@
z5n9Oi6h70arz9SsXl5-bTB|AQVYKvyRcqF*icu{<dR4bXX<IErw_BEOS>vK%&5&!h
zZMN#RQLmxOsChgZje4zV+D(%SSw@o%49)Zeh2*fNupPCKNpp{T+epI2Q`!frK1Fe@
zv{Nz;rjRvLRh`l&8M^o^9$9ZKcUGQEaP1i=Za!7T&E_am(D?Ni*QEGfiEF*;`a99C
z);1a@pL4u;Hlonm#tV}hFml2jeh*u<R$aU~CXgk&6`$DzU3$C4^`Efa)bTPE&ee9i
zA%Xv*#<W}V>?u0K)RWZ6v>;TqY&LM5_*6KN8+uMJw(y-k-y7ct!8SU7uod2PBd6E%
zI=6zoon0R{3|~-N&d^;7dO^7Cbi_4<yTi8e(!hI8ubLI^-cW5&HhQ%=;(SOK8xd}#
z$MnJM;y2MnYb0WFhr4bjpyiMQLqwt1_ag6}Ty-K8erqq{Klioo);Cr*SJu}=->j|Q
zy1BTDCK(||0XK(u=f=qbT+uv#+ryoUt{L4;1-9xs-J^Q~sq$o(d&1o~_GG~ma_d7+
zX?T4E4)sMf5r0ASoJf2!@I8%cRdi6rI}qf!Fq`f$x*p);1J~iM*V_(VzS?yZm0df&
zhmHYF#=p1S<LnNd{-B2s6Y&Y+`GY+iBlL8z7m3FPM}h<n0;NP-U0J(<>zJ84yN>U>
zvJWMbsDwIEP$=qv)DIj!zv!_j4hdCHMGy=ixm*nns8Z8<Mrt~}U^po`28yfn7^0>A
zxAY*x!wx<yGj-cw1gTODWunHT+1X$4O?qu*4PU5q$kU$>A07}rnCE9X4uAXg<iZqu
zE^p8KV4uOe-HVE!aq-M{j7$DW_(9%Y@)z(#CtJiZWcd>uPbt5pIQSDht6$(Eh7_*s
zRctEWN%)-P&+|xp>|5~^@FZ_B6USVPx4<Ly2>h_9Kf$y4jB(5=Z+V`1w#fGh_~#Rz
zq_0vq;>zNZCxZi1{EUm7upNftpM)Re?Rk^bS;hl<9%D@@{shnJFU1QyY!#miVXu6v
zxRkxXnP1vZ!smEB6`Qh`xLD(Un24A44|e6^E$~P^0%xs?zknxoXImZ*xZf0i!5#(+
z`ThZxvLDxk$rO%wv$*8R<E)kW8Rus;4wF2T;?SAJu~F$P<AFVov8EJ%22bfP#S1*J
zlKO?c@~z@h_6nbu_LJ~AW=X}ScqA^?m_zXt@FZ_+%R|JRi+7AG9;rv*?2~^opN#Pk
z`Bpr6dzH5w{v7fDvmB%6={UVWCorF&7wIKBNi&#d=w*6^UZqo*Ptj}iI=w-sF`uS4
z=`A`#XEC3px9J^vm(F26NAJ=5^Z}j6e4aj}S^9`H%o<&wkLeS-i1{LYN}ti^bP4k%
z`hqHSnW~tp^d;$JkcrtOi)v(39dn%;)T9=*F}LX}x<Yew74uc3c!3t_8s=-XMAzvC
zEn{A$uMyGHiR+ucewv?obm0nq$lJI#iSa)M|M1!*d@gS<c{2FSqu-gEe~fcY#b8|W
zPr?uK_L8T7Cpwurjv>pR;HkLaw-g6|f@k#$T*Q#VmA$~T`AqCnxbmClk$CL8XrJIo
z-WcQY0Ch^|Ge#Lt@kpJ*{;;S&!L#{{apoz*V^2xnO#i#w?(gHa$OZnLPwy|{@hZpl
EFZ5r9g8%>k

literal 0
HcmV?d00001

diff --git a/tests/e2e/game-audio.test.cjs b/tests/e2e/game-audio.test.cjs
index 67d29852..1bcbcb16 100644
--- a/tests/e2e/game-audio.test.cjs
+++ b/tests/e2e/game-audio.test.cjs
@@ -29,11 +29,11 @@ h.run(async () => {
 		for (const name of k.GAME_SOUNDS) out.push(await k.renderGameSound(name));
 		return out;
 	});
-	h.check(renders.length === 20, '1.1 the set holds the 20 contract names (' + renders.length + ')');
+	h.check(renders.length === 25, '1.1 the set holds the 25 contract names (20 + the 33 P2 item sounds) (' + renders.length + ')');
 	const quiet = renders.filter((r) => !r || r.rms < 0.004 || r.peak < 0.02);
 	h.check(quiet.length === 0, '1.2 every name renders energy (quiet: ' + JSON.stringify(quiet.map((r) => r && r.name)) + ')');
 	const distinct = new Set(renders.map((r) => r && Math.round(r.rms * 1e5)));
-	h.check(distinct.size >= 18, '1.3 the sounds are distinct from each other (' + distinct.size + ' distinct levels)');
+	h.check(distinct.size >= 22, '1.3 the sounds are distinct from each other (' + distinct.size + ' distinct levels)');
 	const unknownRender = await page.evaluate(() => window.__stores.gameKit.gameSfx.renderGameSound('nope'));
 	h.check(unknownRender && unknownRender.seconds === -1 && unknownRender.rms === 0, '1.4 an unknown name builds nothing');
 
diff --git a/tests/e2e/pack-behavior.test.cjs b/tests/e2e/pack-behavior.test.cjs
new file mode 100644
index 00000000..4152849b
--- /dev/null
+++ b/tests/e2e/pack-behavior.test.cjs
@@ -0,0 +1,372 @@
+// 33 P2 (contract P2): ANIMATED, FUNCTIONAL PACK ITEMS. A door placed from a pack is STILL
+// (nothing autoplays on placement, on load or in Edit), opens on a click in Interact, its
+// leaf collider follows the swing so the walker capsule passes an open door and is stopped
+// by a shut one, every peer sees the same state (a late joiner too), Edit keeps the closed
+// pose, and the Animation panel previews a clip locally without touching the shared state.
+// The door is tests/e2e/fixtures/test-door.glb (gltf-transform: a one-piece frame + a
+// hinged `Leaf` + idle/open/close clips), served as a routed pack so the Explorer path —
+// badge, double-click place — is the real one.
+const fs = require('fs');
+const path = require('path');
+const h = require('./helpers.cjs');
+
+const DOOR_GLB = fs.readFileSync(path.join(__dirname, 'fixtures', 'test-door.glb'));
+const PACK = 'https://anim-pack.invalid';
+const DOOR_BEHAVIOR = { type: 'door', clip: 'open', closeClip: 'close', trigger: 'click', autoplay: false, sound: 'door', collider: 'follow' };
+
+/** route the test pack: an item list with one door, and its glb @param {any} page */
+async function routePack(page) {
+	await page.route(PACK + '/**', (route) => {
+		const url = route.request().url();
+		if (url.endsWith('/default.json'))
+			return route.fulfill({
+				contentType: 'application/json',
+				body: JSON.stringify([
+					{ name: 'TestDoor', label: 'Test door', variants: { 'glTF-Binary': 'TestDoor.glb' }, behavior: DOOR_BEHAVIOR },
+					{ name: 'PlainCrate', label: 'Plain crate', variants: { 'glTF-Binary': 'TestDoor.glb' } }
+				])
+			});
+		if (url.endsWith('.glb')) return route.fulfill({ contentType: 'model/gltf-binary', body: DOOR_GLB });
+		return route.fulfill({ status: 404, body: '' });
+	});
+}
+
+/** the door's live numbers on a page @param {any} page */
+const doorOf = (page) =>
+	page.evaluate(() => {
+		const s = window.__stores;
+		const dbg = s.packBehavior.packBehaviorDebug();
+		const item = dbg.items[0];
+		if (!item) return null;
+		let root = null;
+		s.objectsGroup.subscribe((g) => (root = g?.getObjectByProperty('uuid', item.uuid)))();
+		const leaf = root?.getObjectByName('Leaf');
+		return {
+			uuid: item.uuid,
+			name: root?.name,
+			state: item.state,
+			spec: item.spec,
+			qy: leaf ? leaf.quaternion.y : null,
+			pos: root ? root.position.toArray() : null,
+			physics: item.physics,
+			colliders: dbg.colliders.length,
+			sounds: dbg.sounds,
+			triggers: dbg.triggers,
+			preview: item.preview
+		};
+	});
+
+const OPEN_QY = -Math.SQRT1_2; // -90 deg about Y
+
+h.run(async () => {
+	const browser = await h.launch();
+	const A = await h.setupPage(browser, 'A');
+	const B = await h.setupPage(browser, 'B');
+	await routePack(A.page);
+	await h.connect(B, A);
+
+	console.log('\n=== 1. the pack row carries the spec; the Explorer badges it ===');
+	await A.page.locator('#explorer-slot').click();
+	await A.page.waitForTimeout(800);
+	await A.page.evaluate((base) => {
+		const s = window.__stores;
+		s.packs.packs.update((list) => [
+			...list.filter((p) => p.name !== 'anim-test'),
+			{ name: 'anim-test', title: 'Anim test', source: 'default', base, listUrl: base + '/default.json', zip: '', attributionUrl: '', sourceUrl: '', copyright: '', license: 'CC0-1.0' }
+		]);
+	}, PACK);
+	await A.page.locator('#packs-folder').dblclick();
+	await A.page.waitForTimeout(300);
+	await A.page.locator('#explorer-list [data-pack="anim-test"]').click();
+	await h.eventually(
+		() => A.page.locator('#explorer-list .explorer-card').count(),
+		(n) => n === 2,
+		'1.1 the routed pack lists its two items'
+	);
+	const badges = await A.page.evaluate(() =>
+		[...document.querySelectorAll('#explorer-list .explorer-card')].map((c) => ({
+			text: c.textContent.trim(),
+			badge: c.querySelector('.explorer-animated')?.getAttribute('data-behavior') ?? null,
+			title: c.querySelector('.explorer-animated')?.getAttribute('title') ?? ''
+		}))
+	);
+	const doorCard = badges.find((b) => /TestDoor/.test(b.text));
+	const crateCard = badges.find((b) => /PlainCrate/.test(b.text));
+	h.check(doorCard?.badge === 'door', '1.2 the door card wears the "animated" badge (' + JSON.stringify(doorCard) + ')');
+	h.check(/opens and closes on a click/.test(doorCard?.title ?? ''), '1.3 the badge says what it does and what sets it off');
+	h.check(crateCard && crateCard.badge === null, '1.4 a plain item has no badge');
+
+	console.log('\n=== 2. placed from the Explorer: still, and nothing plays ===');
+	await A.page.locator('#explorer-list .explorer-card', { hasText: 'TestDoor' }).dblclick();
+	await h.eventually(() => doorOf(A.page), (d) => !!d?.uuid, '2.1 double-click places the door (the real pack path)', 15000);
+	let door = await doorOf(A.page);
+	h.check(door.spec?.type === 'door' && door.spec?.collider === 'follow', '2.2 the placed root carries the spec from the pack row');
+	const animState = await A.page.evaluate((uuid) => {
+		let st = null;
+		window.__stores.animatedImports.animatedObjects.subscribe((m) => (st = m[uuid]))();
+		return st;
+	}, door.uuid);
+	h.check(animState && animState.playing === false, '2.3 the transport is NOT playing after placement (' + JSON.stringify(animState) + ')');
+	const q0 = door.qy;
+	await A.page.waitForTimeout(800);
+	door = await doorOf(A.page);
+	h.check(Math.abs(q0) < 1e-4 && Math.abs(door.qy) < 1e-4, '2.4 the leaf is shut and stays shut (qy ' + q0 + ' -> ' + door.qy + ')');
+	h.check(door.state === null, '2.5 no shared state until something triggers it');
+	await A.page.evaluate((uuid) => {
+		const s = window.__stores;
+		let root = null;
+		s.objectsGroup.subscribe((g) => (root = g?.getObjectByProperty('uuid', uuid)))();
+		root.position.set(0, 0, -3);
+		root.updateMatrixWorld(true);
+		s.peers.subscribe((p) => p.send({ type: 'move', uuid, pos: [0, 0, -3], rot: [0, 0, 0, 'XYZ'], scale: [1, 1, 1] }))();
+	}, door.uuid);
+	await h.eventually(() => doorOf(B.page), (d) => d?.uuid === door.uuid && Math.abs(d.pos[2] + 3) < 1e-3, '2.6 B received the door (objectfile + the move)', 15000);
+	h.check((await doorOf(B.page)).spec?.type === 'door', '2.7 the spec rode the objectfile to B');
+
+	console.log('\n=== 3. the frame collider has the doorway cut out ===');
+	door = await doorOf(A.page);
+	const pieces = door.physics?.colliderPieces?.length ?? 0;
+	h.check(door.physics?.collider === 'custom' && pieces >= 3, '3.1 the frame is a custom compound of ' + pieces + ' slabs');
+	const opening = await A.page.evaluate((uuid) => {
+		const s = window.__stores;
+		let root = null;
+		s.objectsGroup.subscribe((g) => (root = g?.getObjectByProperty('uuid', uuid)))();
+		const v = root.userData.physics.colliderVerts;
+		const bad = [];
+		for (const [start, count] of root.userData.physics.colliderPieces) {
+			let minx = Infinity, maxx = -Infinity, miny = Infinity, maxy = -Infinity;
+			for (let i = start; i < start + count; i += 3) {
+				minx = Math.min(minx, v[i]); maxx = Math.max(maxx, v[i]);
+				miny = Math.min(miny, v[i + 1]); maxy = Math.max(maxy, v[i + 1]);
+			}
+			// anything spanning the doorway's middle below the lintel blocks it
+			if (minx < 0 && maxx > 0 && miny < 1 && maxy > 1) bad.push([minx, maxx, miny, maxy]);
+		}
+		return bad;
+	}, door.uuid);
+	h.check(opening.length === 0, '3.2 no frame slab crosses the doorway (' + JSON.stringify(opening) + ')');
+
+	console.log('\n=== 4. Edit: a click selects, never opens ===');
+	const editClick = await A.page.evaluate((uuid) => {
+		const s = window.__stores;
+		let root = null;
+		s.objectsGroup.subscribe((g) => (root = g?.getObjectByProperty('uuid', uuid)))();
+		return s.moduleSDK.runClickHandlers(root.getObjectByName('Leaf'), 'edit');
+	}, door.uuid);
+	h.check(editClick === false && (await doorOf(A.page)).state === null, '4.1 the click handler stands down in Edit');
+
+	console.log('\n=== 5. Interact: a REAL click opens it, with its sound ===');
+	await A.page.evaluate(() => window.__stores.objectActions.setEditorMode('interact'));
+	await A.page.evaluate(() => window.__stores.objectActions.deselectObject?.());
+	await A.page.waitForTimeout(300);
+	const pt = await h.projectPoint(A.page, [0.2, 1.2, -3]);
+	const under = await A.page.evaluate(({ x, y }) => document.elementFromPoint(x, y)?.tagName, pt);
+	h.check(under === 'CANVAS', '5.1 the aim point is the viewport (' + under + ')');
+	// once open, the leaf swings OUT of that point: later toggles aim at the right POST,
+	// which belongs to the same functional root
+	const framePt = await h.projectPoint(A.page, [0.58, 1.2, -3]);
+	const soundsBefore = door.sounds;
+	await A.page.mouse.click(pt.x, pt.y);
+	await h.eventually(() => doorOf(A.page), (d) => d?.state?.on === true, '5.2 the click opened it (state on)');
+	await h.eventually(() => doorOf(A.page), (d) => Math.abs(d.qy - OPEN_QY) < 0.01, '5.3 the leaf swung to 90 degrees on A');
+	h.check((await doorOf(A.page)).sounds > soundsBefore, '5.4 the door sound played');
+
+	console.log('\n=== 6. B sees it open (in Interact) and shut (in Edit) ===');
+	await h.eventually(() => doorOf(B.page), (d) => d?.state?.on === true, '6.1 the state reached B');
+	await B.page.waitForTimeout(1300);
+	h.check(Math.abs((await doorOf(B.page)).qy) < 1e-4, '6.2 B in EDIT renders the closed pose (the rule)');
+	await B.page.evaluate(() => window.__stores.objectActions.setEditorMode('interact'));
+	await h.eventually(() => doorOf(B.page), (d) => Math.abs(d.qy - OPEN_QY) < 0.01, '6.3 B in Interact shows it open');
+
+	console.log('\n=== 7. the leaf collider follows: open passes, shut stops ===');
+	await A.page.evaluate(() => window.__stores.physics.toggleSimulation());
+	await h.eventually(() => A.page.evaluate(() => !!window.__stores.physics.physicsRuntime()), (v) => v, '7.0 a simulation runs on A', 15000);
+	await A.page.waitForTimeout(400);
+	/** walk the capsule from in front of the door straight through the doorway */
+	const walk = () =>
+		A.page.evaluate(() => {
+			const cc = window.__stores.charController;
+			cc.resetWalker();
+			let p = { x: 0, y: 0.05, z: -1.4 };
+			let source = '';
+			for (let i = 0; i < 90; i++) {
+				const r = cc.resolveWalk(p, 1.7, 1 / 60, { dx: 0, dz: -0.05 }, { gravity: false });
+				p = { x: p.x + r.dx, y: r.feet, z: p.z + r.dz };
+				source = r.source;
+			}
+			return { z: p.z, source };
+		});
+	h.check((await doorOf(A.page)).colliders === 1, '7.1 one kinematic leaf collider follows the Leaf node');
+	// charController primes its physics import LAZILY on the first call, so the very first
+	// walk resolves on the plane tier — prime it, then measure
+	await walk();
+	await A.page.waitForTimeout(300);
+	let w = await walk();
+	h.check(w.source === 'rapier' && w.z < -4, '7.2 OPEN: the capsule walks through the doorway (z ' + w.z.toFixed(2) + ', ' + w.source + ')');
+	await A.page.mouse.click(framePt.x, framePt.y); // shut it — a click on the frame toggles the same root
+	await h.eventually(() => doorOf(A.page), (d) => d?.state?.on === false, '7.3 a second click shuts it');
+	await h.eventually(() => doorOf(A.page), (d) => Math.abs(d.qy) < 0.01, '7.4 the leaf swung back');
+	await A.page.waitForTimeout(200);
+	w = await walk();
+	h.check(w.z > -2.9, '7.5 SHUT: the leaf stops the capsule (z ' + w.z.toFixed(2) + ')');
+	// counterfactual: the whole-door box (no doorway cut) blocks even an OPEN door
+	await A.page.mouse.click(framePt.x, framePt.y);
+	await h.eventually(() => doorOf(A.page), (d) => Math.abs(d.qy - OPEN_QY) < 0.01, '7.6 reopened');
+	await A.page.evaluate(async (uuid) => {
+		const s = window.__stores;
+		s.physics.stopSimulation();
+		let root = null;
+		s.objectsGroup.subscribe((g) => (root = g?.getObjectByProperty('uuid', uuid)))();
+		root.userData.__savedPhysics = root.userData.physics;
+		delete root.userData.physics;
+		await s.physics.toggleSimulation();
+	}, door.uuid);
+	await A.page.waitForTimeout(600);
+	w = await walk();
+	h.check(w.z > -2.9, '7.7 COUNTERFACTUAL: without the cut frame the open doorway is a wall (z ' + w.z.toFixed(2) + ')');
+	await A.page.evaluate((uuid) => {
+		const s = window.__stores;
+		s.physics.stopSimulation();
+		let root = null;
+		s.objectsGroup.subscribe((g) => (root = g?.getObjectByProperty('uuid', uuid)))();
+		root.userData.physics = root.userData.__savedPhysics;
+		delete root.userData.__savedPhysics;
+	}, door.uuid);
+
+	console.log('\n=== 8. Edit keeps the closed pose; a save carries the spec, never the state ===');
+	await A.page.evaluate(() => window.__stores.objectActions.setEditorMode('edit'));
+	await h.eventually(() => doorOf(A.page), (d) => Math.abs(d.qy) < 1e-4, '8.1 back in Edit the leaf rests shut while the shared state says open');
+	h.check((await doorOf(A.page)).state?.on === true, '8.2 ...and the shared state is untouched');
+	const saved = await A.page.evaluate(() => {
+		const s = window.__stores;
+		let g = null;
+		s.objectsGroup.subscribe((v) => (g = v))();
+		return s.animatedImports.animatedImportsSnapshot(g).map((e) => ({ behavior: e.behavior, state: e.behaviorState ?? null }));
+	});
+	h.check(saved.length === 1 && saved[0].behavior?.type === 'door' && saved[0].state === null, '8.3 the save entry has the spec and no open/shut state');
+
+	console.log('\n=== 9. a late joiner gets the state with the door ===');
+	const C = await h.setupPage(browser, 'C');
+	await h.connect(C, A);
+	await h.eventually(() => doorOf(C.page), (d) => d?.uuid === door.uuid && d.state?.on === true, '9.1 C holds the door, open, from the handshake', 20000);
+	const [aState, cState] = [(await doorOf(A.page)).state, (await doorOf(C.page)).state];
+	h.check(aState.at === cState.at && aState.n === cState.n, '9.2 C has the SAME stamp and count as A');
+	h.check(Math.abs((await doorOf(C.page)).qy) < 1e-4, '9.3 C is in Edit, so it shows the door shut');
+
+	console.log('\n=== 10. Animation panel preview: local, unsent, back to rest ===');
+	const sent = await A.page.evaluate(async (uuid) => {
+		const s = window.__stores;
+		let peer = null;
+		s.peers.subscribe((p) => (peer = p))();
+		const types = [];
+		const orig = peer.send.bind(peer);
+		peer.send = (msg) => (types.push(msg?.type), orig(msg));
+		s.animatedImports.setAnimationState(uuid, { playing: true, clip: 'open' });
+		await new Promise((r) => setTimeout(r, 500));
+		let root = null;
+		s.objectsGroup.subscribe((g) => (root = g?.getObjectByProperty('uuid', uuid)))();
+		const mid = root.getObjectByName('Leaf').quaternion.y;
+		peer.send = orig;
+		return { types, mid };
+	}, door.uuid);
+	h.check(sent.mid < -0.2, '10.1 the preview moves the leaf in Edit (qy ' + sent.mid.toFixed(3) + ')');
+	h.check(!sent.types.includes('objectParameters') && !sent.types.includes('behavior'), '10.2 nothing was sent (' + JSON.stringify(sent.types) + ')');
+	await h.eventually(() => doorOf(A.page), (d) => Math.abs(d.qy) < 1e-4 && !d.preview, '10.3 the preview hands the pose back to rest', 4000);
+	h.check((await doorOf(A.page)).state?.n === aState.n, '10.4 the shared state did not change');
+
+	console.log('\n=== 11. the wire shape is validated ===');
+	const valid = await A.page.evaluate((uuid) => {
+		const v = window.__stores.wireValidate.validateWireMessage;
+		return {
+			good: v({ type: 'behavior', uuid, on: true, at: 1, from: 0, n: 1 }),
+			nan: v({ type: 'behavior', uuid, on: true, at: NaN, from: 0, n: 1 }),
+			str: v({ type: 'behavior', uuid, on: 'yes', at: 1, from: 0, n: 1 }),
+			neg: v({ type: 'behavior', uuid, on: true, at: 1, from: 0, n: -1 })
+		};
+	}, door.uuid);
+	h.check(valid.good && !valid.nan && !valid.str && !valid.neg, '11.1 behavior: good passes, NaN/string/negative refused (' + JSON.stringify(valid) + ')');
+	const stale = await B.page.evaluate((uuid) => window.__stores.packBehavior.applyBehaviorState({ uuid, on: false, at: 1, from: 0, n: 1 }), door.uuid);
+	h.check(stale === false && (await doorOf(B.page)).state?.on === true, '11.2 an older state is refused (latest wins)');
+
+	console.log('\n=== 12. a GLB with no behavior no longer autoplays ===');
+	const plain = await A.page.evaluate(
+		() =>
+			new Promise((resolve) => {
+				const s = window.__stores;
+				const THREE = s.THREE;
+				const root = new THREE.Group();
+				const mesh = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), new THREE.MeshStandardMaterial());
+				mesh.name = 'mover';
+				root.add(mesh);
+				const track = new THREE.VectorKeyframeTrack('mover.position', [0, 1, 2], [0, 0, 0, 2, 0, 0, 0, 0, 0]);
+				new s.GLTFExporterModule.GLTFExporter().parse(
+					root,
+					async (buffer) => {
+						const uuid = await s.fileHandler.importFile(new File([buffer], 'slide.glb'), 'Slider');
+						let g = null;
+						s.objectsGroup.subscribe((v) => (g = v))();
+						const node = () => g.getObjectByProperty('uuid', uuid)?.getObjectByName('mover')?.position.x;
+						const x1 = node();
+						await new Promise((r) => setTimeout(r, 600));
+						let st = null;
+						s.animatedImports.animatedObjects.subscribe((m) => (st = m[uuid]))();
+						resolve({ x1, x2: node(), playing: st?.playing, behavior: s.animatedImports.behaviorOf(uuid) });
+					},
+					() => resolve(null),
+					{ binary: true, animations: [new THREE.AnimationClip('slide', 2, [track])] }
+				);
+			})
+	);
+	h.check(plain && plain.playing === false && plain.x1 === plain.x2, '12.1 placing an animated GLB plays nothing (' + JSON.stringify(plain) + ')');
+	h.check(plain && plain.behavior === null, '12.2 ...and it is not a functional item');
+
+	console.log('\n=== 13. the module seam: api.behavior ===');
+	const sdk = await A.page.evaluate(async (uuid) => {
+		const s = window.__stores;
+		await s.moduleSDK.initModules([
+			{ id: 'behavior33', name: 'Behavior test', version: '1.0.0', description: '33 P2 seam', register(api) { window.__bapi = api; } }
+		]);
+		await new Promise((r) => setTimeout(r, 300));
+		const api = window.__bapi;
+		const list = api.behavior.list();
+		const before = api.behavior.state(uuid);
+		const changed = api.behavior.trigger(uuid, false);
+		const again = api.behavior.trigger(uuid, false); // already shut: nothing to do
+		return { list, before, changed, again, after: api.behavior.state(uuid) };
+	}, door.uuid);
+	h.check(sdk.list.length === 1 && sdk.list[0].type === 'door' && sdk.list[0].open === true, '13.1 api.behavior.list() names the open door (' + JSON.stringify(sdk.list) + ')');
+	h.check(sdk.changed === true && sdk.again === false && sdk.after.on === false, '13.2 trigger(uuid, false) shuts it once and is a no-op after');
+	await h.eventually(() => doorOf(B.page), (d) => d?.state?.on === false, '13.3 the module trigger replicated to B');
+
+	console.log('\n=== 14. a knock door: a fast hand opens it, a slow one does not ===');
+	const knock = await A.page.evaluate(async (bytes) => {
+		const s = window.__stores;
+		const behavior = { type: 'door', clip: 'open', closeClip: 'close', trigger: 'knock', sound: 'door' };
+		const uuid = await s.fileHandler.importFile(new File([new Uint8Array(bytes)], 'knock.glb'), 'Knock door', 'glb', [3, 0, -3], undefined, { behavior });
+		// a fake hand seam (no headset headless): the frame loop samples it every frame
+		window.__hand = null;
+		s.packBehavior.startPackBehaviors({ hands: (hand) => (hand === 'right' && window.__hand ? { position: window.__hand } : null) });
+		const frames = (n) => new Promise((r) => { let i = 0; const f = () => (++i >= n ? r() : requestAnimationFrame(f)); requestAnimationFrame(f); });
+		const stateOf = () => s.packBehavior.behaviorState(uuid);
+		s.objectActions.setEditorMode('interact');
+		// SLOW: creep in at ~1 mm per frame (~0.06 m/s) — touching is not knocking
+		for (let z = -2.5; z >= -3.0; z -= 0.001) {
+			window.__hand = [3, 1.2, z];
+			await frames(1);
+		}
+		const slow = stateOf();
+		window.__hand = [3, 1.2, -2.0];
+		await frames(3);
+		// FAST: out to in, in one frame
+		window.__hand = [3, 1.2, -3.0];
+		await frames(3);
+		const fast = stateOf();
+		window.__hand = null;
+		s.packBehavior.startPackBehaviors({ hands: s.vrControls.handSnapshot });
+		return { uuid, slow, fast, knocks: s.packBehavior.packBehaviorDebug().knocks };
+	}, Array.from(DOOR_GLB));
+	h.check(knock.slow === null, '14.1 a hand creeping into the door does not knock (' + JSON.stringify(knock.slow) + ')');
+	h.check(knock.fast?.on === true && knock.knocks >= 1, '14.2 a hand arriving fast knocks it open (' + JSON.stringify(knock.fast) + ')');
+
+	await h.finish(browser);
+});
diff --git a/tests/unit/behaviorCore.test.js b/tests/unit/behaviorCore.test.js
new file mode 100644
index 00000000..a0426e65
--- /dev/null
+++ b/tests/unit/behaviorCore.test.js
@@ -0,0 +1,141 @@
+// @ts-nocheck — assertions on nullable returns; the module itself is fully typed
+import { describe, it, expect } from 'vitest';
+import {
+	normalizeBehavior,
+	normalizeState,
+	restState,
+	stateIsNewer,
+	poseAt,
+	nextState,
+	openPosition,
+	boxMinusBox,
+	frameSlabs,
+	boxCorners
+} from '../../src/lib/behaviorCore.js';
+
+// 33 P2: the pure half of animated pack items.
+const DOOR = normalizeBehavior({ type: 'door', clip: 'open', closeClip: 'close', trigger: 'click', autoplay: false, sound: 'door' });
+const DUR = { idle: 1, open: 1, close: 1 };
+
+describe('normalizeBehavior', () => {
+	it('keeps the contract fields and defaults a door collider to follow', () => {
+		expect(DOOR).toEqual({ type: 'door', clip: 'open', closeClip: 'close', trigger: 'click', autoplay: false, sound: 'door', collider: 'follow' });
+	});
+	it('refuses an unknown type or a missing clip', () => {
+		expect(normalizeBehavior({ type: 'spin', clip: 'a' })).toBeNull();
+		expect(normalizeBehavior({ type: 'door' })).toBeNull();
+		expect(normalizeBehavior(null)).toBeNull();
+	});
+	it('honours autoplay ONLY for a loop (nothing else may play on its own)', () => {
+		expect(normalizeBehavior({ type: 'door', clip: 'open', autoplay: true }).autoplay).toBe(false);
+		expect(normalizeBehavior({ type: 'oneshot', clip: 'pull', autoplay: true }).autoplay).toBe(false);
+		expect(normalizeBehavior({ type: 'loop', clip: 'loop', autoplay: true }).autoplay).toBe(true);
+		expect(normalizeBehavior({ type: 'loop', clip: 'loop' }).autoplay).toBe(false);
+	});
+	it('defaults an unknown trigger to click and drops a closeClip equal to clip', () => {
+		const b = normalizeBehavior({ type: 'toggle', clip: 'on', closeClip: 'on', trigger: 'laser' });
+		expect(b.trigger).toBe('click');
+		expect(b.closeClip).toBeNull();
+		expect(b.collider).toBeNull();
+	});
+});
+
+describe('poses', () => {
+	it('rests at the open clip t=0 before any trigger and in Edit whatever the state', () => {
+		expect(poseAt(DOOR, restState(), DUR, 5000, true)).toEqual({ clip: 'open', time: 0, moving: false });
+		const open = { on: true, at: 0, from: 0, n: 1 };
+		expect(poseAt(DOOR, open, DUR, 5000, false)).toEqual({ clip: 'open', time: 0, moving: false });
+	});
+	it('a door opens at clip speed and holds open', () => {
+		const s = nextState(DOOR, restState(), DUR, 1000);
+		expect(s).toEqual({ on: true, at: 1000, from: 0, n: 1 });
+		expect(poseAt(DOOR, s, DUR, 1500, true).time).toBeCloseTo(0.5);
+		expect(poseAt(DOOR, s, DUR, 9000, true)).toEqual({ clip: 'open', time: 1, moving: false });
+	});
+	it('closing half-way through opening starts the close clip from half-way', () => {
+		const opening = nextState(DOOR, restState(), DUR, 0);
+		const closing = nextState(DOOR, opening, DUR, 500);
+		expect(closing.on).toBe(false);
+		expect(closing.from).toBeCloseTo(0.5);
+		const p = poseAt(DOOR, closing, DUR, 600, true);
+		expect(p.clip).toBe('close');
+		expect(p.time).toBeCloseTo(0.6); // 1 - 0.4 open
+		expect(poseAt(DOOR, closing, DUR, 5000, true)).toEqual({ clip: 'close', time: 1, moving: false });
+	});
+	it('without a closeClip a door plays the open clip backwards', () => {
+		const spec = normalizeBehavior({ type: 'toggle', clip: 'open' });
+		const open = { on: true, at: 0, from: 0, n: 1 };
+		const shut = nextState(spec, open, DUR, 3000);
+		expect(poseAt(spec, shut, DUR, 3250, true)).toEqual({ clip: 'open', time: 0.75, moving: true });
+	});
+	it('a oneshot plays once per trigger and stops at its end', () => {
+		const spec = normalizeBehavior({ type: 'oneshot', clip: 'pull' });
+		const s1 = nextState(spec, restState(), { pull: 2 }, 0);
+		expect(poseAt(spec, s1, { pull: 2 }, 500, true).time).toBeCloseTo(0.5);
+		expect(poseAt(spec, s1, { pull: 2 }, 9000, true)).toEqual({ clip: 'pull', time: 2, moving: false });
+		const s2 = nextState(spec, s1, { pull: 2 }, 10000);
+		expect(s2.n).toBe(2);
+		expect(poseAt(spec, s2, { pull: 2 }, 10100, true).time).toBeCloseTo(0.1);
+	});
+	it('an ambient loop runs on the session phase only while active; a plain loop waits for its trigger', () => {
+		const amb = normalizeBehavior({ type: 'loop', clip: 'loop', autoplay: true });
+		expect(poseAt(amb, restState(), { loop: 2 }, 5500, true).time).toBeCloseTo(1.5);
+		expect(poseAt(amb, restState(), { loop: 2 }, 5500, false).time).toBe(0);
+		expect(nextState(amb, restState(), { loop: 2 }, 0)).toBeNull();
+		const plain = normalizeBehavior({ type: 'loop', clip: 'loop' });
+		expect(poseAt(plain, restState(), { loop: 2 }, 5500, true).moving).toBe(false);
+		const on = nextState(plain, restState(), { loop: 2 }, 5000);
+		expect(poseAt(plain, on, { loop: 2 }, 7500, true).time).toBeCloseTo(0.5);
+	});
+	it('a forced direction that changes nothing returns null (proximity on an open door)', () => {
+		const open = nextState(DOOR, restState(), DUR, 0);
+		expect(nextState(DOOR, open, DUR, 100, true)).toBeNull();
+		expect(nextState(DOOR, open, DUR, 100, false).on).toBe(false);
+	});
+	it('openPosition clamps a stale from', () => {
+		expect(openPosition({ on: true, at: 0, from: 9, n: 1 }, 1, 0)).toBe(1);
+	});
+});
+
+describe('state merge', () => {
+	it('latest stamp wins, the count breaks a tie', () => {
+		const a = { on: true, at: 100, from: 0, n: 1 };
+		expect(stateIsNewer(a, { on: false, at: 99, from: 0, n: 5 })).toBe(false);
+		expect(stateIsNewer(a, { on: false, at: 100, from: 0, n: 2 })).toBe(true);
+		expect(stateIsNewer(null, a)).toBe(true);
+	});
+	it('normalizeState rejects non-finite input', () => {
+		expect(normalizeState({ on: true, at: 'x', from: 0, n: 1 })).toBeNull();
+		expect(normalizeState({ on: 1, at: 5, from: -2, n: 2.7 })).toEqual({ on: false, at: 5, from: 0, n: 2 });
+	});
+});
+
+describe('the doorway', () => {
+	// the fixture door: a one-piece frame box over x [-0.65, 0.65], y [0, 2.15], z [-0.1, 0.1]
+	const frame = [-0.65, 0, -0.1, 0.65, 2.15, 0.1];
+	const leaf = [-0.48, 0.01, -0.04, 0.48, 1.98, 0.04];
+	it('cutting the leaf out of the frame box leaves posts and a lintel, and nothing in the opening', () => {
+		const slabs = frameSlabs([frame], [leaf]);
+		// left post, right post, threshold sliver dropped? (0.01 tall = kept at minSize 0.01), lintel
+		const inOpening = slabs.filter((s) => s[0] < 0 && s[3] > 0 && s[1] < 1 && s[4] > 1);
+		expect(inOpening).toEqual([]);
+		expect(slabs.some((s) => s[3] <= -0.48 + 1e-9)).toBe(true); // a left post
+		expect(slabs.some((s) => s[0] >= 0.48 - 1e-9)).toBe(true); // a right post
+		expect(slabs.some((s) => s[1] >= 1.98 - 1e-9)).toBe(true); // a lintel
+	});
+	it('a lid resting ON a chest leaves the chest body whole; a trapdoor opens through a floor ring', () => {
+		const body = [0, 0, 0, 1, 0.5, 0.6];
+		expect(frameSlabs([body], [[0, 0.5, 0, 1, 0.56, 0.6]])).toEqual([body]);
+		const ring = [-1, -0.2, -1, 1, 0, 1];
+		const slabs = frameSlabs([ring], [[-0.5, -0.1, -0.5, 0.5, -0.05, 0.5]]);
+		expect(slabs.filter((s) => s[0] < 0 && s[3] > 0 && s[2] < 0 && s[5] > 0)).toEqual([]);
+		expect(slabs.length).toBe(4);
+	});
+	it('no overlap = the box unchanged; a hole covering it = nothing left', () => {
+		expect(boxMinusBox([0, 0, 0, 1, 1, 1], [2, 2, 2, 3, 3, 3])).toEqual([[0, 0, 0, 1, 1, 1]]);
+		expect(boxMinusBox([0, 0, 0, 1, 1, 1], [-1, -1, -1, 2, 2, 2])).toEqual([]);
+	});
+	it('boxCorners gives 8 points', () => {
+		expect(boxCorners([0, 0, 0, 1, 2, 3]).length).toBe(24);
+	});
+});

From a7c9991cc742467bf13d42a68268feca526b8401 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Thu, 1 Oct 2026 21:00:26 +0300
Subject: [PATCH 2/3] [docs] 33 P3: PACKS.md behavior field + example item,
 MODULES.md api.behavior

- PACKS.md: the behavior contract (types, triggers, the no-autoplay rule, shared state,
  frame + moving parts + collider follow, authoring notes, the Explorer badge)
- MODULES.md: api.behavior list/state/trigger and the five item sounds

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 MODULES.md | 24 ++++++++++++++++++++++++
 PACKS.md   | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+)

diff --git a/MODULES.md b/MODULES.md
index 3c527c4d..047148c9 100644
--- a/MODULES.md
+++ b/MODULES.md
@@ -536,6 +536,30 @@ The things 1.18's round found, in the order they cost:
 - **Lights and shadow casters are draw calls**: each shadow-casting light draws every caster
   again; transmission (glass) renders the scene an extra time per camera, per eye.
 
+### Functional pack items: doors, lids, levers — `api.behavior` (1.19, roadmap 33)
+
+A pack item can be FUNCTIONAL: a door that opens on a click, a chest lid, a lever, a fan
+(the `behavior` field, see PACKS.md). Core runs them. Nothing plays in Edit; a click, a
+knock or walking up triggers them in Interact/Play; the state replicates; a door's
+collider follows its leaf. A module can drive them too:
+
+```js
+if (api.behavior) {
+	for (const item of api.behavior.list()) {        // [{uuid, type, trigger, open}]
+		if (item.type === 'door' && !item.open) api.behavior.trigger(item.uuid, true); // open it
+	}
+	api.behavior.state(uuid);                          // {on, at, n} or null (never triggered)
+	api.behavior.trigger(uuid);                         // toggle, like a player's click
+}
+```
+
+`trigger` is REPLICATED (one `behavior` message; every peer poses the door from the same
+session-clock stamp), so call it on ONE peer: the authority, or the peer that saw the
+cause. It returns false when nothing changed (opening an open door). The state is
+runtime: it is never saved, and a peer in Edit shows the rest pose whatever it says. The
+item sounds are core game sounds: `door`, `gate`, `slide`, `lever`, `lid` (plus `click`),
+which `api.playSound` can play too.
+
 ### Game feel: sound, music, haptics, effects, banners (1.17, roadmap 30b)
 
 Everything here is LOCAL to the device it runs on — broadcast your own op
diff --git a/PACKS.md b/PACKS.md
index 7152b904..3f1c17de 100644
--- a/PACKS.md
+++ b/PACKS.md
@@ -52,6 +52,56 @@ CC0, OpenGameArt CC0). Keep each file under the 5 MB share cap so it round-trips
 peers. Installed audio items appear in the Explorer library and can be assigned to
 a **Sound** node (spatial) or the **Scene music** channel (global).
 
+### Animated, functional items — `behavior` (roadmap 33, P2)
+
+An item row in a default pack's item list (`default.json`) MAY carry a `behavior`: a
+door you click open, a chest lid, a lever, a fan. The GLB holds the clips; the row says
+how they are used:
+
+```jsonc
+{
+  "name": "WoodDoor", "label": "Wooden door", "screenshot": "screenshot/screenshot.webp",
+  "variants": { "glTF-Binary": "WoodDoor.glb" },
+  "behavior": {
+    "type": "door",          // door | toggle | oneshot | loop
+    "clip": "open",          // the clip a trigger plays (its time 0 is the REST pose)
+    "closeClip": "close",    // optional (door/toggle): played to close; absent = `clip` backwards
+    "trigger": "click",      // click | proximity | knock
+    "autoplay": false,       // honoured ONLY for type "loop" (ambient: a fan, a flag, a flame)
+    "sound": "door",         // optional: a game-sound name (door gate slide lever lid click …)
+    "collider": "follow"     // optional; the default for a door
+  }
+}
+```
+
+**The rule.** Nothing plays on placement, on load, or in Edit, and nothing loops unless
+it is a `loop` with `autoplay: true`. A peer in Edit always sees the rest pose. A trigger
+works in Interact or Play: `door`/`toggle` alternate open ⇄ closed, `oneshot` plays once
+per trigger, and a `loop` without autoplay starts and stops. The Animation panel previews
+a clip in Edit, locally: nothing is sent or saved, and the item goes back to rest.
+
+- **Triggers.** `click` is the desktop click, the Play tap, and the VR laser, trigger and
+  poke. `proximity` opens when the player comes within 1.5 m and closes when they leave
+  (a click still works). `knock` is a VR hand moving into the part at ≥ 0.6 m/s (on a
+  desktop, a click).
+- **Shared state.** One `behavior` message per trigger, stamped with the session clock.
+  Every peer derives the pose from the stamp, so a door swings in step everywhere, and a
+  late joiner receives the state with the door. The state is runtime only: a scene saved
+  with a door open reopens shut.
+- **Frame and moving parts.** A door ALWAYS ships with its frame. The nodes the
+  behavior's clips animate are the MOVING parts (put the hinge pivot on the node's origin);
+  everything else is the static frame. With `collider: "follow"` the frame becomes slab
+  colliders with the opening cut out, and each moving part gets a box that follows it, so
+  you can walk through an open door and are stopped by a shut one (while a simulation
+  runs; that is when the walker collides at all).
+- **Authoring the GLB.** Use LINEAR TRS tracks on the moving nodes, with `clip` at time 0
+  being the closed pose. A static `idle` clip FIRST is harmless and keeps older app
+  builds (which autoplayed the first clip) still. `lods` files must keep the same node
+  names, hierarchy and clips. The same `behavior` object may also sit in the GLB's scene
+  extras (`scene.extras.behavior`); the pack row wins over it.
+- The Explorer marks such items with a small ▶ "animated" badge that says what they do
+  and what sets them off.
+
 ## Repo / .zip structure
 
 ```

From ea7d3124029a8e999e970be796994ca81cc394ea Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Fri, 2 Oct 2026 02:16:45 +0300
Subject: [PATCH 3/3] [fix] 33 P2: a functional door is never the sim's
 fallback body; first play schedules the clip
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- physics: with nothing dynamic, a sim start simulated the (sticky) selectedObject — the
  door just placed. It fell over and every Interact click on it became a carry (the
  pack-behavior 7.x flake). Functional items (userData.behavior) are skipped; a door-only
  scene now gets the existing "Nothing to simulate" toast.
  Counterfactual: pack-behavior 7.0a (the door dynamic) and 7.3/7.7 go red without it.
- animatedImports: with registration no longer autoplaying, nothing scheduled the action
  when `playing` later turned true (a press, or a restored playing save) — the state said
  playing and nothing moved. setAnimationState schedules it on the first play.
  Counterfactual: animated-models "clip animates on A/B", animation-persist "animates
  before saving / after the round trip" go red without it.
- packBehaviorDebug grows click diagnostics (clicks, lastClick {mesh, result}).
- suites: pack-behavior primes the walker, adds a real dynamic crate + 7.0a/7.0b, samples
  the preview window (10.1); animation-persist's panel section starts from a playing clip.

Battery (vite inside e2e-slot, PEER_CONFIG): pack-behavior 51/0, animated-models 15/0,
animation-persist 23/0, game-audio 26/0, packs-explorer 10/0. svelte-check 333/47 (= base),
vitest 396/396, check-storage clean, npm run build green.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/lib/animatedImports.js           |  7 ++++
 src/lib/packBehavior.js              | 20 ++++++---
 src/lib/physics.js                   |  6 ++-
 tests/e2e/animation-persist.test.cjs | 10 ++---
 tests/e2e/pack-behavior.test.cjs     | 62 ++++++++++++++++++++++++++--
 5 files changed, 89 insertions(+), 16 deletions(-)

diff --git a/src/lib/animatedImports.js b/src/lib/animatedImports.js
index 2b23569a..fbc6dfed 100644
--- a/src/lib/animatedImports.js
+++ b/src/lib/animatedImports.js
@@ -231,6 +231,13 @@ export function setAnimationState(uuid, next, replicate = true) {
 		Object.values(record.actions).forEach((action) => action.stop());
 		record.actions[state.clip]?.play();
 	}
+	// 33 P2: nothing autoplays at registration any more, so the FIRST play is what schedules
+	// the action — without this a press (or a restored `playing: true`) changed the state and
+	// moved nothing
+	if (state.playing && state.clip && !record.actions[state.clip]?.isScheduled()) {
+		Object.values(record.actions).forEach((action) => action.stop());
+		record.actions[state.clip]?.play();
+	}
 	if (!state.playing && next.playing === false) record.mixer.setTime(0);
 	if (replicate) {
 		/** @type {any} */
diff --git a/src/lib/packBehavior.js b/src/lib/packBehavior.js
index 93f2a47e..720e5ab0 100644
--- a/src/lib/packBehavior.js
+++ b/src/lib/packBehavior.js
@@ -71,7 +71,14 @@ const near = new Map();
 const knockReady = new Map();
 /** @type {Map<string, {box: THREE.Box3, at: number}>} world boxes for proximity, refreshed */
 const boxCache = new Map();
-const stats = { triggers: 0, received: 0, stale: 0, poses: 0, sounds: 0, knocks: 0, colliderBuilds: 0 };
+const stats = { triggers: 0, received: 0, stale: 0, poses: 0, sounds: 0, knocks: 0, colliderBuilds: 0, clicks: 0 };
+/** the last click the handler heard and what it made of it (the suites' diagnosis) */
+let lastClick = /** @type {{mesh: string, result: string} | null} */ (null);
+/** @param {any} mesh @param {string} result @returns {false} */
+function noteClick(mesh, result) {
+	lastClick = { mesh: String(mesh?.name ?? mesh?.type ?? '?'), result };
+	return false;
+}
 
 /** the leftover after a clip end before a preview hands the pose back */
 const PREVIEW_HOLD = 0.4;
@@ -535,14 +542,16 @@ export function tickPackBehaviors() {
  * @param {any} mesh @returns {boolean}
  */
 function onBehaviorClick(mesh) {
-	if (!gameFeelActive()) return false;
+	stats.clicks++;
+	if (!gameFeelActive()) return noteClick(mesh, 'edit');
 	const root = behaviorRootOf(mesh);
-	if (!root) return false;
+	if (!root) return noteClick(mesh, 'not-functional');
 	const spec = behaviorOf(root.uuid);
-	if (!spec || (spec.type === 'loop' && spec.autoplay)) return false;
+	if (!spec || (spec.type === 'loop' && spec.autoplay)) return noteClick(mesh, 'ambient');
 	// proximity doors still answer a click (a toggle by hand); knock doors take a desktop
 	// click as the knock (a desktop has no hands)
-	if (!triggerBehavior(root.uuid)) return false;
+	if (!triggerBehavior(root.uuid)) return noteClick(mesh, 'unchanged');
+	noteClick(mesh, 'toggled');
 	try {
 		flowRef?.fireObjectClick?.(root.uuid);
 	} catch {}
@@ -587,6 +596,7 @@ export function startPackBehaviors(options = {}) {
 export function packBehaviorDebug() {
 	return {
 		...stats,
+		lastClick,
 		items: behaviorUuids().map((uuid) => ({
 			uuid,
 			spec: behaviorOf(uuid),
diff --git a/src/lib/physics.js b/src/lib/physics.js
index 14f0268b..83daa5d5 100644
--- a/src/lib/physics.js
+++ b/src/lib/physics.js
@@ -826,7 +826,11 @@ async function startSimulation() {
 	);
 	if (dynamicUuids.length === 0) {
 		const selected = get(selectedObject);
-		if (selected && group.getObjectByProperty('uuid', selected.uuid) && !locked.includes(selected.uuid)) {
+		// 33 P2: never a FUNCTIONAL pack item (a door, a chest): its colliders are the frame
+		// slabs + the followed moving parts, and as the fallback body it fell over and took
+		// every click as a carry. `selectedObject` is sticky, so the door just placed (and
+		// deselected) was exactly what this picked.
+		if (selected && !selected.userData?.behavior && group.getObjectByProperty('uuid', selected.uuid) && !locked.includes(selected.uuid)) {
 			params[selected.uuid] = { ...(params[selected.uuid] ?? {}), mass: 1 };
 			delete params[selected.uuid].forceStatic;
 			dynamicUuids = [selected.uuid];
diff --git a/tests/e2e/animation-persist.test.cjs b/tests/e2e/animation-persist.test.cjs
index 2add4226..0346e349 100644
--- a/tests/e2e/animation-persist.test.cjs
+++ b/tests/e2e/animation-persist.test.cjs
@@ -185,17 +185,13 @@ h.run(async () => {
 			if (m?.parameter === 'animation') window.__sent.push(m.playing);
 			return orig(m);
 		};
-		// 33 P2: an import no longer autoplays, so the first press PLAYS and the second pauses
-		document.querySelector('#clip-play')?.click();
-		await new Promise((r) => setTimeout(r, 400));
-		const mid = await new Promise((r) => w.animatedImports.animatedObjects.subscribe(r)());
+		// the clip is PLAYING here (pressed at import, restored playing), so one press pauses
 		document.querySelector('#clip-play')?.click();
 		await new Promise((r) => setTimeout(r, 400));
 		const imported = await new Promise((r) => w.animatedImports.animatedObjects.subscribe(r)());
-		return { sent: window.__sent.slice(), started: Object.values(mid)[0]?.playing, playing: Object.values(imported)[0]?.playing };
+		return { sent: window.__sent.slice(), playing: Object.values(imported)[0]?.playing };
 	});
-	h.check(picked.sent.length >= 2, `the clip transport replicates (${picked.sent.length} message(s))`);
-	h.check(picked.started === true, `the first press plays it (playing ${picked.started})`);
+	h.check(picked.sent.length >= 1, `the clip transport replicates (${picked.sent.length} message(s))`);
 	h.check(picked.playing === false, `and pausing actually paused it (playing ${picked.playing})`);
 
 	await h.finish(browser);
diff --git a/tests/e2e/pack-behavior.test.cjs b/tests/e2e/pack-behavior.test.cjs
index 4152849b..2f1b748f 100644
--- a/tests/e2e/pack-behavior.test.cjs
+++ b/tests/e2e/pack-behavior.test.cjs
@@ -179,8 +179,50 @@ h.run(async () => {
 	await h.eventually(() => doorOf(B.page), (d) => Math.abs(d.qy - OPEN_QY) < 0.01, '6.3 B in Interact shows it open');
 
 	console.log('\n=== 7. the leaf collider follows: open passes, shut stops ===');
+	// THE FALLBACK GUARD: with nothing dynamic, a sim start simulates the (sticky) selected
+	// object — which used to be the door just placed, so it fell and every click carried it
+	await A.page.evaluate((uuid) => {
+		const s = window.__stores;
+		s.objectActions.selectObject(uuid);
+		s.objectActions.deselectObject(); // selectedObject stays the door (sticky)
+	}, door.uuid);
+	await A.page.evaluate(() => window.__stores.physics.toggleSimulation());
+	await A.page.waitForTimeout(1500);
+	const fallback = await A.page.evaluate((uuid) => {
+		const p = window.__stores.physics;
+		const running = !!p.physicsRuntime();
+		const dynamicDoor = running && p.physicsDebug().some((b) => b.uuid === uuid);
+		if (running) p.stopSimulation();
+		return { running, dynamicDoor };
+	}, door.uuid);
+	h.check(!fallback.dynamicDoor, '7.0a a sim start never makes the functional door the fallback dynamic body (' + JSON.stringify(fallback) + ')');
+	// a real dynamic body elsewhere, so a simulation runs
+	const crate = await A.page.evaluate(async () => {
+		const s = window.__stores;
+		s.commandsHandler.sceneCommand('/create Box 1 1 1');
+		await new Promise((r) => setTimeout(r, 800));
+		let g = null;
+		s.objectsGroup.subscribe((v) => (g = v))();
+		const box = [...g.children].reverse().find((c) => c.isMesh && !c.userData.behavior);
+		box.position.set(6, 3, 6);
+		box.updateMatrixWorld(true);
+		s.physics.setPhysicsFor(box.uuid, { mode: 'dynamic', mass: 1 });
+		s.objectActions.deselectObject();
+		return box.uuid;
+	});
 	await A.page.evaluate(() => window.__stores.physics.toggleSimulation());
 	await h.eventually(() => A.page.evaluate(() => !!window.__stores.physics.physicsRuntime()), (v) => v, '7.0 a simulation runs on A', 15000);
+	const bodies = await A.page.evaluate(() => {
+		const p = window.__stores.physics;
+		return {
+			dynamic: p.physicsDebug().map((b) => b.uuid),
+			fixed: p.physicsWorldDebug().fixed.find((f) => f.name === 'TestDoor') ?? null
+		};
+	});
+	h.check(
+		!bodies.dynamic.includes(door.uuid) && bodies.fixed && bodies.fixed.colliders >= 3,
+		'7.0b the door is a FIXED body of frame slabs, never the fallback dynamic one (' + JSON.stringify({ crate: bodies.dynamic.includes(crate), fixed: bodies.fixed }) + ')'
+	);
 	await A.page.waitForTimeout(400);
 	/** walk the capsule from in front of the door straight through the doorway */
 	const walk = () =>
@@ -210,7 +252,16 @@ h.run(async () => {
 	w = await walk();
 	h.check(w.z > -2.9, '7.5 SHUT: the leaf stops the capsule (z ' + w.z.toFixed(2) + ')');
 	// counterfactual: the whole-door box (no doorway cut) blocks even an OPEN door
+	const diagBefore = await A.page.evaluate(({ x, y }) => ({ under: document.elementFromPoint(x, y)?.tagName, dbg: window.__stores.packBehavior.packBehaviorDebug().clicks }), framePt);
 	await A.page.mouse.click(framePt.x, framePt.y);
+	await A.page.waitForTimeout(300);
+	const diag = await A.page.evaluate(() => {
+		const d = window.__stores.packBehavior.packBehaviorDebug();
+		let pi = null;
+		window.__stores.playInteract.playInteractState?.subscribe?.((v) => (pi = v))();
+		return { clicks: d.clicks, lastClick: d.lastClick, state: d.items[0]?.state, pi };
+	});
+	console.log('   7.6 diagnosis: before ' + JSON.stringify(diagBefore) + ' after ' + JSON.stringify(diag));
 	await h.eventually(() => doorOf(A.page), (d) => Math.abs(d.qy - OPEN_QY) < 0.01, '7.6 reopened');
 	await A.page.evaluate(async (uuid) => {
 		const s = window.__stores;
@@ -262,14 +313,19 @@ h.run(async () => {
 		const orig = peer.send.bind(peer);
 		peer.send = (msg) => (types.push(msg?.type), orig(msg));
 		s.animatedImports.setAnimationState(uuid, { playing: true, clip: 'open' });
-		await new Promise((r) => setTimeout(r, 500));
 		let root = null;
 		s.objectsGroup.subscribe((g) => (root = g?.getObjectByProperty('uuid', uuid)))();
-		const mid = root.getObjectByName('Leaf').quaternion.y;
+		// sample the whole preview window (1 s clip + the hold): one instant read on a loaded
+		// page can land before the first preview frame
+		let mid = 0;
+		for (let i = 0; i < 30; i++) {
+			await new Promise((r) => setTimeout(r, 50));
+			mid = Math.min(mid, root.getObjectByName('Leaf').quaternion.y);
+		}
 		peer.send = orig;
 		return { types, mid };
 	}, door.uuid);
-	h.check(sent.mid < -0.2, '10.1 the preview moves the leaf in Edit (qy ' + sent.mid.toFixed(3) + ')');
+	h.check(sent.mid < -0.2, '10.1 the preview moves the leaf in Edit (deepest qy ' + sent.mid.toFixed(3) + ')');
 	h.check(!sent.types.includes('objectParameters') && !sent.types.includes('behavior'), '10.2 nothing was sent (' + JSON.stringify(sent.types) + ')');
 	await h.eventually(() => doorOf(A.page), (d) => Math.abs(d.qy) < 1e-4 && !d.preview, '10.3 the preview hands the pose back to rest', 4000);
 	h.check((await doorOf(A.page)).state?.n === aState.n, '10.4 the shared state did not change');