@holoscript/core 8.0.0 → 8.0.2

package/dist/index.js

@@ -1,12 +1,12 @@
-export { GLTFPipeline, createGLTFPipeline, generateScaleNormalMap, generateScaleTexture } from './chunk-JX7YL6ZE.js';
-export { ANCHOR_DEFAULTS, ARCORE_DEPTH_RECOMMENDED_RANGE_MILLIMETERS, HOLOMAP_MOBILE_SENSOR_BUNDLE_VERSION, TRAJECTORY_DEFAULTS, arCoreDepthFrameToMobileSensorFrame, cameraPoseFromColumnMajorTransform, createAnchorContext, createArCoreDepthMobileSensorBundle, createFusedAttentionBackend, createPagedKVCache, createTrajectoryMemory, mergeAnchoredProvenance, mobileSensorBundleToFrames, replayMobileSensorBundle, validateMobileSensorBundle } from './chunk-F43YAA34.js';
+export { GLTFPipeline, createGLTFPipeline, generateScaleNormalMap, generateScaleTexture } from './chunk-ZPYP4RBA.js';
+export { ANCHOR_DEFAULTS, ARCORE_DEPTH_RECOMMENDED_RANGE_MILLIMETERS, HOLOMAP_MOBILE_SENSOR_BUNDLE_VERSION, TRAJECTORY_DEFAULTS, arCoreDepthFrameToMobileSensorFrame, cameraPoseFromColumnMajorTransform, createAnchorContext, createArCoreDepthMobileSensorBundle, createFusedAttentionBackend, createPagedKVCache, createTrajectoryMemory, mergeAnchoredProvenance, mobileSensorBundleToFrames, replayMobileSensorBundle, validateMobileSensorBundle } from './chunk-E47Z63DF.js';
 export { InteropBindingGenerator, MCPCircuitBreaker, getMCPCircuitBreaker } from './chunk-FGGJQRLZ.js';
 export { SkeletonTrait as SkeletonAnimationTrait, createSkeletonTrait } from './chunk-M56JSP4A.js';
-export { BUILD_TIMESTAMP, GIT_COMMIT_SHA, HOLOMAP_DEFAULTS, HOLOSCRIPT_VERSION, assertWeightCid, createHoloMapMicroEncoder, createHoloMapRunId, createHoloMapRuntime, frameToMicroImage, getCachedWeightBlob, getVersionInfo, getVersionString, loadHoloMapWeightBlob, logHoloMapEvent, normalizeWeightCidDigest, putCachedWeightBlob, resetHoloMapTelemetryForTests, runHoloMapMicroEncoderCpu, tryCreateHoloMapEncoderDevice } from './chunk-AYBXB26F.js';
+export { BUILD_TIMESTAMP, GIT_COMMIT_SHA, HOLOMAP_DEFAULTS, HOLOSCRIPT_VERSION, assertWeightCid, createHoloMapMicroEncoder, createHoloMapRunId, createHoloMapRuntime, frameToMicroImage, getCachedWeightBlob, getVersionInfo, getVersionString, loadHoloMapWeightBlob, logHoloMapEvent, normalizeWeightCidDigest, putCachedWeightBlob, resetHoloMapTelemetryForTests, runHoloMapMicroEncoderCpu, tryCreateHoloMapEncoderDevice } from './chunk-LOGP3JWH.js';
 export { computeHoloMapReplayFingerprint, fnv1a32Hex } from './chunk-WNNE3PO3.js';
 export { CircuitBreakerState, CircuitBreaker as ResilienceCircuitBreaker, retryWithBackoff, withTimeout } from './chunk-A6KINLZJ.js';
-import { init_ThreeJSCompiler, init_A2AAgentCardCompiler, init_NIRCompiler, GaussianSplattingCompiler, NIRCompiler, A2AAgentCardCompiler, USDZPipeline } from './chunk-NGKREZ36.js';
-export { BUILTIN_RESOURCES, CAPABILITY_HIERARCHY, CATEGORY_DEFAULT_EMBODIMENT, CompilerBridge, CrossRealityTraitRegistry, EFFECTS_BY_CATEGORY, EFFECT_TO_CAPABILITY, EffectChecker, EffectRow, HANDOFF_PATH_RULES, LinearTypeChecker, MVC_BUDGET_CONSTRAINTS, PLATFORM_BUDGETS, PLATFORM_EMBODIMENT_OVERRIDES, ResourceBudgetAnalyzer, SpatialPartitionPass, TRAIT_EFFECTS, TRAIT_RESOURCE_COSTS, TRAIT_RESOURCE_MAP, TRUST_LEVEL_CAPABILITIES, ThreeJSCompiler, USDZPipeline, bestCategoryForTraits, buildSafetyReport, checkCapabilities, compilePipelineSource, compilePipelineSourceToNode, compilePipelineSourceToPython, compilePipelineToNode, compilePipelineToPython, createCrossRealityTraitRegistry, createEffectChecker, dangerLevel, deriveRequirements, effectCategory, expandCapabilities, formatReport, generateCertificate, getCompilerBridge, getCrossRealityTraitRegistry, inferFromBuiltins, inferFromTraits, isSafeTraitSet, knownBuiltins, knownTraits, quickSafetyCheck, resetCrossRealityTraitRegistry, runSafetyPass, selectModality, selectModalityForAll, spatialPartition } from './chunk-NGKREZ36.js';
+import { init_ThreeJSCompiler, init_Native2DCompiler, init_A2AAgentCardCompiler, init_NIRCompiler, Native2DCompiler, GaussianSplattingCompiler, NIRCompiler, A2AAgentCardCompiler, USDZPipeline } from './chunk-3OYVN53V.js';
+export { BUILTIN_RESOURCES, CAPABILITY_HIERARCHY, CATEGORY_DEFAULT_EMBODIMENT, CompilerBridge, CrossRealityTraitRegistry, EFFECTS_BY_CATEGORY, EFFECT_TO_CAPABILITY, EffectChecker, EffectRow, HANDOFF_PATH_RULES, LinearTypeChecker, MVC_BUDGET_CONSTRAINTS, PLATFORM_BUDGETS, PLATFORM_EMBODIMENT_OVERRIDES, ResourceBudgetAnalyzer, SpatialPartitionPass, TRAIT_EFFECTS, TRAIT_RESOURCE_COSTS, TRAIT_RESOURCE_MAP, TRUST_LEVEL_CAPABILITIES, ThreeJSCompiler, USDZPipeline, bestCategoryForTraits, buildSafetyReport, checkCapabilities, compilePipelineSource, compilePipelineSourceToNode, compilePipelineSourceToPython, compilePipelineToNode, compilePipelineToPython, createCrossRealityTraitRegistry, createEffectChecker, dangerLevel, deriveRequirements, effectCategory, expandCapabilities, formatReport, generateCertificate, getCompilerBridge, getCrossRealityTraitRegistry, inferFromBuiltins, inferFromTraits, isSafeTraitSet, knownBuiltins, knownTraits, quickSafetyCheck, resetCrossRealityTraitRegistry, runSafetyPass, selectModality, selectModalityForAll, spatialPartition } from './chunk-3OYVN53V.js';
 export { generateHullGeometry, generateMembraneGeometry, generateSplineGeometry } from './chunk-EKBKLK7P.js';
 import { generateSemanticSceneGraphObject } from './chunk-HYNTS5CP.js';
 export { SemanticSceneGraph } from './chunk-HYNTS5CP.js';
@@ -14,11 +14,10 @@ export { AgentInferenceExportTarget_default as AgentInferenceExportTarget } from
 export { assertHoloMapManifestContract } from './chunk-MBOOR7X4.js';
 export { COCOExporterImpl as COCOExporter } from './chunk-Q56TT7IL.js';
 export { RemotionBridgeImpl as RemotionBridge } from './chunk-YYXH45E2.js';
-export { AIDriverTrait, ARKIT_MOUTH_SHAPES, AnimationTrait, BehaviorTreeRunner, MorphTrait as BlendShapeTrait, CharacterTrait, ComponentType, DEFAULT_ANIMATION_MAP, DEFAULT_AUTONOMY_GUARD_POLICY, DEFAULT_EXPRESSION_PRESETS, DEFAULT_FREQUENCY_BANDS, DRAFT_DEFAULTS, DRAFT_TRAIT, DialogTrait, DraftManager, ECSWorld, EmotionDirectiveTrait, GOAPPlanner, IKTrait, JointTrait, LipSyncTrait, LobbyTrait, NetworkedTrait, OCULUS_VISEME_MAP, REFUSED_CARE_OPTIMIZATION_TARGETS, RigidbodyTrait, TriggerTrait, VRTraitRegistry, VoiceInputTrait, VoiceOutputTrait, accessibleHandler, aiInpaintingHandler, aiTextureGenHandler, alertHandler, altTextHandler, ambisonicsHandler, anchorHandler, audioMaterialHandler, audioOcclusionHandler, audioPortalHandler, avatarEmbodimentHandler, behaviorTreeHandler, bodyTrackingHandler, buoyancyHandler, chainHandler, clothHandler, coLocatedHandler, computeHandler, controlNetHandler, controllerInputHandler, createAIDriverTrait, createAnimationTrait, createMorphTrait as createBlendShapeTrait, createCareField, createCharacterTrait, createDialogTrait, createEmotionDirectiveTrait, createIKTrait, createJointTrait, createLipSyncTrait, createLobbyTrait, createNetworkedTrait, createRepairLoop, createRigidbodyTrait, createTriggerTrait, createVoiceInputTrait, createVoiceOutputTrait, dataBindingHandler, destructionHandler, dialogueHandler, diffusionRealtimeHandler, digitalTwinHandler, dropTableHandler, effectiveWeight, emotionHandler, emotionalVoiceHandler, encounterHandler, evaluateAutonomyGuard, extractPayload, faceTrackingHandler, factionHandler, fbxHandler, flowFieldHandler, fluidHandler, gaussianSplatHandler, geospatialAnchorHandler, geospatialEnvHandler, getCachedThingDescription, getMQTTSinkClient, getMQTTSinkState, getMQTTSourceClient, getMQTTSourceState, getWoTThingState, gltfHandler, goalOrientedHandler, gpuBufferHandler, gpuParticleHandler, gpuPhysicsHandler, handTrackingHandler, hapticCueHandler, hasMQTTSinkTrait, hasMQTTSourceTrait, hasWoTThingTrait, headTrackedAudioHandler, heatmap3dHandler, highContrastHandler, hrtfHandler, invalidateThingDescription, isMQTTSinkConnected, isMQTTSourceConnected, layerAwareHandler, lightEstimationHandler, llmAgentHandler, luckHandler, magnifiableHandler, marketplaceHandler, materialXHandler, memoryHandler, meshDetectionHandler, motionReducedHandler, mqttSinkHandler, mqttSourceHandler, multiAgentHandler, nerfHandler, neuralLinkHandler, nftHandler, occlusionHandler, patrolHandler, perceptionHandler, persistentAnchorHandler, photogrammetryHandler, pickByWeight, planeDetectionHandler, poiHandler, pointCloudHandler, portableHandler, publishToMQTTSink, rbacHandler, recordGratitude, rememberRelationalContext, remotePresenceHandler, reverbZoneHandler, roleHandler, rooftopAnchorHandler, ropeHandler, sceneGraphHandler, screenReaderHandler, sensorHandler, sharePlayHandler, sharedAnchorHandler, sharedWorldHandler, shouldFire, softBodyHandler, sonificationHandler, spatialAccessoryHandler, spatialAudioCueHandler, spatialPersonaHandler, spectatorHandler, statHandler, subtitleHandler, terrainAnchorHandler, tokenGatedHandler, usdHandler, userMonitorHandler, validateCareField, voiceProximityHandler, volumetricVideoHandler, vpsHandler, vrTraitRegistry, walletHandler, windHandler, wotThingHandler } from './chunk-RVBHAXFG.js';
+export { AIDriverTrait, ARKIT_MOUTH_SHAPES, AnimationTrait, BehaviorTreeRunner, MorphTrait as BlendShapeTrait, CharacterTrait, ComponentType, DEFAULT_ANIMATION_MAP, DEFAULT_AUTONOMY_GUARD_POLICY, DEFAULT_EXPRESSION_PRESETS, DEFAULT_FREQUENCY_BANDS, DRAFT_DEFAULTS, DRAFT_TRAIT, DialogTrait, DraftManager, ECSWorld, EmotionDirectiveTrait, GOAPPlanner, IKTrait, JointTrait, LipSyncTrait, LobbyTrait, NetworkedTrait, OCULUS_VISEME_MAP, REFUSED_CARE_OPTIMIZATION_TARGETS, RigidbodyTrait, TriggerTrait, VRTraitRegistry, VoiceInputTrait, VoiceOutputTrait, accessibleHandler, aiInpaintingHandler, aiTextureGenHandler, alertHandler, altTextHandler, ambisonicsHandler, anchorHandler, audioMaterialHandler, audioOcclusionHandler, audioPortalHandler, avatarEmbodimentHandler, behaviorTreeHandler, bodyTrackingHandler, buoyancyHandler, chainHandler, clothHandler, coLocatedHandler, computeHandler, controlNetHandler, controllerInputHandler, createAIDriverTrait, createAnimationTrait, createMorphTrait as createBlendShapeTrait, createCareField, createCharacterTrait, createDialogTrait, createEmotionDirectiveTrait, createIKTrait, createJointTrait, createLipSyncTrait, createLobbyTrait, createNetworkedTrait, createRepairLoop, createRigidbodyTrait, createTriggerTrait, createVoiceInputTrait, createVoiceOutputTrait, dataBindingHandler, destructionHandler, dialogueHandler, diffusionRealtimeHandler, digitalTwinHandler, dropTableHandler, effectiveWeight, emotionHandler, emotionalVoiceHandler, encounterHandler, evaluateAutonomyGuard, extractPayload, faceTrackingHandler, factionHandler, fbxHandler, flowFieldHandler, fluidHandler, gaussianSplatHandler, geospatialAnchorHandler, geospatialEnvHandler, getCachedThingDescription, getMQTTSinkClient, getMQTTSinkState, getMQTTSourceClient, getMQTTSourceState, getWoTThingState, gltfHandler, goalOrientedHandler, gpuBufferHandler, gpuParticleHandler, gpuPhysicsHandler, handTrackingHandler, hapticCueHandler, hasMQTTSinkTrait, hasMQTTSourceTrait, hasWoTThingTrait, headTrackedAudioHandler, heatmap3dHandler, highContrastHandler, hrtfHandler, invalidateThingDescription, isMQTTSinkConnected, isMQTTSourceConnected, layerAwareHandler, lightEstimationHandler, llmAgentHandler, luckHandler, magnifiableHandler, marketplaceHandler, materialXHandler, memoryHandler, meshDetectionHandler, motionReducedHandler, mqttSinkHandler, mqttSourceHandler, multiAgentHandler, nerfHandler, neuralLinkHandler, nftHandler, occlusionHandler, patrolHandler, perceptionHandler, persistentAnchorHandler, photogrammetryHandler, pickByWeight, planeDetectionHandler, poiHandler, pointCloudHandler, portableHandler, publishToMQTTSink, rbacHandler, recordGratitude, rememberRelationalContext, remotePresenceHandler, reverbZoneHandler, roleHandler, rooftopAnchorHandler, ropeHandler, sceneGraphHandler, screenReaderHandler, sensorHandler, sharePlayHandler, sharedAnchorHandler, sharedWorldHandler, shouldFire, softBodyHandler, sonificationHandler, spatialAccessoryHandler, spatialAudioCueHandler, spatialPersonaHandler, spectatorHandler, statHandler, subtitleHandler, terrainAnchorHandler, tokenGatedHandler, usdHandler, userMonitorHandler, validateCareField, voiceProximityHandler, volumetricVideoHandler, vpsHandler, vrTraitRegistry, walletHandler, windHandler, wotThingHandler } from './chunk-DXWOTOUK.js';
 export { LIGHTING_PRESETS, LightingTrait, MATERIAL_PRESETS, MaterialTrait, RenderingTrait, SHADER_CHUNKS, SHADER_PRESETS, ShaderTrait, createLightingTrait, createMaterialTrait, createRenderingTrait, createShaderTrait } from './chunk-QPOQ7VPI.js';
 export { HOLOMAP_SIMULATION_CONTRACT_KIND, ensureNodeWebGpuSync, isWebGpuEnvironmentPresent } from './chunk-YF2I3MV3.js';
 import './chunk-TDCNJHWO.js';
-import './chunk-VECQYRXL.js';
 import './chunk-YQELFNJV.js';
 import './chunk-FHP6LXJS.js';
 import { IncrementalCompiler } from './chunk-GYZE55MO.js';
@@ -29,61 +28,62 @@ export { AsyncFunctionHandler, ErrorBoundary, ExportImportHandler, InteropContex
 export { ABSORB_TRAIT, AbsorbProcessor, HOT_RELOAD_TRAIT, HotReloadWatcher, SCRIPT_TEST_TRAIT, ScriptTestRunner } from './chunk-2M2DPHKB.js';
 import { computeContentHash } from './chunk-4R6SBXDB.js';
 export { classifyPublishMode, computeContentHash, extractImports, generateProvenance } from './chunk-4R6SBXDB.js';
-import { init_WASMCompiler, WASMCompiler } from './chunk-IPWSXCCN.js';
-export { WASMCompiler, compileASTToWASM, compileToWASM, createWASMCompiler } from './chunk-IPWSXCCN.js';
-import { init_WebGPUCompiler, WebGPUCompiler } from './chunk-NBMHU6SW.js';
-export { WebGPUCompiler } from './chunk-NBMHU6SW.js';
+import { init_WASMCompiler, WASMCompiler } from './chunk-YVD3CSO3.js';
+export { WASMCompiler, compileASTToWASM, compileToWASM, createWASMCompiler } from './chunk-YVD3CSO3.js';
+import { init_WebGPUCompiler, WebGPUCompiler } from './chunk-CMT5NMMS.js';
+export { WebGPUCompiler } from './chunk-CMT5NMMS.js';
 import { init_DTDLCompiler, DTDLCompiler } from './chunk-J6M4FPK5.js';
 export { DTDLCompiler, DTDL_TRAIT_COMPONENTS } from './chunk-J6M4FPK5.js';
-import { init_URDFCompiler, URDFCompiler } from './chunk-HZTDET3N.js';
-export { URDFCompiler, compileForGazebo, compileForROS2, compileToURDF, createURDFCompiler, generateControllersYaml, generateROS2LaunchFile } from './chunk-HZTDET3N.js';
-import { USDPhysicsCompiler } from './chunk-IVSZDECV.js';
-export { USDPhysicsCompiler, compileForIsaacSim, compileToUSDPhysics } from './chunk-IVSZDECV.js';
-import { init_SDFCompiler, SDFCompiler } from './chunk-MGE5Z4GS.js';
-export { SDFCompiler } from './chunk-MGE5Z4GS.js';
+import { init_URDFCompiler, URDFCompiler } from './chunk-R24NNAEG.js';
+export { URDFCompiler, compileForGazebo, compileForROS2, compileToURDF, createURDFCompiler, generateControllersYaml, generateROS2LaunchFile } from './chunk-R24NNAEG.js';
+import { USDPhysicsCompiler } from './chunk-LHAXPADA.js';
+export { USDPhysicsCompiler, compileForIsaacSim, compileToUSDPhysics } from './chunk-LHAXPADA.js';
+import { init_SDFCompiler, SDFCompiler } from './chunk-OH2FAIVU.js';
+export { SDFCompiler } from './chunk-OH2FAIVU.js';
 import { init_StateCompiler, StateCompiler } from './chunk-ANXZFVY2.js';
 import { TraitCompositionCompiler } from './chunk-XKTPFXGA.js';
 export { TraitCompositionCompiler } from './chunk-XKTPFXGA.js';
-import { init_UnrealCompiler, UnrealCompiler } from './chunk-IZM5VQZD.js';
-export { UnrealCompiler, compileToUnreal } from './chunk-IZM5VQZD.js';
-import { init_GodotCompiler, GodotCompiler } from './chunk-UMABK6SI.js';
-export { GodotCompiler } from './chunk-UMABK6SI.js';
-import { init_R3FCompiler, init_visual, MATERIAL_PRESETS, ENVIRONMENT_PRESETS, R3FCompiler } from './chunk-UM6C3CGK.js';
-export { ENVIRONMENT_PRESETS, R3FCompiler, registerAllPresets } from './chunk-UM6C3CGK.js';
+import { init_UnrealCompiler, UnrealCompiler } from './chunk-D3STJ56J.js';
+export { UnrealCompiler, compileToUnreal } from './chunk-D3STJ56J.js';
+import { init_GodotCompiler, GodotCompiler } from './chunk-PY37LNDP.js';
+export { GodotCompiler } from './chunk-PY37LNDP.js';
+import { init_R3FCompiler, init_visual, MATERIAL_PRESETS, ENVIRONMENT_PRESETS, R3FCompiler } from './chunk-FS7BFHFN.js';
+export { ENVIRONMENT_PRESETS, R3FCompiler, registerAllPresets } from './chunk-FS7BFHFN.js';
 import './chunk-XT6JY5W5.js';
-import { init_PlayCanvasCompiler, PlayCanvasCompiler } from './chunk-ZBQXLH2L.js';
+import './chunk-QRPRIJ2W.js';
+import { init_PlayCanvasCompiler, PlayCanvasCompiler } from './chunk-DHO2YRIM.js';
 import { init_AndroidCompiler, AndroidCompiler } from './chunk-WRKUDAZJ.js';
 export { AndroidCompiler, compileToAndroid } from './chunk-WRKUDAZJ.js';
-import { init_AndroidXRCompiler, AndroidXRCompiler } from './chunk-KJLB4OPV.js';
-export { AndroidXRCompiler, compileToAndroidXR } from './chunk-KJLB4OPV.js';
+import { init_AndroidXRCompiler, AndroidXRCompiler } from './chunk-YN2YWTXW.js';
+export { AndroidXRCompiler, compileToAndroidXR } from './chunk-YN2YWTXW.js';
 import './chunk-FDSGHPAK.js';
 import { init_IOSCompiler, IOSCompiler } from './chunk-OMXII44L.js';
 export { IOSCompiler, compileToIOS } from './chunk-OMXII44L.js';
-import { init_VisionOSCompiler, VisionOSCompiler } from './chunk-S4W6Z2MN.js';
-export { VisionOSCompiler } from './chunk-S4W6Z2MN.js';
+import { init_VisionOSCompiler, VisionOSCompiler } from './chunk-2X7NGX3M.js';
+export { VisionOSCompiler } from './chunk-2X7NGX3M.js';
 export { FileSizeExceededError, IPFSPinError, IPFSService, IPFSUploadError, InfuraProvider, NFTStorageProvider, PinataProvider } from './chunk-WRWEX5ZF.js';
-import { MultiLayerCompiler } from './chunk-62FBK3B7.js';
-export { MultiLayerCompiler } from './chunk-62FBK3B7.js';
-import { init_VRRCompiler, VRRCompiler } from './chunk-T2QCTZMO.js';
-export { VRRCompiler } from './chunk-T2QCTZMO.js';
+import { MultiLayerCompiler } from './chunk-FFAOS5HQ.js';
+export { MultiLayerCompiler } from './chunk-FFAOS5HQ.js';
+import { init_VRRCompiler, VRRCompiler } from './chunk-4SDKXQ4C.js';
+export { VRRCompiler } from './chunk-4SDKXQ4C.js';
 import { init_ARCompiler, ARCompiler } from './chunk-UJXISJBN.js';
 export { ARCompiler } from './chunk-UJXISJBN.js';
-import { init_OpenXRCompiler, OpenXRCompiler } from './chunk-23J755AR.js';
-export { OpenXRCompiler } from './chunk-23J755AR.js';
-import { init_VRChatCompiler, VRChatCompiler } from './chunk-BE4UJCQT.js';
-export { VRChatCompiler, compileToVRChat } from './chunk-BE4UJCQT.js';
-import { init_BabylonCompiler, BabylonCompiler } from './chunk-PHVRG4I2.js';
-export { BabylonCompiler } from './chunk-PHVRG4I2.js';
+import { init_OpenXRCompiler, OpenXRCompiler } from './chunk-QD32ADK6.js';
+export { OpenXRCompiler } from './chunk-QD32ADK6.js';
+import { init_VRChatCompiler, VRChatCompiler } from './chunk-UWJHCOH2.js';
+export { VRChatCompiler, compileToVRChat } from './chunk-UWJHCOH2.js';
+import { init_BabylonCompiler, BabylonCompiler } from './chunk-J7XZV333.js';
+export { BabylonCompiler } from './chunk-J7XZV333.js';
 import { init_Semiring, init_ProvenanceSemiring } from './chunk-TJHVSBP2.js';
 export { AuthorityTier, MaxPlusSemiring, MinPlusSemiring, ProvenanceSemiring, SumProductSemiring, TRAIT_ZERO, authorityWeight, createDeadElement, isDeadElement, strategyToSemiring } from './chunk-TJHVSBP2.js';
 import { init_TraitCompositor, init_composition_rules } from './chunk-4C57PR42.js';
 export { COMPOSITION_RULES, TraitCompositor, TraitVisualRegistry, VISUAL_LAYER_PRIORITY } from './chunk-4C57PR42.js';
-import { init_UnityCompiler, UnityCompiler } from './chunk-ZZEI7MV4.js';
-export { UnityCompiler } from './chunk-ZZEI7MV4.js';
+import { init_UnityCompiler, UnityCompiler } from './chunk-CCATWPXM.js';
+export { UnityCompiler } from './chunk-CCATWPXM.js';
 import { init_PlatformConditional, init_PlatformConditionalCompilerMixin, PLATFORM_CATEGORIES, DEFAULT_EMBODIMENT, platformCategory, ALL_PLATFORMS } from './chunk-GZG4KA4E.js';
 export { ALL_PLATFORMS, DEFAULT_EMBODIMENT, PLATFORM_CAPABILITIES, PLATFORM_CATEGORIES, PlatformConditionalCompilerMixin, ALL_PLATFORMS as XR_ALL_PLATFORMS, PLATFORM_CAPABILITIES as XR_PLATFORM_CAPABILITIES, PLATFORM_CATEGORIES as XR_PLATFORM_CATEGORIES, agentBudgetFor, createPlatformTarget, embodimentFor, filterCompositionForPlatform, hasCapability, matchesPlatform, matchesPlatformConstraint, normalizePlatformName, platformCategory, resolvePlatforms, selectBlock } from './chunk-GZG4KA4E.js';
-import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, compilePostProcessingBlock, compileParticleBlock, compilePhysicsBlock, compileMaterialBlock } from './chunk-JCLBKPMX.js';
-export { architectureToGodot, architectureToR3F, architectureToUSDA, architectureToUnity, architectureToVRChat, compileArchitectureBlock, compileDataVizBlock, compileDomainBlocks, compileEducationBlock, compileHealthcareBlock, compileInputBlock, compileIoTBlock, compileMaterialBlock, compileMusicBlock, compileNarrativeBlock, compileNavigationBlock, compilePaymentBlock, compilePhysicsBlock, compileProceduralBlock, compileRenderingBlock, compileRoboticsBlock, compileWeb3Block, datavizToGodot, datavizToR3F, datavizToUSDA, datavizToUnity, datavizToVRChat, educationToGodot, educationToR3F, educationToUSDA, educationToUnity, educationToVRChat, healthcareToGodot, healthcareToR3F, healthcareToUSDA, healthcareToUnity, healthcareToVRChat, inputToGodot, inputToR3F, inputToUSDA, inputToUnity, inputToVRChat, iotToGodot, iotToR3F, iotToUSDA, iotToUnity, iotToVRChat, materialToGLTF, materialToR3F, materialToUSD, musicToGodot, musicToR3F, musicToUSDA, musicToUnity, musicToVRChat, narrativeToGodot, narrativeToR3F, narrativeToUSDA, narrativeToUnity, narrativeToVRChat, navigationToGodot, navigationToR3F, navigationToUSDA, navigationToUnity, navigationToVRChat, paymentToGodot, paymentToR3F, paymentToUSDA, paymentToUnity, paymentToVRChat, physicsToURDF, proceduralToGodot, proceduralToR3F, proceduralToUSDA, proceduralToUnity, proceduralToVRChat, renderingToGodot, renderingToR3F, renderingToUSDA, renderingToUnity, renderingToVRChat, roboticsToGodot, roboticsToR3F, roboticsToUSDA, roboticsToUnity, roboticsToVRChat, web3ToGodot, web3ToR3F, web3ToUSDA, web3ToUnity, web3ToVRChat } from './chunk-JCLBKPMX.js';
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, compilePostProcessingBlock, compileParticleBlock, compilePhysicsBlock, compileMaterialBlock } from './chunk-BOVPWH4H.js';
+export { architectureToGodot, architectureToR3F, architectureToUSDA, architectureToUnity, architectureToVRChat, compileArchitectureBlock, compileDataVizBlock, compileDomainBlocks, compileEducationBlock, compileHealthcareBlock, compileInputBlock, compileIoTBlock, compileMaterialBlock, compileMusicBlock, compileNarrativeBlock, compileNavigationBlock, compilePaymentBlock, compilePhysicsBlock, compileProceduralBlock, compileRenderingBlock, compileRoboticsBlock, compileWeb3Block, datavizToGodot, datavizToR3F, datavizToUSDA, datavizToUnity, datavizToVRChat, educationToGodot, educationToR3F, educationToUSDA, educationToUnity, educationToVRChat, healthcareToGodot, healthcareToR3F, healthcareToUSDA, healthcareToUnity, healthcareToVRChat, inputToGodot, inputToR3F, inputToUSDA, inputToUnity, inputToVRChat, iotToGodot, iotToR3F, iotToUSDA, iotToUnity, iotToVRChat, materialToGLTF, materialToR3F, materialToUSD, musicToGodot, musicToR3F, musicToUSDA, musicToUnity, musicToVRChat, narrativeToGodot, narrativeToR3F, narrativeToUSDA, narrativeToUnity, narrativeToVRChat, navigationToGodot, navigationToR3F, navigationToUSDA, navigationToUnity, navigationToVRChat, paymentToGodot, paymentToR3F, paymentToUSDA, paymentToUnity, paymentToVRChat, physicsToURDF, proceduralToGodot, proceduralToR3F, proceduralToUSDA, proceduralToUnity, proceduralToVRChat, renderingToGodot, renderingToR3F, renderingToUSDA, renderingToUnity, renderingToVRChat, roboticsToGodot, roboticsToR3F, roboticsToUSDA, roboticsToUnity, roboticsToVRChat, web3ToGodot, web3ToR3F, web3ToUSDA, web3ToUnity, web3ToVRChat } from './chunk-BOVPWH4H.js';
 import { init_CompilerBase, init_CompilerDocumentationGenerator, init_CultureTraits, CompilerBase, CompilerDocumentationGenerator } from './chunk-QPSKHBJP.js';
 export { BUILTIN_NORMS, BUILTIN_NORM_PROVENANCE, CompilerBase, UNKNOWN_NORM_PROVENANCE, criticalMassForChange, deserializeNormProvenance, getBuiltinNorm, normalizeNormProvenance, normsByCategory, serializeNormProvenance } from './chunk-QPSKHBJP.js';
 import './chunk-THCK6ECW.js';
@@ -105,8 +105,8 @@ import './chunk-SIEXCILW.js';
 import './chunk-CBJY23VL.js';
 export { HoloScriptTypeChecker, createTypeChecker } from './chunk-VMLKSV26.js';
 export { BUILTIN_CONSTRAINTS } from './chunk-XSFNHP2E.js';
-import { getSharedEventBus } from './chunk-RARB3MBR.js';
-export { EventBus, getSharedEventBus, setSharedEventBus, telemetry } from './chunk-RARB3MBR.js';
+import { lazyPeerSymbol, getSharedEventBus } from './chunk-IELX2OKI.js';
+export { EventBus, getSharedEventBus, setSharedEventBus, telemetry } from './chunk-IELX2OKI.js';
 import { HoloScriptCodeParser } from './chunk-URG2SJLK.js';
 export { ERROR_CODES, HoloScriptCodeParser, ParserPools } from './chunk-URG2SJLK.js';
 import './chunk-H652NHX5.js';
@@ -114,7 +114,7 @@ import { logger } from './chunk-PHENW4MQ.js';
 export { ConsoleLogger, NoOpLogger, enableConsoleLogging, logger, resetLogger, setHoloScriptLogger } from './chunk-PHENW4MQ.js';
 import { init_safeJsonParse, readJson, jsonClone } from './chunk-VVKVQZI6.js';
 export { jsonClone, readJson, safeJsonParse, safeJsonParseSchema, tryParseJson } from './chunk-VVKVQZI6.js';
-import { __export, __require } from './chunk-OL46QLBJ.js';
+import { __commonJS, __export, __publicField, __require } from './chunk-OL46QLBJ.js';
 import * as fs2 from 'fs';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync, statSync } from 'fs';
 import * as path3 from 'path';
@@ -125,9 +125,1393 @@ import { inflateSync, deflateSync } from 'zlib';
 import { EventEmitter } from 'events';
 import { canonicalizeManifest, verifySignature } from '@holoscript/platform';
 export { canonicalizeManifest, checkRateLimit, createDefaultPolicy, createPackageManifest, createSandbox, createStrictPolicy, decrypt, deriveKey, destroy as destroySandbox, encrypt, execute as executeSandbox, exportKey, generateEncryptionKey, generateKeyPair, hmacSha256, importKey, randomBytes, randomHex, randomUUID, resetRateLimit, sanitizeInput, sha256, sha512, signPackage, validateApiKey, validateUrl, validateWalletAddress, verifyHmacSha256, verifySignature } from '@holoscript/platform';
-import { createRequire } from 'module';
 import { Worker } from 'worker_threads';
 
+// ../holo-vm/dist/index.cjs
+var require_dist = __commonJS({
+  "../holo-vm/dist/index.cjs"(exports$1) {
+    var HoloOpCode = /* @__PURE__ */ ((HoloOpCode2) => {
+      HoloOpCode2[HoloOpCode2["SPAWN"] = 1] = "SPAWN";
+      HoloOpCode2[HoloOpCode2["DESPAWN"] = 2] = "DESPAWN";
+      HoloOpCode2[HoloOpCode2["CLONE"] = 3] = "CLONE";
+      HoloOpCode2[HoloOpCode2["SET_COMPONENT"] = 4] = "SET_COMPONENT";
+      HoloOpCode2[HoloOpCode2["GET_COMPONENT"] = 5] = "GET_COMPONENT";
+      HoloOpCode2[HoloOpCode2["REMOVE_COMPONENT"] = 6] = "REMOVE_COMPONENT";
+      HoloOpCode2[HoloOpCode2["SET_PARENT"] = 7] = "SET_PARENT";
+      HoloOpCode2[HoloOpCode2["QUERY"] = 8] = "QUERY";
+      HoloOpCode2[HoloOpCode2["TRANSFORM"] = 16] = "TRANSFORM";
+      HoloOpCode2[HoloOpCode2["TRANSLATE"] = 17] = "TRANSLATE";
+      HoloOpCode2[HoloOpCode2["ROTATE"] = 18] = "ROTATE";
+      HoloOpCode2[HoloOpCode2["LOOK_AT"] = 19] = "LOOK_AT";
+      HoloOpCode2[HoloOpCode2["RAYCAST"] = 20] = "RAYCAST";
+      HoloOpCode2[HoloOpCode2["QUERY_BOX"] = 21] = "QUERY_BOX";
+      HoloOpCode2[HoloOpCode2["QUERY_SPHERE"] = 22] = "QUERY_SPHERE";
+      HoloOpCode2[HoloOpCode2["FIND_PATH"] = 23] = "FIND_PATH";
+      HoloOpCode2[HoloOpCode2["GET_ZONE"] = 24] = "GET_ZONE";
+      HoloOpCode2[HoloOpCode2["ADD_RIGIDBODY"] = 32] = "ADD_RIGIDBODY";
+      HoloOpCode2[HoloOpCode2["APPLY_FORCE"] = 33] = "APPLY_FORCE";
+      HoloOpCode2[HoloOpCode2["APPLY_IMPULSE"] = 34] = "APPLY_IMPULSE";
+      HoloOpCode2[HoloOpCode2["SET_VELOCITY"] = 35] = "SET_VELOCITY";
+      HoloOpCode2[HoloOpCode2["ADD_COLLIDER"] = 36] = "ADD_COLLIDER";
+      HoloOpCode2[HoloOpCode2["ADD_JOINT"] = 37] = "ADD_JOINT";
+      HoloOpCode2[HoloOpCode2["SET_GRAVITY"] = 38] = "SET_GRAVITY";
+      HoloOpCode2[HoloOpCode2["PHYSICS_STEP"] = 39] = "PHYSICS_STEP";
+      HoloOpCode2[HoloOpCode2["SET_GEOMETRY"] = 48] = "SET_GEOMETRY";
+      HoloOpCode2[HoloOpCode2["SET_MATERIAL"] = 49] = "SET_MATERIAL";
+      HoloOpCode2[HoloOpCode2["SET_VISIBLE"] = 50] = "SET_VISIBLE";
+      HoloOpCode2[HoloOpCode2["SET_LOD"] = 51] = "SET_LOD";
+      HoloOpCode2[HoloOpCode2["SET_LIGHT"] = 52] = "SET_LIGHT";
+      HoloOpCode2[HoloOpCode2["SET_ANIMATION"] = 53] = "SET_ANIMATION";
+      HoloOpCode2[HoloOpCode2["SET_GAUSSIAN_SPLAT"] = 54] = "SET_GAUSSIAN_SPLAT";
+      HoloOpCode2[HoloOpCode2["SET_PARTICLE_SYSTEM"] = 55] = "SET_PARTICLE_SYSTEM";
+      HoloOpCode2[HoloOpCode2["APPLY_TRAIT"] = 64] = "APPLY_TRAIT";
+      HoloOpCode2[HoloOpCode2["REMOVE_TRAIT"] = 65] = "REMOVE_TRAIT";
+      HoloOpCode2[HoloOpCode2["RESOLVE_TRAITS"] = 66] = "RESOLVE_TRAITS";
+      HoloOpCode2[HoloOpCode2["EMIT_EVENT"] = 67] = "EMIT_EVENT";
+      HoloOpCode2[HoloOpCode2["ON_EVENT"] = 68] = "ON_EVENT";
+      HoloOpCode2[HoloOpCode2["EVAL_CONDITION"] = 69] = "EVAL_CONDITION";
+      HoloOpCode2[HoloOpCode2["LOAD_ASSET"] = 80] = "LOAD_ASSET";
+      HoloOpCode2[HoloOpCode2["PLAY_AUDIO"] = 81] = "PLAY_AUDIO";
+      HoloOpCode2[HoloOpCode2["NET_SYNC"] = 82] = "NET_SYNC";
+      HoloOpCode2[HoloOpCode2["NET_SEND"] = 83] = "NET_SEND";
+      HoloOpCode2[HoloOpCode2["NET_RECV"] = 84] = "NET_RECV";
+      HoloOpCode2[HoloOpCode2["XR_INPUT"] = 85] = "XR_INPUT";
+      HoloOpCode2[HoloOpCode2["HAPTIC"] = 86] = "HAPTIC";
+      HoloOpCode2[HoloOpCode2["NOP"] = 96] = "NOP";
+      HoloOpCode2[HoloOpCode2["JUMP"] = 97] = "JUMP";
+      HoloOpCode2[HoloOpCode2["JUMP_IF"] = 98] = "JUMP_IF";
+      HoloOpCode2[HoloOpCode2["CALL"] = 99] = "CALL";
+      HoloOpCode2[HoloOpCode2["RETURN"] = 100] = "RETURN";
+      HoloOpCode2[HoloOpCode2["PUSH"] = 101] = "PUSH";
+      HoloOpCode2[HoloOpCode2["POP"] = 102] = "POP";
+      HoloOpCode2[HoloOpCode2["STORE"] = 103] = "STORE";
+      HoloOpCode2[HoloOpCode2["LOAD"] = 104] = "LOAD";
+      HoloOpCode2[HoloOpCode2["HALT"] = 105] = "HALT";
+      HoloOpCode2[HoloOpCode2["YIELD"] = 106] = "YIELD";
+      HoloOpCode2[HoloOpCode2["TIMER"] = 107] = "TIMER";
+      HoloOpCode2[HoloOpCode2["ADD"] = 108] = "ADD";
+      HoloOpCode2[HoloOpCode2["SUB"] = 109] = "SUB";
+      HoloOpCode2[HoloOpCode2["MUL"] = 110] = "MUL";
+      HoloOpCode2[HoloOpCode2["DIV"] = 111] = "DIV";
+      HoloOpCode2[HoloOpCode2["AGENT_INVOKE"] = 112] = "AGENT_INVOKE";
+      HoloOpCode2[HoloOpCode2["AGENT_READ"] = 113] = "AGENT_READ";
+      HoloOpCode2[HoloOpCode2["AGENT_SUBSCRIBE"] = 114] = "AGENT_SUBSCRIBE";
+      HoloOpCode2[HoloOpCode2["DIALOG_SHOW"] = 115] = "DIALOG_SHOW";
+      HoloOpCode2[HoloOpCode2["QUEST_UPDATE"] = 116] = "QUEST_UPDATE";
+      HoloOpCode2[HoloOpCode2["CMP_EQ"] = 128] = "CMP_EQ";
+      HoloOpCode2[HoloOpCode2["CMP_LT"] = 129] = "CMP_LT";
+      HoloOpCode2[HoloOpCode2["CMP_GT"] = 130] = "CMP_GT";
+      HoloOpCode2[HoloOpCode2["NOT"] = 131] = "NOT";
+      return HoloOpCode2;
+    })(HoloOpCode || {});
+    var ComponentType3 = /* @__PURE__ */ ((ComponentType22) => {
+      ComponentType22[ComponentType22["Transform"] = 1] = "Transform";
+      ComponentType22[ComponentType22["Geometry"] = 2] = "Geometry";
+      ComponentType22[ComponentType22["Material"] = 3] = "Material";
+      ComponentType22[ComponentType22["RigidBody"] = 4] = "RigidBody";
+      ComponentType22[ComponentType22["Collider"] = 5] = "Collider";
+      ComponentType22[ComponentType22["Light"] = 6] = "Light";
+      ComponentType22[ComponentType22["Animation"] = 7] = "Animation";
+      ComponentType22[ComponentType22["Audio"] = 8] = "Audio";
+      ComponentType22[ComponentType22["Network"] = 9] = "Network";
+      ComponentType22[ComponentType22["Trait"] = 10] = "Trait";
+      ComponentType22[ComponentType22["ParticleSystem"] = 11] = "ParticleSystem";
+      ComponentType22[ComponentType22["GaussianSplat"] = 12] = "GaussianSplat";
+      ComponentType22[ComponentType22["LOD"] = 13] = "LOD";
+      ComponentType22[ComponentType22["Custom"] = 255] = "Custom";
+      return ComponentType22;
+    })(ComponentType3 || {});
+    var GeometryType2 = /* @__PURE__ */ ((GeometryType3) => {
+      GeometryType3[GeometryType3["Cube"] = 1] = "Cube";
+      GeometryType3[GeometryType3["Sphere"] = 2] = "Sphere";
+      GeometryType3[GeometryType3["Cylinder"] = 3] = "Cylinder";
+      GeometryType3[GeometryType3["Plane"] = 4] = "Plane";
+      GeometryType3[GeometryType3["Cone"] = 5] = "Cone";
+      GeometryType3[GeometryType3["Torus"] = 6] = "Torus";
+      GeometryType3[GeometryType3["Capsule"] = 7] = "Capsule";
+      GeometryType3[GeometryType3["Mesh"] = 8] = "Mesh";
+      GeometryType3[GeometryType3["Text3D"] = 9] = "Text3D";
+      GeometryType3[GeometryType3["Portal"] = 10] = "Portal";
+      GeometryType3[GeometryType3["Terrain"] = 11] = "Terrain";
+      GeometryType3[GeometryType3["Skybox"] = 12] = "Skybox";
+      GeometryType3[GeometryType3["Billboard"] = 13] = "Billboard";
+      GeometryType3[GeometryType3["Line"] = 14] = "Line";
+      return GeometryType3;
+    })(GeometryType2 || {});
+    var BodyType2 = /* @__PURE__ */ ((BodyType22) => {
+      BodyType22[BodyType22["Static"] = 0] = "Static";
+      BodyType22[BodyType22["Dynamic"] = 1] = "Dynamic";
+      BodyType22[BodyType22["Kinematic"] = 2] = "Kinematic";
+      return BodyType22;
+    })(BodyType2 || {});
+    var ColliderShape = /* @__PURE__ */ ((ColliderShape2) => {
+      ColliderShape2[ColliderShape2["Box"] = 1] = "Box";
+      ColliderShape2[ColliderShape2["Sphere"] = 2] = "Sphere";
+      ColliderShape2[ColliderShape2["Capsule"] = 3] = "Capsule";
+      ColliderShape2[ColliderShape2["Cylinder"] = 4] = "Cylinder";
+      ColliderShape2[ColliderShape2["ConvexHull"] = 5] = "ConvexHull";
+      ColliderShape2[ColliderShape2["TriMesh"] = 6] = "TriMesh";
+      return ColliderShape2;
+    })(ColliderShape || {});
+    var LightType2 = /* @__PURE__ */ ((LightType22) => {
+      LightType22[LightType22["Directional"] = 1] = "Directional";
+      LightType22[LightType22["Point"] = 2] = "Point";
+      LightType22[LightType22["Spot"] = 3] = "Spot";
+      LightType22[LightType22["Ambient"] = 4] = "Ambient";
+      LightType22[LightType22["Area"] = 5] = "Area";
+      return LightType22;
+    })(LightType2 || {});
+    var SyncTier = /* @__PURE__ */ ((SyncTier2) => {
+      SyncTier2[SyncTier2["Physics"] = 0] = "Physics";
+      SyncTier2[SyncTier2["Movement"] = 1] = "Movement";
+      SyncTier2[SyncTier2["AIAgent"] = 2] = "AIAgent";
+      SyncTier2[SyncTier2["Cosmetic"] = 3] = "Cosmetic";
+      return SyncTier2;
+    })(SyncTier || {});
+    var ValueType = /* @__PURE__ */ ((ValueType2) => {
+      ValueType2[ValueType2["Null"] = 0] = "Null";
+      ValueType2[ValueType2["Bool"] = 1] = "Bool";
+      ValueType2[ValueType2["I32"] = 2] = "I32";
+      ValueType2[ValueType2["F32"] = 3] = "F32";
+      ValueType2[ValueType2["F64"] = 4] = "F64";
+      ValueType2[ValueType2["String"] = 5] = "String";
+      ValueType2[ValueType2["Vec3"] = 6] = "Vec3";
+      ValueType2[ValueType2["Quat"] = 7] = "Quat";
+      ValueType2[ValueType2["EntityRef"] = 8] = "EntityRef";
+      ValueType2[ValueType2["Array"] = 9] = "Array";
+      return ValueType2;
+    })(ValueType || {});
+    var FAMILY_NAMES = {
+      0: "Entity",
+      1: "Spatial",
+      2: "Physics",
+      3: "Rendering",
+      4: "Trait",
+      5: "I/O",
+      6: "Control",
+      7: "Agent",
+      8: "Comparison"
+    };
+    function getOpcodeFamily(opcode) {
+      const familyByte = opcode >> 4 & 15;
+      return FAMILY_NAMES[familyByte] ?? "Unknown";
+    }
+    function getOpcodeName(opcode) {
+      return HoloOpCode[opcode] ?? `UNKNOWN_0x${opcode.toString(16).padStart(2, "0")}`;
+    }
+    function isControlFlow(opcode) {
+      return opcode === 97 || opcode === 98 || opcode === 99 || opcode === 100 || opcode === 105 || opcode === 106;
+    }
+    var HOLOB_MAGIC = 1213156418;
+    var HOLOB_VERSION = 1;
+    var HolobFlags = /* @__PURE__ */ ((HolobFlags2) => {
+      HolobFlags2[HolobFlags2["None"] = 0] = "None";
+      HolobFlags2[HolobFlags2["Debug"] = 1] = "Debug";
+      HolobFlags2[HolobFlags2["SIMD"] = 2] = "SIMD";
+      HolobFlags2[HolobFlags2["Threads"] = 4] = "Threads";
+      HolobFlags2[HolobFlags2["Networking"] = 8] = "Networking";
+      HolobFlags2[HolobFlags2["Physics"] = 16] = "Physics";
+      return HolobFlags2;
+    })(HolobFlags || {});
+    var AssetType = /* @__PURE__ */ ((AssetType2) => {
+      AssetType2[AssetType2["Mesh"] = 1] = "Mesh";
+      AssetType2[AssetType2["Texture"] = 2] = "Texture";
+      AssetType2[AssetType2["Audio"] = 3] = "Audio";
+      AssetType2[AssetType2["Animation"] = 4] = "Animation";
+      AssetType2[AssetType2["GaussianSplat"] = 5] = "GaussianSplat";
+      AssetType2[AssetType2["Font"] = 6] = "Font";
+      AssetType2[AssetType2["Script"] = 7] = "Script";
+      return AssetType2;
+    })(AssetType || {});
+    var HoloBytecodeBuilder2 = class {
+      constructor() {
+        __publicField(this, "strings", /* @__PURE__ */ new Map());
+        __publicField(this, "stringList", []);
+        __publicField(this, "assets", []);
+        __publicField(this, "traits", []);
+        __publicField(this, "functions", []);
+        __publicField(this, "entities", []);
+        __publicField(this, "events", []);
+        __publicField(this, "flags", 0);
+      }
+      /**
+       * Intern a string and return its index
+       */
+      internString(str) {
+        const existing = this.strings.get(str);
+        if (existing !== void 0) return existing;
+        const idx = this.stringList.length;
+        this.stringList.push(str);
+        this.strings.set(str, idx);
+        return idx;
+      }
+      /**
+       * Add a feature flag
+       */
+      addFlag(flag) {
+        this.flags |= flag;
+        return this;
+      }
+      /**
+       * Add an asset reference
+       */
+      addAsset(uri, type) {
+        const idx = this.assets.length;
+        this.assets.push({ uriIndex: this.internString(uri), type });
+        return idx;
+      }
+      /**
+       * Add a trait definition
+       */
+      addTrait(name, deps = [], initFunc = -1) {
+        const idx = this.traits.length;
+        this.traits.push({
+          nameIndex: this.internString(name),
+          dependencies: deps,
+          initFunctionIndex: initFunc,
+          eventHandlers: /* @__PURE__ */ new Map()
+        });
+        return idx;
+      }
+      /**
+       * Begin building a function
+       */
+      addFunction(name, paramCount = 0) {
+        const idx = this.functions.length;
+        const fn = {
+          nameIndex: this.internString(name),
+          instructions: [],
+          registerCount: 0,
+          paramCount
+        };
+        this.functions.push(fn);
+        return new HoloFunctionBuilder(fn, this, idx);
+      }
+      /**
+       * Add an entity definition
+       */
+      addEntity(name, archetype = 0, parentIndex = -1) {
+        const idx = this.entities.length;
+        this.entities.push({
+          nameIndex: this.internString(name),
+          archetype,
+          components: [],
+          parentIndex
+        });
+        return idx;
+      }
+      /**
+       * Add component data to an entity
+       */
+      addComponentToEntity(entityIdx, componentType, values) {
+        this.entities[entityIdx].components.push({ componentType, values });
+        return this;
+      }
+      /**
+       * Add an event binding
+       */
+      addEvent(eventType, handlerFunctionIndex, entityFilter = -1) {
+        this.events.push({ eventType, handlerFunctionIndex, entityFilter });
+        return this;
+      }
+      /**
+       * Build the final bytecode module
+       */
+      build() {
+        return {
+          magic: HOLOB_MAGIC,
+          version: HOLOB_VERSION,
+          flags: this.flags,
+          strings: [...this.stringList],
+          assets: [...this.assets],
+          traits: [...this.traits],
+          functions: [...this.functions],
+          entities: [...this.entities],
+          events: [...this.events]
+        };
+      }
+    };
+    var HoloFunctionBuilder = class {
+      constructor(func, parent, index) {
+        this.func = func;
+        this.parent = parent;
+        this.index = index;
+      }
+      emit(opcode, ...operands) {
+        this.func.instructions.push({ opcode, operands });
+        return this;
+      }
+      // ── Entity ────────────────────────────────────────────────────────────────
+      spawn(entityType, name) {
+        return this.emit(1, entityType, this.parent.internString(name));
+      }
+      despawn(entityId) {
+        return this.emit(2, entityId);
+      }
+      setComponent(entityId, compType, ...data) {
+        return this.emit(4, entityId, compType, ...data);
+      }
+      getComponent(entityId, compType) {
+        return this.emit(5, entityId, compType);
+      }
+      setParent(childId, parentId) {
+        return this.emit(7, childId, parentId);
+      }
+      query(archetypeMask) {
+        return this.emit(8, archetypeMask);
+      }
+      // ── Spatial ───────────────────────────────────────────────────────────────
+      transform(entityId, x, y, z) {
+        return this.emit(16, entityId, x, y, z, 0, 0, 0, 1, 1, 1, 1);
+      }
+      translate(entityId, dx, dy, dz) {
+        return this.emit(17, entityId, dx, dy, dz);
+      }
+      rotate(entityId, qx, qy, qz, qw) {
+        return this.emit(18, entityId, qx, qy, qz, qw);
+      }
+      lookAt(entityId, tx, ty, tz) {
+        return this.emit(19, entityId, tx, ty, tz);
+      }
+      raycast(ox, oy, oz, dx, dy, dz, maxDist) {
+        return this.emit(20, ox, oy, oz, dx, dy, dz, maxDist);
+      }
+      // ── Physics ───────────────────────────────────────────────────────────────
+      addRigidbody(entityId, mass, bodyType) {
+        return this.emit(32, entityId, mass, bodyType);
+      }
+      applyForce(entityId, fx, fy, fz) {
+        return this.emit(33, entityId, fx, fy, fz);
+      }
+      applyImpulse(entityId, ix, iy, iz) {
+        return this.emit(34, entityId, ix, iy, iz);
+      }
+      setGravity(gx, gy, gz) {
+        return this.emit(38, gx, gy, gz);
+      }
+      physicsStep(dt) {
+        return this.emit(39, dt);
+      }
+      // ── Rendering Hints ───────────────────────────────────────────────────────
+      setGeometry(entityId, geoType) {
+        return this.emit(48, entityId, geoType);
+      }
+      setMaterial(entityId, ...desc) {
+        return this.emit(49, entityId, ...desc);
+      }
+      setVisible(entityId, visible) {
+        return this.emit(50, entityId, visible ? 1 : 0);
+      }
+      setLight(entityId, lightType, ...params) {
+        return this.emit(52, entityId, lightType, ...params);
+      }
+      setAnimation(entityId, animId) {
+        return this.emit(53, entityId, animId);
+      }
+      // ── Trait ─────────────────────────────────────────────────────────────────
+      applyTrait(entityId, traitId) {
+        return this.emit(64, entityId, traitId);
+      }
+      removeTrait(entityId, traitId) {
+        return this.emit(65, entityId, traitId);
+      }
+      emitEvent(eventType, ...payload) {
+        return this.emit(67, eventType, ...payload);
+      }
+      onEvent(eventType, handlerOffset) {
+        return this.emit(68, eventType, handlerOffset);
+      }
+      // ── I/O ───────────────────────────────────────────────────────────────────
+      loadAsset(uri, assetType) {
+        return this.emit(80, this.parent.internString(uri), assetType);
+      }
+      playAudio(soundId, x, y, z) {
+        return this.emit(81, soundId, x, y, z);
+      }
+      netSync(entityId, syncTier) {
+        return this.emit(82, entityId, syncTier);
+      }
+      // ── Control Flow ──────────────────────────────────────────────────────────
+      nop() {
+        return this.emit(
+          96
+          /* NOP */
+        );
+      }
+      jump(offset) {
+        return this.emit(97, offset);
+      }
+      jumpIf(offset) {
+        return this.emit(98, offset);
+      }
+      call(funcIdx) {
+        return this.emit(99, funcIdx);
+      }
+      ret() {
+        return this.emit(
+          100
+          /* RETURN */
+        );
+      }
+      push(value) {
+        return this.emit(101, value);
+      }
+      pop() {
+        return this.emit(
+          102
+          /* POP */
+        );
+      }
+      store(registerIdx) {
+        this.func.registerCount = Math.max(this.func.registerCount, registerIdx + 1);
+        return this.emit(103, registerIdx);
+      }
+      load(registerIdx) {
+        return this.emit(104, registerIdx);
+      }
+      halt() {
+        return this.emit(
+          105
+          /* HALT */
+        );
+      }
+      yieldTick() {
+        return this.emit(
+          106
+          /* YIELD */
+        );
+      }
+      timer(delayMs, handlerOffset) {
+        return this.emit(107, delayMs, handlerOffset);
+      }
+      // ── Arithmetic ────────────────────────────────────────────────────────────
+      add() {
+        return this.emit(
+          108
+          /* ADD */
+        );
+      }
+      sub() {
+        return this.emit(
+          109
+          /* SUB */
+        );
+      }
+      mul() {
+        return this.emit(
+          110
+          /* MUL */
+        );
+      }
+      div() {
+        return this.emit(
+          111
+          /* DIV */
+        );
+      }
+      // ── Comparison ────────────────────────────────────────────────────────────
+      cmpEq() {
+        return this.emit(
+          128
+          /* CMP_EQ */
+        );
+      }
+      cmpLt() {
+        return this.emit(
+          129
+          /* CMP_LT */
+        );
+      }
+      cmpGt() {
+        return this.emit(
+          130
+          /* CMP_GT */
+        );
+      }
+      not() {
+        return this.emit(
+          131
+          /* NOT */
+        );
+      }
+      // ── Agent Bridge ──────────────────────────────────────────────────────────
+      agentInvoke(agentId, actionIdx) {
+        return this.emit(112, agentId, actionIdx);
+      }
+      agentRead(agentId, fieldIdx) {
+        return this.emit(113, agentId, fieldIdx);
+      }
+      dialogShow(npcId, dialogTreeId) {
+        return this.emit(115, npcId, dialogTreeId);
+      }
+      questUpdate(questId, state) {
+        return this.emit(116, questId, state);
+      }
+      /** Get the current instruction count (useful for jump targets) */
+      get instructionCount() {
+        return this.func.instructions.length;
+      }
+    };
+    var ECSWorld2 = class {
+      constructor() {
+        __publicField(this, "entities", /* @__PURE__ */ new Map());
+        __publicField(this, "nextEntityId", 1);
+        __publicField(this, "archetypeIndex", /* @__PURE__ */ new Map());
+      }
+      /**
+       * Spawn a new entity
+       */
+      spawn(name, archetype = 0) {
+        const id = this.nextEntityId++;
+        const entity = {
+          id,
+          name,
+          parentId: -1,
+          childIds: [],
+          components: /* @__PURE__ */ new Map(),
+          traits: /* @__PURE__ */ new Set(),
+          alive: true,
+          dirty: true
+        };
+        this.entities.set(id, entity);
+        if (!this.archetypeIndex.has(archetype)) {
+          this.archetypeIndex.set(archetype, /* @__PURE__ */ new Set());
+        }
+        this.archetypeIndex.get(archetype).add(id);
+        return id;
+      }
+      /**
+       * Despawn an entity and its children
+       */
+      despawn(entityId) {
+        const entity = this.entities.get(entityId);
+        if (!entity) return false;
+        for (const childId of [...entity.childIds]) {
+          this.despawn(childId);
+        }
+        if (entity.parentId !== -1) {
+          const parent = this.entities.get(entity.parentId);
+          if (parent) {
+            parent.childIds = parent.childIds.filter((id) => id !== entityId);
+          }
+        }
+        entity.alive = false;
+        this.entities.delete(entityId);
+        return true;
+      }
+      /**
+       * Set a component on an entity
+       */
+      setComponent(entityId, componentType, data) {
+        const entity = this.entities.get(entityId);
+        if (!entity) return false;
+        entity.components.set(componentType, data);
+        entity.dirty = true;
+        return true;
+      }
+      /**
+       * Get a component from an entity
+       */
+      getComponent(entityId, componentType) {
+        const entity = this.entities.get(entityId);
+        if (!entity) return void 0;
+        return entity.components.get(componentType);
+      }
+      /**
+       * Remove a component from an entity
+       */
+      removeComponent(entityId, componentType) {
+        const entity = this.entities.get(entityId);
+        if (!entity) return false;
+        entity.dirty = true;
+        return entity.components.delete(componentType);
+      }
+      /**
+       * Set parent-child relationship
+       */
+      setParent(childId, parentId) {
+        const child = this.entities.get(childId);
+        const parent = this.entities.get(parentId);
+        if (!child || !parent) return false;
+        if (child.parentId !== -1) {
+          const oldParent = this.entities.get(child.parentId);
+          if (oldParent) {
+            oldParent.childIds = oldParent.childIds.filter((id) => id !== childId);
+          }
+        }
+        child.parentId = parentId;
+        parent.childIds.push(childId);
+        child.dirty = true;
+        return true;
+      }
+      /**
+       * Query entities by archetype mask
+       */
+      queryArchetype(mask) {
+        const set = this.archetypeIndex.get(mask);
+        return set ? [...set] : [];
+      }
+      /**
+       * Get entity by ID
+       */
+      getEntity(entityId) {
+        return this.entities.get(entityId);
+      }
+      /**
+       * Get all dirty entities and clear dirty flags
+       */
+      flushDirty() {
+        const dirty = [];
+        for (const entity of this.entities.values()) {
+          if (entity.dirty) {
+            dirty.push(entity);
+            entity.dirty = false;
+          }
+        }
+        return dirty;
+      }
+      /**
+       * Get all living entities
+       */
+      getAllEntities() {
+        return [...this.entities.values()];
+      }
+      /**
+       * Get entity count
+       */
+      get entityCount() {
+        return this.entities.size;
+      }
+    };
+    var VMStatus = /* @__PURE__ */ ((VMStatus2) => {
+      VMStatus2["Idle"] = "IDLE";
+      VMStatus2["Running"] = "RUNNING";
+      VMStatus2["Yielded"] = "YIELDED";
+      VMStatus2["Halted"] = "HALTED";
+      VMStatus2["Error"] = "ERROR";
+      return VMStatus2;
+    })(VMStatus || {});
+    var UnsupportedHostOpcodeError = class extends Error {
+      constructor(opcode, operands) {
+        const opcodeName = getOpcodeName(opcode);
+        const opcodeGroup = getHostOpcodeGroup(opcode);
+        super(
+          `Unsupported host opcode ${opcodeName} (${opcodeGroup}) requires a registered host callback`
+        );
+        __publicField(this, "opcode");
+        __publicField(this, "opcodeName");
+        __publicField(this, "opcodeGroup");
+        __publicField(this, "operands");
+        this.name = "UnsupportedHostOpcodeError";
+        this.opcode = opcode;
+        this.opcodeName = opcodeName;
+        this.opcodeGroup = opcodeGroup;
+        this.operands = [...operands];
+      }
+    };
+    var HoloVM = class {
+      constructor(hostCallbacks = {}) {
+        // Core state
+        __publicField(this, "bytecode", null);
+        __publicField(this, "world", new ECSWorld2());
+        // Execution state
+        __publicField(this, "stack", []);
+        __publicField(this, "callStack", []);
+        __publicField(this, "status", "IDLE");
+        __publicField(this, "tickCount", 0);
+        // Timer system
+        __publicField(this, "timers", []);
+        __publicField(this, "currentTimeMs", 0);
+        // Event queue
+        __publicField(this, "eventQueue", []);
+        // Limits
+        __publicField(this, "maxStackSize", 4096);
+        __publicField(this, "maxCallDepth", 256);
+        __publicField(this, "maxInstructionsPerTick", 1e4);
+        __publicField(this, "hostCallbacks", /* @__PURE__ */ new Map());
+        __publicField(this, "lastError");
+        this.registerHostCallbacks(hostCallbacks);
+      }
+      /**
+       * Load a bytecode module into the VM
+       */
+      load(bytecode) {
+        this.bytecode = bytecode;
+        this.reset();
+        this.initializeEntities();
+      }
+      /**
+       * Reset VM state without unloading bytecode
+       */
+      reset() {
+        this.stack = [];
+        this.callStack = [];
+        this.status = "IDLE";
+        this.tickCount = 0;
+        this.timers = [];
+        this.currentTimeMs = 0;
+        this.eventQueue = [];
+        this.lastError = void 0;
+      }
+      registerHostCallback(opcode, callback) {
+        if (!isHostOpcode(opcode)) {
+          throw new Error(`Opcode ${getOpcodeName(opcode)} is not a host-integration opcode`);
+        }
+        this.hostCallbacks.set(opcode, callback);
+      }
+      registerHostCallbacks(callbacks) {
+        for (const [opcode, callback] of Object.entries(callbacks)) {
+          if (callback) {
+            this.registerHostCallback(Number(opcode), callback);
+          }
+        }
+      }
+      /**
+       * Initialize entities from the bytecode's init section
+       */
+      initializeEntities() {
+        if (!this.bytecode) return;
+        for (const entityDef of this.bytecode.entities) {
+          const name = this.bytecode.strings[entityDef.nameIndex] ?? `entity_${entityDef.nameIndex}`;
+          const entityId = this.world.spawn(name, entityDef.archetype);
+          for (const comp of entityDef.components) {
+            this.world.setComponent(entityId, comp.componentType, comp.values);
+          }
+          if (entityDef.parentIndex >= 0) {
+            this.world.setParent(entityId, entityDef.parentIndex + 1);
+          }
+        }
+      }
+      /**
+       * Execute one tick of the VM (called at ~90fps)
+       *
+       * Each tick:
+       * 1. Process expired timers
+       * 2. Dispatch queued events
+       * 3. Resume execution from yield point (or run init)
+       * 4. Return dirty entities for rendering
+       */
+      tick(deltaMs) {
+        if (!this.bytecode) {
+          this.lastError = new Error("No bytecode loaded");
+          return {
+            status: "ERROR",
+            stackTop: null,
+            tickCount: this.tickCount,
+            entityCount: 0,
+            error: "No bytecode loaded"
+          };
+        }
+        this.tickCount++;
+        this.currentTimeMs += deltaMs;
+        this.processTimers();
+        this.dispatchEvents();
+        if (this.status === "YIELDED") {
+          this.status = "RUNNING";
+          this.executeInstructions();
+        } else if (this.status === "IDLE" && this.bytecode.functions.length > 0) {
+          this.callFunction(0);
+          this.executeInstructions();
+        }
+        return {
+          status: this.status,
+          stackTop: this.stack.length > 0 ? this.stack[this.stack.length - 1] : null,
+          tickCount: this.tickCount,
+          entityCount: this.world.entityCount,
+          error: this.status === "ERROR" ? this.lastError?.message : void 0
+        };
+      }
+      /**
+       * Main execution loop — runs until YIELD, HALT, or instruction limit
+       */
+      executeInstructions() {
+        if (!this.bytecode) return;
+        let instructionsExecuted = 0;
+        while (this.status === "RUNNING" && instructionsExecuted < this.maxInstructionsPerTick) {
+          const frame = this.currentFrame;
+          if (!frame) {
+            this.status = "HALTED";
+            break;
+          }
+          const func = this.bytecode.functions[frame.functionIndex];
+          if (!func || frame.pc >= func.instructions.length) {
+            this.callStack.pop();
+            if (this.callStack.length === 0) {
+              this.status = "HALTED";
+            }
+            break;
+          }
+          const instr = func.instructions[frame.pc];
+          frame.pc++;
+          instructionsExecuted++;
+          try {
+            this.executeInstruction(instr, frame);
+          } catch (err) {
+            this.status = "ERROR";
+            this.lastError = err instanceof Error ? err : new Error(String(err));
+            break;
+          }
+          if (this.status !== "RUNNING") break;
+        }
+      }
+      /**
+       * Execute a single instruction
+       */
+      executeInstruction(instr, frame) {
+        const op = instr.opcode;
+        const operands = instr.operands;
+        switch (op) {
+          // ── Entity Operations ───────────────────────────────────────────────
+          case 1: {
+            const entityType = operands[0];
+            const nameIdx = operands[1];
+            const name = this.getString(nameIdx);
+            const id = this.world.spawn(name, entityType);
+            this.push(id);
+            break;
+          }
+          case 2: {
+            const entityId = operands[0];
+            this.world.despawn(entityId);
+            break;
+          }
+          case 4: {
+            const entityId = operands[0];
+            const compType = operands[1];
+            const data = operands.slice(2);
+            this.world.setComponent(entityId, compType, data);
+            break;
+          }
+          case 5: {
+            const entityId = operands[0];
+            const compType = operands[1];
+            const data = this.world.getComponent(entityId, compType);
+            this.push(data ?? null);
+            break;
+          }
+          case 6: {
+            const entityId = operands[0];
+            const compType = operands[1];
+            this.world.removeComponent(entityId, compType);
+            break;
+          }
+          case 7: {
+            const childId = operands[0];
+            const parentId = operands[1];
+            this.world.setParent(childId, parentId);
+            break;
+          }
+          case 8: {
+            const mask = operands[0];
+            const entities = this.world.queryArchetype(mask);
+            this.push(entities);
+            break;
+          }
+          // ── Spatial Operations ──────────────────────────────────────────────
+          case 16: {
+            const entityId = operands[0];
+            const transform = {
+              position: { x: operands[1], y: operands[2], z: operands[3] },
+              rotation: {
+                x: operands[4],
+                y: operands[5],
+                z: operands[6],
+                w: operands[7]
+              },
+              scale: { x: operands[8], y: operands[9], z: operands[10] }
+            };
+            this.world.setComponent(entityId, 1, transform);
+            break;
+          }
+          case 17: {
+            const entityId = operands[0];
+            const existing = this.world.getComponent(
+              entityId,
+              1
+              /* Transform */
+            );
+            if (existing) {
+              existing.position.x += operands[1];
+              existing.position.y += operands[2];
+              existing.position.z += operands[3];
+              this.world.setComponent(entityId, 1, existing);
+            }
+            break;
+          }
+          case 18: {
+            const entityId = operands[0];
+            this.world.setComponent(entityId, 1, {
+              position: { x: 0, y: 0, z: 0 },
+              rotation: {
+                x: operands[1],
+                y: operands[2],
+                z: operands[3],
+                w: operands[4]
+              },
+              scale: { x: 1, y: 1, z: 1 }
+            });
+            break;
+          }
+          case 48: {
+            const entityId = operands[0];
+            const geoType = operands[1];
+            this.world.setComponent(entityId, 2, { type: geoType, params: {} });
+            break;
+          }
+          case 49: {
+            const entityId = operands[0];
+            const material = {
+              color: operands[1] ?? 16777215,
+              metalness: operands[2] ?? 0,
+              roughness: operands[3] ?? 0.5,
+              emissive: operands[4] ?? 0,
+              opacity: operands[5] ?? 1
+            };
+            this.world.setComponent(entityId, 3, material);
+            break;
+          }
+          case 50: {
+            const entityId = operands[0];
+            operands[1] !== 0;
+            const entity = this.world.getEntity(entityId);
+            if (entity) entity.dirty = true;
+            break;
+          }
+          case 52: {
+            const entityId = operands[0];
+            const lightType = operands[1];
+            this.world.setComponent(entityId, 6, {
+              type: lightType,
+              params: operands.slice(2)
+            });
+            break;
+          }
+          // ── Physics Operations ──────────────────────────────────────────────
+          case 32: {
+            const entityId = operands[0];
+            const rb = {
+              mass: operands[1],
+              bodyType: operands[2],
+              velocity: { x: 0, y: 0, z: 0 },
+              angularVelocity: { x: 0, y: 0, z: 0 }
+            };
+            this.world.setComponent(entityId, 4, rb);
+            break;
+          }
+          case 33: {
+            const entityId = operands[0];
+            const rb = this.world.getComponent(
+              entityId,
+              4
+              /* RigidBody */
+            );
+            if (rb && rb.mass > 0) {
+              const dt = 1 / 90;
+              rb.velocity.x += operands[1] / rb.mass * dt;
+              rb.velocity.y += operands[2] / rb.mass * dt;
+              rb.velocity.z += operands[3] / rb.mass * dt;
+              this.world.setComponent(entityId, 4, rb);
+            }
+            break;
+          }
+          case 34: {
+            const entityId = operands[0];
+            const rb = this.world.getComponent(
+              entityId,
+              4
+              /* RigidBody */
+            );
+            if (rb && rb.mass > 0) {
+              rb.velocity.x += operands[1] / rb.mass;
+              rb.velocity.y += operands[2] / rb.mass;
+              rb.velocity.z += operands[3] / rb.mass;
+              this.world.setComponent(entityId, 4, rb);
+            }
+            break;
+          }
+          case 35: {
+            const entityId = operands[0];
+            const rb = this.world.getComponent(
+              entityId,
+              4
+              /* RigidBody */
+            );
+            if (rb) {
+              rb.velocity = {
+                x: operands[1],
+                y: operands[2],
+                z: operands[3]
+              };
+              this.world.setComponent(entityId, 4, rb);
+            }
+            break;
+          }
+          case 38: {
+            this.world.setComponent(0, 255, { x: operands[0], y: operands[1], z: operands[2] });
+            break;
+          }
+          // ── Trait Operations ────────────────────────────────────────────────
+          case 64: {
+            const entityId = operands[0];
+            const traitId = operands[1];
+            const entity = this.world.getEntity(entityId);
+            if (entity) {
+              entity.traits.add(traitId);
+              entity.dirty = true;
+            }
+            break;
+          }
+          case 65: {
+            const entityId = operands[0];
+            const traitId = operands[1];
+            const entity = this.world.getEntity(entityId);
+            if (entity) {
+              entity.traits.delete(traitId);
+              entity.dirty = true;
+            }
+            break;
+          }
+          case 67: {
+            const eventType = operands[0];
+            const payload = operands.slice(1);
+            this.eventQueue.push({ eventType, payload });
+            break;
+          }
+          // ── Control Flow ────────────────────────────────────────────────────
+          case 96:
+            break;
+          case 97: {
+            frame.pc = operands[0];
+            break;
+          }
+          case 98: {
+            const condition = this.pop();
+            if (condition) {
+              frame.pc = operands[0];
+            }
+            break;
+          }
+          case 99: {
+            const funcIdx = operands[0];
+            this.callFunction(funcIdx);
+            break;
+          }
+          case 100: {
+            this.callStack.pop();
+            if (this.callStack.length === 0) {
+              this.status = "HALTED";
+            }
+            break;
+          }
+          case 101: {
+            this.push(operands[0]);
+            break;
+          }
+          case 102: {
+            this.pop();
+            break;
+          }
+          case 103: {
+            const regIdx = operands[0];
+            const value = this.pop();
+            if (regIdx < frame.registers.length) {
+              frame.registers[regIdx] = value;
+            }
+            break;
+          }
+          case 104: {
+            const regIdx = operands[0];
+            if (regIdx < frame.registers.length) {
+              this.push(frame.registers[regIdx]);
+            } else {
+              this.push(null);
+            }
+            break;
+          }
+          case 105: {
+            this.status = "HALTED";
+            break;
+          }
+          case 106: {
+            this.status = "YIELDED";
+            break;
+          }
+          case 107: {
+            const delayMs = operands[0];
+            const handlerFunc = operands[1];
+            this.timers.push({
+              triggerTimeMs: this.currentTimeMs + delayMs,
+              handlerFunctionIndex: handlerFunc
+            });
+            break;
+          }
+          // ── Arithmetic ──────────────────────────────────────────────────────
+          case 108: {
+            const b = this.pop();
+            const a = this.pop();
+            this.push((a ?? 0) + (b ?? 0));
+            break;
+          }
+          case 109: {
+            const b = this.pop();
+            const a = this.pop();
+            this.push((a ?? 0) - (b ?? 0));
+            break;
+          }
+          case 110: {
+            const b = this.pop();
+            const a = this.pop();
+            this.push((a ?? 0) * (b ?? 0));
+            break;
+          }
+          case 111: {
+            const b = this.pop();
+            const a = this.pop();
+            this.push(b !== 0 ? (a ?? 0) / b : 0);
+            break;
+          }
+          // ── Comparison ──────────────────────────────────────────────────────
+          case 128: {
+            const b = this.pop();
+            const a = this.pop();
+            this.push(a === b ? 1 : 0);
+            break;
+          }
+          case 129: {
+            const b = this.pop();
+            const a = this.pop();
+            this.push(a < b ? 1 : 0);
+            break;
+          }
+          case 130: {
+            const b = this.pop();
+            const a = this.pop();
+            this.push(a > b ? 1 : 0);
+            break;
+          }
+          case 131: {
+            const val = this.pop();
+            this.push(val ? 0 : 1);
+            break;
+          }
+          // ── Agent Bridge (stubs — filled in by host integration) ────────────
+          case 112:
+          case 113:
+          case 114:
+          case 115:
+          case 116:
+            this.executeHostOpcode(op, operands);
+            break;
+          // ── I/O & Networking (host integration) ─────────────────────────────
+          case 80:
+          case 81:
+          case 82:
+          case 83:
+          case 84:
+          case 85:
+          case 86:
+            this.executeHostOpcode(op, operands);
+            break;
+          // ── Spatial queries (host integration) ───────────────────────────────
+          case 20:
+          case 21:
+          case 22:
+          case 23:
+          case 24:
+            this.executeHostOpcode(op, operands);
+            break;
+        }
+      }
+      // ── Stack operations ──────────────────────────────────────────────────────
+      push(value) {
+        if (this.stack.length >= this.maxStackSize) {
+          this.status = "ERROR";
+          return;
+        }
+        this.stack.push(value);
+      }
+      pop() {
+        return this.stack.pop() ?? null;
+      }
+      // ── Call frame management ─────────────────────────────────────────────────
+      get currentFrame() {
+        return this.callStack[this.callStack.length - 1];
+      }
+      callFunction(funcIdx) {
+        if (!this.bytecode) return;
+        if (this.callStack.length >= this.maxCallDepth) {
+          this.status = "ERROR";
+          return;
+        }
+        const func = this.bytecode.functions[funcIdx];
+        if (!func) {
+          this.status = "ERROR";
+          return;
+        }
+        const frame = {
+          functionIndex: funcIdx,
+          pc: 0,
+          registers: new Array(func.registerCount).fill(null),
+          stackBase: this.stack.length
+        };
+        this.callStack.push(frame);
+        this.status = "RUNNING";
+      }
+      executeHostOpcode(opcode, operands) {
+        const callback = this.hostCallbacks.get(opcode);
+        if (!callback) {
+          throw new UnsupportedHostOpcodeError(opcode, operands);
+        }
+        const result = callback({
+          opcode,
+          opcodeName: getOpcodeName(opcode),
+          opcodeGroup: getHostOpcodeGroup(opcode),
+          operands: [...operands],
+          tickCount: this.tickCount,
+          currentTimeMs: this.currentTimeMs,
+          world: this.world,
+          vm: this,
+          resolveString: (index) => this.getString(index)
+        });
+        if (!HOST_OUTPUT_OPCODES.has(opcode)) {
+          return;
+        }
+        if (result === void 0) {
+          throw new Error(`Host callback for ${getOpcodeName(opcode)} must return a VM operand`);
+        }
+        this.push(result);
+      }
+      // ── Timer processing ──────────────────────────────────────────────────────
+      processTimers() {
+        const expired = [];
+        this.timers = this.timers.filter((t) => {
+          if (t.triggerTimeMs <= this.currentTimeMs) {
+            expired.push(t);
+            return false;
+          }
+          return true;
+        });
+        for (const timer of expired) {
+          this.callFunction(timer.handlerFunctionIndex);
+          this.executeInstructions();
+        }
+      }
+      // ── Event dispatch ────────────────────────────────────────────────────────
+      dispatchEvents() {
+        if (!this.bytecode) return;
+        const events = [...this.eventQueue];
+        this.eventQueue = [];
+        for (const event of events) {
+          for (const binding of this.bytecode.events) {
+            if (binding.eventType === event.eventType) {
+              for (const p of event.payload) {
+                this.push(p);
+              }
+              this.callFunction(binding.handlerFunctionIndex);
+              this.executeInstructions();
+            }
+          }
+        }
+      }
+      // ── Utility ───────────────────────────────────────────────────────────────
+      getString(index) {
+        if (!this.bytecode) return "";
+        return this.bytecode.strings[index] ?? `str_${index}`;
+      }
+      /**
+       * Get current VM status
+       */
+      getStatus() {
+        return this.status;
+      }
+      /**
+       * Get current stack snapshot (for debugging)
+       */
+      getStack() {
+        return [...this.stack];
+      }
+      /**
+       * Get the tick count
+       */
+      getTickCount() {
+        return this.tickCount;
+      }
+      /**
+       * Get the last execution error, preserving typed host-integration failures.
+       */
+      getLastError() {
+        return this.lastError;
+      }
+      /**
+       * Queue an external event (e.g., from user input or network)
+       */
+      queueEvent(eventType, ...payload) {
+        this.eventQueue.push({ eventType, payload });
+      }
+    };
+    var HOST_OPCODE_GROUPS = /* @__PURE__ */ new Map([
+      [112, "agent"],
+      [113, "agent"],
+      [114, "agent"],
+      [115, "agent"],
+      [116, "agent"],
+      [80, "io"],
+      [81, "io"],
+      [82, "io"],
+      [83, "io"],
+      [84, "io"],
+      [85, "io"],
+      [86, "io"],
+      [20, "spatial"],
+      [21, "spatial"],
+      [22, "spatial"],
+      [23, "spatial"],
+      [24, "spatial"]
+    ]);
+    var HOST_OUTPUT_OPCODES = /* @__PURE__ */ new Set([
+      112,
+      113,
+      80,
+      84,
+      85,
+      20,
+      21,
+      22,
+      23,
+      24
+      /* GET_ZONE */
+    ]);
+    function isHostOpcode(opcode) {
+      return HOST_OPCODE_GROUPS.has(opcode);
+    }
+    function getHostOpcodeGroup(opcode) {
+      return HOST_OPCODE_GROUPS.get(opcode) ?? "io";
+    }
+    exports$1.AssetType = AssetType;
+    exports$1.BodyType = BodyType2;
+    exports$1.ColliderShape = ColliderShape;
+    exports$1.ComponentType = ComponentType3;
+    exports$1.ECSWorld = ECSWorld2;
+    exports$1.GeometryType = GeometryType2;
+    exports$1.HOLOB_MAGIC = HOLOB_MAGIC;
+    exports$1.HOLOB_VERSION = HOLOB_VERSION;
+    exports$1.HoloBytecodeBuilder = HoloBytecodeBuilder2;
+    exports$1.HoloFunctionBuilder = HoloFunctionBuilder;
+    exports$1.HoloOpCode = HoloOpCode;
+    exports$1.HoloVM = HoloVM;
+    exports$1.HolobFlags = HolobFlags;
+    exports$1.LightType = LightType2;
+    exports$1.SyncTier = SyncTier;
+    exports$1.UnsupportedHostOpcodeError = UnsupportedHostOpcodeError;
+    exports$1.VMStatus = VMStatus;
+    exports$1.ValueType = ValueType;
+    exports$1.getOpcodeFamily = getOpcodeFamily;
+    exports$1.getOpcodeName = getOpcodeName;
+    exports$1.isControlFlow = isControlFlow;
+    exports$1.isHostOpcode = isHostOpcode;
+  }
+});
+
 // src/composition/CompositionParser.ts
 function getProp(props, key2) {
   if (!props) return void 0;
@@ -6473,6 +7857,7 @@ var CircuitBreakerRegistry = class {
 };
 
 // src/compiler/ReferenceExporters.ts
+init_Native2DCompiler();
 var ReferenceExporter = class {
   constructor(options = {}) {
     this.options = {
@@ -6853,6 +8238,20 @@ var WASMReferenceExporter = class extends ReferenceExporter {
     };
   }
 };
+var Native2DReferenceExporter = class extends ReferenceExporter {
+  export(composition) {
+    const output = new Native2DCompiler().compile(composition, "", void 0, {
+      format: "html"
+    });
+    return {
+      target: "native-2d",
+      output,
+      format: "text",
+      warnings: [],
+      usedFallback: true
+    };
+  }
+};
 var ReferenceExporterRegistry = class {
   constructor() {
     this.exporters = /* @__PURE__ */ new Map();
@@ -6864,6 +8263,7 @@ var ReferenceExporterRegistry = class {
     this.exporters.set("webgpu", new WebGPUReferenceExporter());
     this.exporters.set("r3f", new R3FReferenceExporter());
     this.exporters.set("babylon", new BabylonReferenceExporter());
+    this.exporters.set("native-2d", new Native2DReferenceExporter());
     this.exporters.set("openxr", new OpenXRReferenceExporter());
     this.exporters.set("vrchat", new VRChatReferenceExporter());
     this.exporters.set("ios", new IOSReferenceExporter());
@@ -23376,7 +24776,7 @@ button refreshBtn {
 
 // src/barrel/runtime-env.ts
 async function createHoloScriptEnvironment() {
-  const { HoloScriptRuntime } = await import('./HoloScriptRuntime-3URVTKPJ.js');
+  const { HoloScriptRuntime } = await import('./HoloScriptRuntime-2DDYOPOR.js');
   return {
     parser: new HoloScriptParser(),
     runtime: new HoloScriptRuntime(),
@@ -33495,71 +34895,6 @@ function calculateMedian(numbers) {
   const mid = Math.floor(sorted.length / 2);
   return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
 }
-var requirePeer = createRequire(import.meta.url);
-var peerCache = /* @__PURE__ */ new Map();
-function loadPeer(specifier) {
-  const cached = peerCache.get(specifier);
-  if (cached) return cached;
-  let mod;
-  try {
-    mod = requirePeer(specifier);
-  } catch (err) {
-    const e = err;
-    const pkg = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
-    if (e && (e.code === "ERR_MODULE_NOT_FOUND" || e.code === "MODULE_NOT_FOUND")) {
-      throw new Error(
-        `@holoscript/core: optional peer "${pkg}" is required to use this symbol but is not installed. Run \`npm install ${pkg}\` (or your package manager's equivalent) to enable it. The core parser and compiler surface work without it.`
-      );
-    }
-    throw err;
-  }
-  peerCache.set(specifier, mod);
-  return mod;
-}
-function resolveSymbol(specifier, name) {
-  const mod = loadPeer(specifier);
-  if (!(name in mod)) {
-    const pkg = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
-    throw new Error(
-      `@holoscript/core: symbol "${name}" was not found in optional peer "${specifier}" (package "${pkg}"). The installed peer version may be incompatible with this @holoscript/core release.`
-    );
-  }
-  return mod[name];
-}
-function lazyPeerSymbol(specifier, name) {
-  const target = function lazyPeerProxyTarget() {
-  };
-  let resolved;
-  const real = () => {
-    if (resolved === void 0) resolved = resolveSymbol(specifier, name);
-    return resolved;
-  };
-  return new Proxy(target, {
-    apply(_t, thisArg, args) {
-      return Reflect.apply(real(), thisArg, args);
-    },
-    construct(_t, args, newTarget) {
-      return Reflect.construct(real(), args, newTarget);
-    },
-    get(_t, prop) {
-      const r = real();
-      const v = Reflect.get(r, prop, r);
-      return typeof v === "function" ? v.bind(r) : v;
-    },
-    has(_t, prop) {
-      return Reflect.has(real(), prop);
-    },
-    getPrototypeOf() {
-      return Reflect.getPrototypeOf(real());
-    },
-    ownKeys() {
-      return Reflect.ownKeys(real());
-    },
-    getOwnPropertyDescriptor(_t, prop) {
-      return Reflect.getOwnPropertyDescriptor(real(), prop);
-    }
-  });
-}
 
 // src/barrel/compiler-plugins-crypto.ts
 init_CompilerBase();
@@ -33571,7 +34906,7 @@ var GeometryType;
 var BodyType;
 var LightType;
 try {
-  const holoVm = __require("@holoscript/holo-vm");
+  const holoVm = require_dist();
   HoloBytecodeBuilder = holoVm.HoloBytecodeBuilder;
   ComponentType2 = holoVm.ComponentType;
   GeometryType = holoVm.GeometryType;