@holoscript/engine 6.0.3 → 6.0.4

package/dist/index.d.cts

@@ -1,35 +1,40 @@
 import { E as EngineSystem } from './SpatialEngine-CXmE-U_d.cjs';
 export { a as EngineConfig, b as EngineMetrics, c as EngineState, S as SpatialEngine } from './SpatialEngine-CXmE-U_d.cjs';
-export { A as AABB, M as ADVANCED_PBR_PRESETS, a as AdvancedLight, L as AdvancedLightingLightType, b as AdvancedLightingManager, V as AdvancedLightingVec2, c as AdvancedLightingVec3, d as AdvancedPBRConfig, e as AdvancedPBRMaterial, f as AdvancedPBRVec3, g as AdvancedTexturingVec2, h as AdvancedTexturingVec3, i as AmbientConfig, j as AnimationFrameOptions, k as AnisotropyConfig, l as AreaLightConfig, m as AreaLightShape, n as AtlasPacker, o as AtlasRect, p as AttachmentFormat, B as BVH, q as BVHNode, r as BatchStats, s as BlendMode, t as BloomConfig, u as BloomEffect, C as CausticConfig, v as ChromaticAberrationConfig, w as ClearOp, x as ClearcoatConfig, y as CloudConfig, z as CloudRenderer, D as CloudSample, E as ColorGrading, F as ColorGradingConfig, G as CompiledShader, H as CullMode, I as DOFConfig, J as DecalBatcher, K as DecalDef, N as DecalInstance, O as DecalSystem, P as DetailMapConfig, Q as DisplacementConfig, R as DrawBatch, S as FogConfig, T as FogMode, U as FogSystem, W as FramebufferAttachment, X as GIConfig, Y as GIMode, Z as GIProbe, _ as GIProbeGrid, $ as GlobalIlluminationVec3, a0 as GraphStats, a1 as HitRecord, a2 as IBlendComponent, a3 as IBlendState, a4 as IBoundingBox, a5 as IBufferDescriptor, a6 as ICameraUniforms, a7 as IColorTargetState, a8 as IDepthStencilState, a9 as IDeviceCapabilities, aa as IDrawCall, ab as IESProfile, ac as IFrameStats, ad as IGPUTexture, ae as IIndexBuffer, af as IRenderMaterial, ag as IRenderMesh, ah as IRenderPassColorAttachment, ai as IRenderPassDepthStencilAttachment, aj as IRenderPassDescriptor, ak as IRenderPipelineDescriptor, al as IRendererStats, am as ISamplerDescriptor, an as ISceneUniforms, ao as IShaderModule, ap as ITextureDescriptor, aq as IUniformBuffer, ar as IVertexAttribute, as as IVertexBuffer, at as IVertexBufferLayout, au as IWebGPUContext, av as IWebGPUInitOptions, aw as IridescenceConfig, ax as Light, ay as LightCookie, az as LightType, aA as LightingModel, aB as MaterialDef, aC as MaterialInstance, aD as MaterialLibrary, aE as MaterialSystem, aF as MaterialSystemBlendMode, aG as MaterialSystemCullMode, aH as MaterialSystemMaterial, aI as MotionBlurConfig, aJ as NLMConfig, aK as PDFOptions, aL as POMConfig, aM as PP_PRESETS, aN as PassContext, aO as PathTracerScene, aP as PhysicsDebugDrawer, aQ as PixelBuffer, aR as PostProcess, aS as PostProcessEffect, aT as PostProcessProfile, aU as PostProcessStack, aV as PostProcessingStack, aW as PrerenderOptions, aX as ProbeInfo, aY as ProjectorConfig, aZ as ProjectorLight, a_ as PuppeteerRenderer, a$ as PuppeteerRendererOptions, b0 as RENDERING_MATERIAL_PRESETS, b1 as RGB, b2 as RTApi, b3 as RTFeature, b4 as Ray, b5 as RayTracer, b6 as RayTracingConfig, b7 as RayTracingVec3, b8 as RenderGraph, b9 as RenderPass, ba as RenderPassConfig, bb as RenderPassDescriptor, bc as RenderResult, bd as RenderTarget, be as Rendering, bf as RenderingMaterialType, bg as SH9, bh as SHADER_NODES, bi as SSAOConfig, bj as SSGIConfig, bk as SSRConfig, bl as SSSConfig, bm as SSSLayer, bn as SSSMaterial, bo as SSSModel, bp as SSSRGB, bq as SSS_PRESETS, br as STANDARD_FRAGMENT_SHADER, bs as STANDARD_VERTEX_SHADER, bt as ScreenshotOptions, bu as ShaderConnection, bv as ShaderDataType, bw as ShaderGraph, bx as ShaderNode, by as ShaderNodeDef, bz as ShaderPort, bA as ShaderPortRef, bB as ShaderUniform, bC as SheenConfig, bD as TAAConfig, bE as Texture2D, bF as TextureFormat, bG as TextureSlot, bH as ToneMapper, bI as TonemapOperator, bJ as Triangle, bK as UNLIT_FRAGMENT_SHADER, bL as UNLIT_VERTEX_SHADER, bM as UniformDef, bN as UniformType, bO as VolumetricLight, bP as VolumetricLightConfig, bQ as VolumetricSample, bR as WebGPURenderer, bS as aabbCentroid, bT as aabbSurfaceArea, bU as addSHSample, bV as anisotropicRoughness, bW as applyChromaticAberration, bX as applyDOF, bY as applyDetailAlbedo, bZ as applyFilmGrain, b_ as applyMotionBlur, b$ as applyVignette, c0 as blendDetailNormal, c1 as blendTAA, c2 as buildCircleCookie, c3 as buildSeparableSSSKernel, c4 as burleyProfile, c5 as burleyProfileRGB, c6 as christensenProfile, c7 as computeAABB, c8 as computeCoC, c9 as computeDiffuseAlbedo, ca as computeDisplacedPosition, cb as computeDisplacementNormalsFromHeightMap, cc as computeF0, cd as computePOM, ce as computeSSAO, cf as computeSSGI, cg as computeSSR, ch as computeTriangleNormal, ci as createAtlasPacker, cj as createDefaultMaterialDef, ck as createSH9, cl as createSolidTexture, cm as diskSolidAngle, cn as distributionGGX, co as distributionGGXAnisotropic, cp as evalSH9Irradiance, cq as evalSeparableKernel, cr as evaluateClearcoat, cs as evaluateIridescence, ct as evaluateSheen, cu as fresnelRoughness, cv as fresnelSchlick, cw as geometrySmith, cx as getAtlasEfficiency, cy as getRectUV, cz as haltonJitter, cA as hexToRGBA, cB as intersectRayAABB, cC as intersectRayTriangle, cD as lerpSH9, cE as nlmDenoise, cF as packRect, cG as parseIESProfile, cH as pathTrace, cI as prerenderHTML, cJ as rectSolidAngle, cK as renderPDF, cL as renderScreenshot, cM as rgbaToHex, cN as sampleCookie, cO as sampleIES, cP as sampleTexture, cQ as sampleTextureBilinear, cR as sampleTriplanar, cS as scaleSH9, cT as sheenDistribution, cU as sheenVisibility, cV as thinSlabTransmission, cW as triplanarWeights } from './index-DIA-2Xpa.cjs';
-export { i as Animation } from './index-D2fXoZqJ.cjs';
-export { i as Physics } from './index-HvSitE_e.cjs';
-export { i as Runtime } from './index-Dv8Ca2kR.cjs';
-export { i as Audio } from './index-BC6efRgw.cjs';
+export { A as AABB, M as ADVANCED_PBR_PRESETS, a as AdvancedLight, L as AdvancedLightingLightType, b as AdvancedLightingManager, V as AdvancedLightingVec2, c as AdvancedLightingVec3, d as AdvancedPBRConfig, e as AdvancedPBRMaterial, f as AdvancedPBRVec3, g as AdvancedTexturingVec2, h as AdvancedTexturingVec3, i as AmbientConfig, j as AnimationFrameOptions, k as AnisotropyConfig, l as AreaLightConfig, m as AreaLightShape, n as AtlasPacker, o as AtlasRect, p as AttachmentFormat, B as BVH, q as BVHNode, r as BatchStats, s as BlendMode, t as BloomConfig, u as BloomEffect, C as CausticConfig, v as ChromaticAberrationConfig, w as ClearOp, x as ClearcoatConfig, y as CloudConfig, z as CloudRenderer, D as CloudSample, E as ColorGrading, F as ColorGradingConfig, G as CompiledShader, H as CullMode, I as DOFConfig, J as DecalBatcher, K as DecalDef, N as DecalInstance, O as DecalSystem, P as DetailMapConfig, Q as DisplacementConfig, R as DrawBatch, S as FogConfig, T as FogMode, U as FogSystem, W as FramebufferAttachment, X as GIConfig, Y as GIMode, Z as GIProbe, _ as GIProbeGrid, $ as GlobalIlluminationVec3, a0 as GraphStats, a1 as HitRecord, a2 as IBlendComponent, a3 as IBlendState, a4 as IBoundingBox, a5 as IBufferDescriptor, a6 as ICameraUniforms, a7 as IColorTargetState, a8 as IDepthStencilState, a9 as IDeviceCapabilities, aa as IDrawCall, ab as IESProfile, ac as IFrameStats, ad as IGPUTexture, ae as IIndexBuffer, af as IRenderMaterial, ag as IRenderMesh, ah as IRenderPassColorAttachment, ai as IRenderPassDepthStencilAttachment, aj as IRenderPassDescriptor, ak as IRenderPipelineDescriptor, al as IRendererStats, am as ISamplerDescriptor, an as ISceneUniforms, ao as IShaderModule, ap as ITextureDescriptor, aq as IUniformBuffer, ar as IVertexAttribute, as as IVertexBuffer, at as IVertexBufferLayout, au as IWebGPUContext, av as IWebGPUInitOptions, aw as IridescenceConfig, ax as Light, ay as LightCookie, az as LightType, aA as LightingModel, aB as MaterialDef, aC as MaterialInstance, aD as MaterialLibrary, aE as MaterialSystem, aF as MaterialSystemBlendMode, aG as MaterialSystemCullMode, aH as MaterialSystemMaterial, aI as MotionBlurConfig, aJ as NLMConfig, aK as PDFOptions, aL as POMConfig, aM as PP_PRESETS, aN as PassContext, aO as PathTracerScene, aP as PhysicsDebugDrawer, aQ as PixelBuffer, aR as PostProcess, aS as PostProcessEffect, aT as PostProcessProfile, aU as PostProcessStack, aV as PostProcessingStack, aW as PrerenderOptions, aX as ProbeInfo, aY as ProjectorConfig, aZ as ProjectorLight, a_ as PuppeteerRenderer, a$ as PuppeteerRendererOptions, b0 as RENDERING_MATERIAL_PRESETS, b1 as RGB, b2 as RTApi, b3 as RTFeature, b4 as Ray, b5 as RayTracer, b6 as RayTracingConfig, b7 as RayTracingVec3, b8 as RenderGraph, b9 as RenderPass, ba as RenderPassConfig, bb as RenderPassDescriptor, bc as RenderResult, bd as RenderTarget, be as Rendering, bf as RenderingMaterialType, bg as SH9, bh as SHADER_NODES, bi as SSAOConfig, bj as SSGIConfig, bk as SSRConfig, bl as SSSConfig, bm as SSSLayer, bn as SSSMaterial, bo as SSSModel, bp as SSSRGB, bq as SSS_PRESETS, br as STANDARD_FRAGMENT_SHADER, bs as STANDARD_VERTEX_SHADER, bt as ScreenshotOptions, bu as ShaderConnection, bv as ShaderDataType, bw as ShaderGraph, bx as ShaderNode, by as ShaderNodeDef, bz as ShaderPort, bA as ShaderPortRef, bB as ShaderUniform, bC as SheenConfig, bD as TAAConfig, bE as Texture2D, bF as TextureFormat, bG as TextureSlot, bH as ToneMapper, bI as TonemapOperator, bJ as Triangle, bK as UNLIT_FRAGMENT_SHADER, bL as UNLIT_VERTEX_SHADER, bM as UniformDef, bN as UniformType, bO as VolumetricLight, bP as VolumetricLightConfig, bQ as VolumetricSample, bR as WebGPURenderer, bS as aabbCentroid, bT as aabbSurfaceArea, bU as addSHSample, bV as anisotropicRoughness, bW as applyChromaticAberration, bX as applyDOF, bY as applyDetailAlbedo, bZ as applyFilmGrain, b_ as applyMotionBlur, b$ as applyVignette, c0 as blendDetailNormal, c1 as blendTAA, c2 as buildCircleCookie, c3 as buildSeparableSSSKernel, c4 as burleyProfile, c5 as burleyProfileRGB, c6 as christensenProfile, c7 as computeAABB, c8 as computeCoC, c9 as computeDiffuseAlbedo, ca as computeDisplacedPosition, cb as computeDisplacementNormalsFromHeightMap, cc as computeF0, cd as computePOM, ce as computeSSAO, cf as computeSSGI, cg as computeSSR, ch as computeTriangleNormal, ci as createAtlasPacker, cj as createDefaultMaterialDef, ck as createSH9, cl as createSolidTexture, cm as diskSolidAngle, cn as distributionGGX, co as distributionGGXAnisotropic, cp as evalSH9Irradiance, cq as evalSeparableKernel, cr as evaluateClearcoat, cs as evaluateIridescence, ct as evaluateSheen, cu as fresnelRoughness, cv as fresnelSchlick, cw as geometrySmith, cx as getAtlasEfficiency, cy as getRectUV, cz as haltonJitter, cA as hexToRGBA, cB as intersectRayAABB, cC as intersectRayTriangle, cD as lerpSH9, cE as nlmDenoise, cF as packRect, cG as parseIESProfile, cH as pathTrace, cI as prerenderHTML, cJ as rectSolidAngle, cK as renderPDF, cL as renderScreenshot, cM as rgbaToHex, cN as sampleCookie, cO as sampleIES, cP as sampleTexture, cQ as sampleTextureBilinear, cR as sampleTriplanar, cS as scaleSH9, cT as sheenDistribution, cU as sheenVisibility, cV as thinSlabTransmission, cW as triplanarWeights } from './index-ByIq2XrS.cjs';
+import { A as AnimationEngine } from './index-CmYtNiI-.cjs';
+export { i as Animation } from './index-CmYtNiI-.cjs';
+export { i as Physics } from './index-BHySEPX7.cjs';
+import { W as WasmMesher, S as SurfaceMesh, a as SurfaceMeshOptions, T as TetMesh } from './index-DQKisbcI.cjs';
+export { i as Simulation } from './index-DQKisbcI.cjs';
+export { i as Runtime } from './index-CUl3QstQ.cjs';
+export { i as Audio } from './index-B2PIsAmR.cjs';
 export { i as VR } from './index-BS3P_0Q8.cjs';
 export { i as Input } from './index-CX2pFNZx.cjs';
-export { i as Camera } from './index-rC5eM7xz.cjs';
+export { i as Camera } from './index-s9yOFU37.cjs';
 export { i as Navigation } from './index-C2XVM6Fg.cjs';
-export { i as Particles } from './index-BlXHaPDg.cjs';
-export { i as Terrain } from './index-DBMwdfI5.cjs';
+export { i as Particles } from './index-CnRzWxi_.cjs';
+export { i as Terrain } from './index-BJV21zuy.cjs';
 export { i as Tilemap } from './index-CXwgtszY.cjs';
 export { i as Procedural } from './index-BfTyHDzB.cjs';
-export { i as Combat } from './index-C6fjODuj.cjs';
+export { i as Combat } from './index-nMvkoRm8.cjs';
 export { i as Dialogue } from './index-riYekckF.cjs';
 export { i as Gameplay } from './index-DALSrkL-.cjs';
 export { i as Character } from './index-Du-wibkm.cjs';
 export { i as ECS } from './index-BHAIZXxZ.cjs';
-export { i as Scene } from './index-Crg8mJkF.cjs';
-export { i as Environment } from './index-C6YCOCTJ.cjs';
-export { i as World } from './index-B2ahcPOJ.cjs';
-export { i as Orbital } from './index-BQVsbJuC.cjs';
+export { i as Scene } from './index-DJ6-R8vh.cjs';
+export { i as Environment } from './index-BQutTphC.cjs';
+export { i as World } from './index-DfNLiAka.cjs';
+export { i as Orbital } from './index-BysHjDSO.cjs';
 export { i as Hologram } from './index-DsSFZOg9.cjs';
-export { i as VM } from './index-CJYOp6Nv.cjs';
-export { i as VMBridge } from './index-DouwiW0o.cjs';
-import { AssetMaturity } from '@holoscript/core';
+export { i as VM } from './index-B4dc1BWC.cjs';
+export { i as VMBridge } from './index-BrCqHAgp.cjs';
+import { AssetMaturity, INeuralSplatPacket, HSPlusRuntime, ReactiveState, StateDeclaration, VRHand, Vector3, HSPlusAST, HSPlusNode, HSPlusStatement, TraitEvent } from '@holoscript/core';
 import './PhysicsTypes-Dw6_oXuD.cjs';
+import '@holoscript/snn-webgpu';
+import '@holoscript/crdt-spatial';
 import 'three';
 import './World-CgKA4O2J.cjs';
-import './executor-CRFAQA9C.cjs';
+import './executor-C6ay5Awb.cjs';
 import '@holoscript/uaal';
 
 /**
@@ -95,6 +100,121 @@ declare class PhysicsStep implements EngineSystem {
     destroy(): void;
 }
 
+/**
+ * WebGPU Context Management
+ *
+ * Handles WebGPU device initialization, feature detection, and fallback strategies.
+ *
+ * @module gpu/WebGPUContext
+ */
+interface WebGPUCapabilities {
+    supported: boolean;
+    adapter: GPUAdapter | null;
+    device: GPUDevice | null;
+    limits: GPUSupportedLimits | null;
+    features: Set<string>;
+}
+interface WebGPUContextOptions {
+    powerPreference?: 'low-power' | 'high-performance';
+    requiredFeatures?: GPUFeatureName[];
+    requiredLimits?: Record<string, number>;
+    fallbackToCPU?: boolean;
+}
+/**
+ * WebGPU Context Manager
+ *
+ * Provides centralized WebGPU device initialization with feature detection
+ * and graceful fallback to CPU when WebGPU is unavailable.
+ *
+ * @example
+ * ```typescript
+ * const context = new WebGPUContext({
+ *   powerPreference: 'high-performance',
+ *   fallbackToCPU: true,
+ * });
+ *
+ * await context.initialize();
+ *
+ * if (context.isSupported()) {
+ *   // Use GPU acceleration
+ *   const device = context.getDevice();
+ *   // ... create compute pipelines
+ * } else {
+ *   // Fallback to CPU physics
+ *   console.warn('WebGPU not available, using CPU fallback');
+ * }
+ * ```
+ */
+declare class WebGPUContext {
+    private adapter;
+    private device;
+    private limits;
+    private features;
+    private options;
+    private initialized;
+    constructor(options?: WebGPUContextOptions);
+    /**
+     * Initialize WebGPU context
+     *
+     * @returns Promise that resolves when initialization is complete
+     * @throws Error if WebGPU is not supported and fallbackToCPU is false
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if WebGPU is supported and initialized
+     */
+    isSupported(): boolean;
+    /**
+     * Get WebGPU device
+     * @throws Error if device is not initialized
+     */
+    getDevice(): GPUDevice;
+    /**
+     * Get WebGPU adapter
+     * @throws Error if adapter is not available
+     */
+    getAdapter(): GPUAdapter;
+    /**
+     * Get device limits
+     */
+    getLimits(): GPUSupportedLimits;
+    /**
+     * Get supported features
+     */
+    getFeatures(): Set<string>;
+    /**
+     * Check if a specific feature is supported
+     */
+    hasFeature(feature: string): boolean;
+    /**
+     * Get capabilities object
+     */
+    getCapabilities(): WebGPUCapabilities;
+    /**
+     * Get optimal workgroup size for compute shaders
+     *
+     * Returns a workgroup size that maximizes occupancy based on device limits.
+     * Common values: 64, 128, 256 (must be power of 2)
+     */
+    getOptimalWorkgroupSize(): number;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+    /**
+     * Handle unsupported browser/device
+     */
+    private handleUnsupported;
+    /**
+     * Handle device lost event
+     */
+    private handleDeviceLost;
+    /**
+     * Detect and log GPU information (for debugging)
+     */
+    logGPUInfo(): Promise<void>;
+}
+
 /**
  * @holoscript/core LOD Types
  *
@@ -940,7 +1060,7 @@ declare class TransitionScheduler {
     /**
      * Record actual GPU cost for a transition (for budget tuning)
      */
-    recordCost(entityId: string, actualCostMs: number): void;
+    recordCost(entityId: string, _actualCostMs: number): void;
     /**
      * Get budget utilization (0-1)
      */
@@ -1198,7 +1318,7 @@ declare class LODPerformanceMetrics {
     /**
      * Start profiling a code section
      */
-    startProfile(name: string): number;
+    startProfile(_name: string): number;
     /**
      * End profiling and record result
      */
@@ -1574,4 +1694,728 @@ declare namespace index {
   export { index_DEFAULT_GENERATION_OPTIONS as DEFAULT_GENERATION_OPTIONS, index_DEFAULT_LOD_CONFIG as DEFAULT_LOD_CONFIG, index_DEFAULT_LOD_LEVEL as DEFAULT_LOD_LEVEL, index_DEFAULT_MANAGER_OPTIONS as DEFAULT_MANAGER_OPTIONS, index_DEFAULT_MESHLET_OPTIONS as DEFAULT_MESHLET_OPTIONS, type index_GeneratedLODLevel as GeneratedLODLevel, index_LODBridge as LODBridge, type index_LODBridgeOptions as LODBridgeOptions, type index_LODChain as LODChain, type index_LODChainLevel as LODChainLevel, type index_LODConfig as LODConfig, type index_LODEvent as LODEvent, type index_LODEventHandler as LODEventHandler, type index_LODEventType as LODEventType, type index_LODFeature as LODFeature, type index_LODGenerationOptions as LODGenerationOptions, type index_LODGenerationResult as LODGenerationResult, index_LODGenerator as LODGenerator, type index_LODGroup as LODGroup, type index_LODHierarchy as LODHierarchy, type index_LODLevel as LODLevel, type index_LODLevelHistogram as LODLevelHistogram, index_LODManager as LODManager, type index_LODManagerOptions as LODManagerOptions, index_LODMemoryPool as LODMemoryPool, type index_LODMetrics as LODMetrics, index_LODPerformanceMetrics as LODPerformanceMetrics, type index_LODState as LODState, type index_LODStrategy as LODStrategy, index_LODTransition as LODTransition, type index_LODTransitionConfig as LODTransitionConfig, type index_MemoryPoolOptions as MemoryPoolOptions, type index_MeshData as MeshData, type index_MeshValidation as MeshValidation, type index_Meshlet as Meshlet, type index_MeshletGenerationResult as MeshletGenerationResult, index_MeshletGenerator as MeshletGenerator, type index_MeshletGeneratorOptions as MeshletGeneratorOptions, type index_PerformanceSnapshot as PerformanceSnapshot, type index_PoolStatistics as PoolStatistics, type index_PooledBuffer as PooledBuffer, type index_ProfilingData as ProfilingData, index_STANDARD_DISTANCES as STANDARD_DISTANCES, index_STANDARD_RATIOS as STANDARD_RATIOS, type index_ScheduledTransition as ScheduledTransition, type index_SimplificationAlgorithm as SimplificationAlgorithm, type index_TransitionBudget as TransitionBudget, type index_TransitionCostAnalysis as TransitionCostAnalysis, type index_TransitionMode as TransitionMode, index_TransitionScheduler as TransitionScheduler, type index_TransitionState as TransitionState, index_calculateOptimalDistances as calculateOptimalDistances, index_calculateScreenCoverage as calculateScreenCoverage, index_createLODGenerator as createLODGenerator, index_createLODGroup as createLODGroup, index_createLODLevel as createLODLevel, index_createLODManager as createLODManager, index_createLODMemoryPool as createLODMemoryPool, index_createLODMetrics as createLODMetrics, index_createLODPerformanceMetrics as createLODPerformanceMetrics, index_createLODState as createLODState, index_createMeshletGenerator as createMeshletGenerator, index_createMobileLODManager as createMobileLODManager, index_createMobileMemoryPool as createMobileMemoryPool, index_createStandardLODConfig as createStandardLODConfig, index_createTestCube as createTestCube, index_createTestSphere as createTestSphere, index_createVRLODManager as createVRLODManager, index_createVRMemoryPool as createVRMemoryPool, index_generateLODs as generateLODs, index_generateMeshlets as generateMeshlets, index_getRecommendedLODCount as getRecommendedLODCount, index_getTrianglesSaved as getTrianglesSaved, index_mergeLODConfigs as mergeLODConfigs, index_selectLODLevelByDistance as selectLODLevelByDistance, index_selectLODLevelByScreenCoverage as selectLODLevelByScreenCoverage, index_validateLODConfig as validateLODConfig };
 }
 
-export { type CollisionCallback, type CollisionEvent, DEFAULT_GENERATION_OPTIONS, DEFAULT_LOD_CONFIG, DEFAULT_LOD_LEVEL, DEFAULT_MANAGER_OPTIONS, DEFAULT_MESHLET_OPTIONS, EngineSystem, type GeneratedLODLevel, index as LOD, LODBridge, type LODBridgeOptions, type LODChain, type LODChainLevel, type LODConfig, type LODEvent, type LODEventHandler, type LODEventType, type LODFeature, type LODGenerationOptions, type LODGenerationResult, LODGenerator, type LODGroup, type LODHierarchy, type LODLevel, type LODLevelHistogram, LODManager, type LODManagerOptions, LODMemoryPool, type LODMetrics, LODPerformanceMetrics, type LODState, type LODStrategy, LODTransition, type LODTransitionConfig, type MemoryPoolOptions, type MeshData, type MeshValidation, type Meshlet, type MeshletGenerationResult, MeshletGenerator, type MeshletGeneratorOptions, type PerformanceSnapshot, type PhysicsBodyState, PhysicsStep, type PoolStatistics, type PooledBuffer, type ProfilingData, STANDARD_DISTANCES, STANDARD_RATIOS, type ScheduledTransition, type SimplificationAlgorithm, type TransitionBudget, type TransitionCostAnalysis, type TransitionMode, TransitionScheduler, type TransitionState, type Vec3, calculateOptimalDistances, calculateScreenCoverage, createLODGenerator, createLODGroup, createLODLevel, createLODManager, createLODMemoryPool, createLODMetrics, createLODPerformanceMetrics, createLODState, createMeshletGenerator, createMobileLODManager, createMobileMemoryPool, createStandardLODConfig, createTestCube, createTestSphere, createVRLODManager, createVRMemoryPool, generateLODs, generateMeshlets, getRecommendedLODCount, getTrianglesSaved, mergeLODConfigs, selectLODLevelByDistance, selectLODLevelByScreenCoverage, validateLODConfig };
+/**
+ * GaussianSplatSorter - Wait-Free Hierarchical Radix Sort for WebGPU Gaussian Splatting
+ *
+ * Orchestrates the full GPU sort pipeline for Gaussian splat rendering:
+ *   1. Compress: raw splats -> RGBA8 colors, f16 covariance, depth keys
+ *   2. Sort: 4-pass 8-bit radix sort using Blelloch scan (no global atomics)
+ *   3. Render: sorted indices feed the splat renderer for correct back-to-front compositing
+ *
+ * Performance characteristics:
+ *   - O(n) radix sort (4 passes for 32-bit keys)
+ *   - Wait-free: no global atomics, no cross-workgroup synchronization
+ *   - 50% memory reduction via compression (32 bytes/splat vs 64 bytes)
+ *   - Cross-browser: Chrome, Safari, Firefox, mobile (no subgroup ops, no shader-f16)
+ *
+ * References:
+ *   - HoloScript W.035: Radix sort outperforms bitonic sort for N > 64K splats
+ *   - HoloScript G.030.01: Safari requires explicit bind group recreation after buffer swap
+ *
+ * @module gpu/GaussianSplatSorter
+ * @version 1.0.0
+ */
+
+interface GaussianSplatSorterOptions {
+    /** Maximum number of splats (determines buffer allocation) */
+    maxSplats: number;
+    /** Workgroup size for compute shaders (default: 256, must be power of 2) */
+    workgroupSize?: number;
+    /** Elements processed per thread in sort passes (default: 4) */
+    elementsPerThread?: number;
+    /** Enable debug timing via timestamp queries (default: false) */
+    enableTimestamps?: boolean;
+    /** Canvas width for projection calculations */
+    canvasWidth: number;
+    /** Canvas height for projection calculations */
+    canvasHeight: number;
+}
+interface SplatSortStats {
+    /** Number of splats currently being sorted */
+    splatCount: number;
+    /** Number of workgroup blocks for sort */
+    blockCount: number;
+    /** GPU time for compression pass (ms, if timestamps enabled) */
+    compressTimeMs?: number;
+    /** GPU time for sort passes (ms, if timestamps enabled) */
+    sortTimeMs?: number;
+    /** GPU time for render (ms, if timestamps enabled) */
+    renderTimeMs?: number;
+    /** Total GPU time (ms) */
+    totalTimeMs?: number;
+    /** Memory usage in bytes */
+    memoryUsageBytes: number;
+}
+interface CameraState {
+    /** View matrix (column-major, 16 floats) */
+    viewMatrix: Float32Array;
+    /** Projection matrix (column-major, 16 floats) */
+    projMatrix: Float32Array;
+    /** View-projection matrix (column-major, 16 floats) */
+    viewProjectionMatrix: Float32Array;
+    /** Camera position in world space */
+    cameraPosition: [number, number, number];
+    /** Focal length X in pixels */
+    focalX: number;
+    /** Focal length Y in pixels */
+    focalY: number;
+}
+declare class GaussianSplatSorter {
+    private context;
+    private device;
+    private options;
+    private sortShaderModule;
+    private compressShaderModule;
+    private renderShaderModule;
+    private compressPipeline;
+    private histogramPipeline;
+    private blellochScanPipeline;
+    private globalPrefixPipeline;
+    private scatterPipeline;
+    private renderPipeline;
+    private rawSplatBuffer;
+    private compressedSplatBuffer;
+    private sortKeysA;
+    private sortKeysB;
+    private sortValuesA;
+    private sortValuesB;
+    private blockHistogramsBuffer;
+    private globalPrefixesBuffer;
+    private compressUniformBuffer;
+    private sortUniformBuffer;
+    private renderUniformBuffer;
+    private compressBindGroup;
+    private splatCount;
+    private blockCount;
+    private initialized;
+    constructor(context: WebGPUContext, options: GaussianSplatSorterOptions);
+    /**
+     * Initialize all GPU resources: shaders, pipelines, buffers.
+     *
+     * Must be called before any sort or render operations.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create and validate shader modules with cross-browser error reporting.
+     */
+    private createShaderModules;
+    /**
+     * Create all compute pipelines for the sort.
+     */
+    private createComputePipelines;
+    /**
+     * Create render pipeline for sorted splat rendering.
+     */
+    private createRenderPipeline;
+    /**
+     * Allocate all GPU buffers.
+     */
+    private createBuffers;
+    private createSortBuffer;
+    /**
+     * Upload raw splat data to the GPU.
+     *
+     * Expected layout per splat (64 bytes):
+     *   position: vec3<f32>  (12 bytes)
+     *   scale:    vec3<f32>  (12 bytes)
+     *   rotation: vec4<f32>  (16 bytes) - quaternion (w, x, y, z)
+     *   color:    vec4<f32>  (16 bytes) - RGBA [0..1]
+     *   padding:             (8 bytes)
+     *
+     * @param data Raw splat data as Float32Array
+     * @param count Number of splats (not bytes)
+     */
+    uploadSplatData(data: Float32Array, count: number): void;
+    /**
+     * Execute the full sort pipeline: compress -> 4-pass radix sort.
+     *
+     * Should be called each frame before rendering when the camera moves.
+     * Uses a single command encoder for all passes to minimize CPU overhead.
+     *
+     * @param camera Current camera state for depth computation
+     * @param commandEncoder Optional encoder to chain with other passes
+     * @returns Command encoder with all sort passes recorded
+     */
+    sort(camera: CameraState, commandEncoder?: GPUCommandEncoder): GPUCommandEncoder;
+    /**
+     * Record compression compute pass.
+     */
+    private recordCompressPass;
+    /**
+     * Record one radix sort pass (histogram + scan + scatter).
+     */
+    private recordSortPass;
+    /**
+     * Record render pass for sorted Gaussian splats.
+     *
+     * @param encoder Command encoder to record into
+     * @param camera Camera state for rendering
+     * @param colorView Color attachment view
+     * @param depthView Depth attachment view
+     * @param clearColor Optional clear color (default: transparent black)
+     */
+    recordRenderPass(encoder: GPUCommandEncoder, camera: CameraState, colorView: GPUTextureView, depthView: GPUTextureView, clearColor?: GPUColor): void;
+    /**
+     * Execute full frame: sort + render in a single command submission.
+     *
+     * This is the main per-frame method for most use cases.
+     *
+     * @param camera Current camera state
+     * @param colorView Color attachment view
+     * @param depthView Depth attachment view
+     * @param clearColor Optional clear color
+     */
+    frame(camera: CameraState, colorView: GPUTextureView, depthView: GPUTextureView, clearColor?: GPUColor): void;
+    /**
+     * Get current sort statistics.
+     */
+    getStats(): SplatSortStats;
+    /**
+     * Calculate total GPU memory usage in bytes.
+     */
+    getMemoryUsage(): number;
+    /**
+     * Get the sorted index buffer (for external rendering integration).
+     *
+     * After sort(), the sorted indices are in sortValuesA (for even pass count).
+     */
+    getSortedIndicesBuffer(): GPUBuffer;
+    /**
+     * Get the compressed splat buffer (for external rendering integration).
+     */
+    getCompressedSplatBuffer(): GPUBuffer;
+    /**
+     * Update canvas dimensions (e.g., on resize).
+     */
+    updateDimensions(width: number, height: number): void;
+    /**
+     * Destroy all GPU resources.
+     */
+    destroy(): void;
+}
+
+interface ExtractorOptions {
+    /** Maximum splats to extract */
+    maxSplats: number;
+}
+/**
+ * Extracts raw GPU sorted data from a GaussianSplatSorter.
+ * Uses GPUBuffer.mapAsync to read back the `compressedSplatBuffer` and `sortValuesA` buffers
+ * which contain the natively sorted WebGPU output.
+ *
+ * Mitigation for mapAsync stalls: We use double buffering to pipeline the readbacks.
+ */
+declare class GaussianSplatExtractor {
+    private context;
+    private device;
+    private options;
+    private readbackBuffersA;
+    private readbackBuffersB;
+    private isUsingA;
+    private ongoingReadback;
+    private frameCounter;
+    constructor(context: WebGPUContext, options: ExtractorOptions);
+    private initializeBuffers;
+    private createReadbackBuffer;
+    /**
+     * Captures the sorted state of the GaussianSplatSorter.
+     * Internally pipelines the GPU readback to avoid stalling the main render loop.
+     */
+    extractFrame(sorter: GaussianSplatSorter, camera: CameraState, compressedSource: GPUBuffer, indicesSource: GPUBuffer): Promise<INeuralSplatPacket | null>;
+}
+
+/**
+ * TetGenWasmMesher — WASM-based tetrahedralization using TetGen.
+ *
+ * This mesher provides high-fidelity constrained Delaunay tetrahedralization
+ * of arbitrary piecewise linear complexes (PLC).
+ */
+
+declare class TetGenWasmMesher implements WasmMesher {
+    private wasmModule;
+    constructor();
+    initialize(): Promise<void>;
+    tetrahedralize(surface: SurfaceMesh, options?: SurfaceMeshOptions): Promise<TetMesh>;
+}
+
+interface NetworkState<T> {
+    sequenceNumber: number;
+    state: T;
+}
+
+/**
+ * KeyboardSystem.ts
+ *
+ * Handles virtual keyboard interactions.
+ * Listens for UI events and updates TextInput components.
+ */
+
+/** Extended runtime interface for keyboard-specific methods */
+interface KeyboardRuntime extends HSPlusRuntime {
+    findInstanceById(id: string): {
+        node: {
+            id: string;
+            type: string;
+            properties: Record<string, unknown>;
+        };
+        children?: Array<{
+            node: {
+                id: string;
+                type: string;
+                properties: Record<string, unknown>;
+            };
+        }>;
+    } | null;
+    updateNodeProperty(id: string, key: string, value: unknown): void;
+}
+declare class KeyboardSystem {
+    private runtime;
+    private focusedInputId;
+    private cursorIndex;
+    private static readonly CHAR_WIDTH;
+    private static readonly START_X;
+    constructor(runtime: KeyboardRuntime);
+    private setupListeners;
+    handleEvent(event: string, payload: any): void;
+    private handleKeyPress;
+    private insertAtCursor;
+    private getText;
+    private updateInputState;
+    private setCursorVisible;
+    private updateCursorVisuals;
+}
+
+declare class HandMenuSystem {
+    private runtime;
+    private menuNodeId;
+    private menuNode;
+    private isMenuVisible;
+    private isTransitioning;
+    private lastToggleTime;
+    private transitions;
+    constructor(runtime: HSPlusRuntime, engine?: AnimationEngine);
+    update(delta: number): void;
+    private checkPalmFacingUser;
+    private showMenu;
+    private hideMenu;
+}
+
+/**
+ * HoloScript+ Runtime Engine
+ *
+ * Executes parsed HoloScript+ AST with:
+ * - Control flow (@for, @if) evaluation
+ * - Lifecycle hook management
+ * - VR trait integration
+ * - Reactive state binding
+ * - TypeScript companion integration
+ *
+ * @version 1.0.0
+ */
+
+type LifecycleHandler = (...args: unknown[]) => void;
+interface NodeInstance {
+    __holo_id: string;
+    node: HSPlusNode;
+    properties: Record<string, unknown>;
+    renderedNode: unknown;
+    lifecycleHandlers: Map<string, LifecycleHandler[]>;
+    children: NodeInstance[];
+    parent: NodeInstance | null;
+    destroyed: boolean;
+    templateName?: string;
+    templateVersion?: number;
+    dirty: boolean;
+    hasTraits: boolean;
+}
+interface RuntimeOptions {
+    renderer?: Renderer;
+    vrEnabled?: boolean;
+    companions?: Record<string, Record<string, (...args: unknown[]) => unknown>>;
+    manifestUrl?: string;
+    baseUrl?: string;
+    webXrManagerClass?: unknown;
+}
+interface Renderer {
+    createElement(type: string, properties: Record<string, unknown>): unknown;
+    updateElement(element: unknown, properties: Record<string, unknown>): void;
+    appendChild(parent: unknown, child: unknown): void;
+    removeChild(parent: unknown, child: unknown): void;
+    destroy(element: unknown): void;
+    setXRSession?(session: XRSession | null, glBinding: unknown | null, projectionLayer: unknown | null): void;
+}
+/** Extended renderer interface for WebXR-capable renderers (e.g. WebGPURenderer). */
+declare class HoloScriptPlusRuntimeImpl implements HSPlusRuntime {
+    private ast;
+    private options;
+    state: ReactiveState<StateDeclaration>;
+    private evaluator;
+    private builtins;
+    private traitRegistry;
+    private rootInstance;
+    private eventHandlers;
+    private templates;
+    private updateLoopId;
+    private lastUpdateTime;
+    private companions;
+    private networkSync;
+    private mounted;
+    private scaleMultiplier;
+    private chunkLoader;
+    private hotReloader;
+    private networkPredictor;
+    private movementPredictor;
+    private _flatEntities;
+    private _copilot;
+    /**
+     * Set the AI Copilot for generate directive processing.
+     */
+    setCopilot(copilot: {
+        isReady(): boolean;
+        generateFromPrompt(prompt: string, options: Record<string, unknown>): Promise<unknown>;
+    }): void;
+    vrContext: {
+        hands: {
+            left: VRHand | null;
+            right: VRHand | null;
+        };
+        headset: {
+            position: Vector3;
+            rotation: Vector3;
+        };
+        controllers: {
+            left: unknown;
+            right: unknown;
+        };
+    };
+    private webXrManager;
+    private isXRSessionActive;
+    private physicsWorld;
+    private vrPhysicsBridge;
+    private debugDrawer;
+    keyboardSystem: KeyboardSystem;
+    handMenuSystem: HandMenuSystem;
+    constructor(ast: HSPlusAST, options?: RuntimeOptions);
+    enterVR(): Promise<void>;
+    /**
+     * Main XR Loop - called by WebXRManager
+     */
+    private xrLoop;
+    exitVR(): Promise<void>;
+    /**
+     * Convert Quaternion to Euler Angles (YXZ sequence)
+     */
+    private quaternionToEuler;
+    private updateVRInput;
+    private initializeState;
+    private loadImports;
+    mount(container: unknown): void;
+    unmount(): void;
+    /**
+     * Scans the AST for all template definitions, including nested ones.
+     */
+    private findAllTemplates;
+    /**
+     * Dynamically mount a new object into the scene (e.g. from a lazy-loaded chunk)
+     */
+    mountObject(node: HSPlusNode, parent?: NodeInstance | null): NodeInstance;
+    unmountObject(idOrInstance: string | NodeInstance): void;
+    private _holoIdCounter;
+    private generateHoloId;
+    private instantiateNode;
+    getNode(id: string): HSPlusNode | undefined;
+    private processDirectives;
+    private registerLifecycleHandler;
+    private processControlFlow;
+    private cloneNodeWithContext;
+    private interpolateString;
+    private interpolateProperties;
+    private evaluateExpression;
+    private evaluateProperties;
+    /**
+     * Expands spread expressions in a properties object.
+     * Spread keys are formatted as __spread_N with value { type: 'spread', argument: ... }
+     */
+    private expandPropertySpreads;
+    /**
+     * Expands spread expressions within an array.
+     */
+    private expandArraySpreads;
+    /**
+     * Resolves a spread argument to its runtime value.
+     */
+    private resolveSpreadArgument;
+    private callLifecycle;
+    private startUpdateLoop;
+    private stopUpdateLoop;
+    update(delta: number): void;
+    /**
+     * Authoritative server sync for networked state.
+     */
+    onNetworkStateUpdate(serverState: NetworkState<Record<string, unknown>>): void;
+    private updateInstance;
+    private syncAvatarParts;
+    private generatedNodes;
+    private processGenerateDirectives;
+    private apiPollingTimers;
+    private updateExternalApis;
+    private executeExternalApi;
+    private parseDurationToMs;
+    private createTraitContext;
+    private destroyInstance;
+    togglePhysicsDebug(enabled: boolean): void;
+    updateData(data: unknown): void;
+    updateNodeProperty(nodeId: string, property: string, value: unknown): void;
+    getState(): Record<string, unknown>;
+    getVariable(name: string): unknown;
+    setVariable(name: string, value: unknown): void;
+    getContext(): Record<string, unknown>;
+    reset(): void;
+    updateAnimations(): void;
+    updateParticles(delta: number): void;
+    getHologramStates(): Map<string, Record<string, unknown>>;
+    setState(updates: Partial<StateDeclaration>): void;
+    emit(event: string, payload?: unknown): void;
+    updateEntity(id: string, properties: Partial<Record<string, unknown>>): boolean;
+    on(event: string, handler: (payload: unknown) => void): () => void;
+    hotReload(newAst: HSPlusAST): Promise<void>;
+    /**
+     * Creates a Map proxy that reflects the reactive state.
+     * This allowed the HotReloader (designed for Map-based state) to work with
+     * the runtime's Record-based reactive state.
+     */
+    private createStateMapProxy;
+    findInstanceById(id: string, root?: NodeInstance | null): NodeInstance | null;
+    /**
+     * Executes a block of HoloScript+ statements
+     */
+    executeStatementBlock(instance: NodeInstance, body: HSPlusStatement[]): Promise<void>;
+    /**
+     * Executes a single HoloScript+ statement
+     */
+    executeStatement(instance: NodeInstance, stmt: HSPlusStatement): Promise<void>;
+    private migrateInstancesOfTemplate;
+    private findAllInstancesOfTemplate;
+    private migrateInstance;
+    private executeMigrationCode;
+    updateVRContext(context: typeof this.vrContext): void;
+    handleVREvent(event: TraitEvent, node: HSPlusNode): void;
+    private findInstance;
+    registerTemplate(name: string, node: HSPlusNode): void;
+    spawnTemplate(name: string, position: Vector3): HSPlusNode;
+    destroyNode(node: HSPlusNode): void;
+}
+/**
+ * Create a new HoloScript+ runtime instance
+ */
+declare function createRuntime(ast: HSPlusAST, options?: RuntimeOptions): HSPlusRuntime;
+
+/**
+ * InstancedRenderer.ts
+ *
+ * GPU instanced rendering system for massive object counts.
+ * Allows rendering 10,000+ similar objects with minimal draw calls.
+ *
+ * Features:
+ * - Automatic batching by geometry type and material
+ * - GPU instancing (1 draw call per batch vs 1 per object)
+ * - Dynamic instance management (add/remove/update)
+ * - Transform matrix updates (position, rotation, scale)
+ * - Material variation support
+ * - Performance monitoring
+ */
+interface InstancedObject {
+    /** Unique instance ID */
+    id: string;
+    /** Batch key (geometry + material) */
+    batchKey: string;
+    /** Instance index in batch */
+    instanceIndex: number;
+    /** Transform matrix (16 floats) */
+    matrix: Float32Array;
+    /** Material color override */
+    color?: [number, number, number];
+    /** Visibility flag */
+    visible: boolean;
+}
+interface InstanceBatch {
+    /** Batch identifier */
+    key: string;
+    /** Geometry type */
+    geometryType: string;
+    /** Material type */
+    materialType: string;
+    /** Three.js InstancedMesh */
+    instancedMesh: any;
+    /** Maximum instances */
+    maxInstances: number;
+    /** Current instance count */
+    count: number;
+    /** Instance ID → Index mapping */
+    instanceMap: Map<string, number>;
+    /** Free instance indices (for reuse) */
+    freeIndices: number[];
+    /** Needs matrix update */
+    needsUpdate: boolean;
+}
+interface InstancedRenderingStats {
+    /** Total batches */
+    batchCount: number;
+    /** Total instances across all batches */
+    totalInstances: number;
+    /** Draw calls (one per batch) */
+    drawCalls: number;
+    /** Memory usage (approximate, MB) */
+    memoryUsage: number;
+    /** Performance improvement vs non-instanced */
+    improvement: string;
+}
+/**
+ * Instanced Rendering Manager
+ * Automatically batches similar objects for GPU instancing
+ */
+declare class InstancedRenderer {
+    private batches;
+    private objects;
+    private scene;
+    private maxInstancesPerBatch;
+    private enabled;
+    constructor(scene: any, maxInstancesPerBatch?: number);
+    /**
+     * Add object to instanced rendering
+     */
+    addInstance(id: string, geometryType: string, materialType: string, position: [number, number, number], rotation?: [number, number, number], scale?: [number, number, number], color?: [number, number, number]): boolean;
+    /**
+     * Remove instance from rendering
+     */
+    removeInstance(id: string): boolean;
+    /**
+     * Update instance transform
+     */
+    updateInstance(id: string, position?: [number, number, number], rotation?: [number, number, number], scale?: [number, number, number]): boolean;
+    /**
+     * Update instance color
+     */
+    updateInstanceColor(id: string, color: [number, number, number]): boolean;
+    /**
+     * Update all batches (call once per frame)
+     */
+    update(): void;
+    /**
+     * Create a new batch
+     */
+    private createBatch;
+    /**
+     * Create geometry by type
+     */
+    private createGeometry;
+    /**
+     * Create material by type
+     */
+    private createMaterial;
+    /**
+     * Create transform matrix from position, rotation, scale
+     */
+    private createTransformMatrix;
+    /**
+     * Convert Float32Array to THREE.Matrix4
+     */
+    private arrayToMatrix4;
+    /**
+     * Extract transform from matrix
+     */
+    private matrixToTransform;
+    /**
+     * Get statistics
+     */
+    getStatistics(): InstancedRenderingStats;
+    /**
+     * Enable/disable instanced rendering
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Clear all batches
+     */
+    clear(): void;
+    /**
+     * Get batch for inspection
+     */
+    getBatch(key: string): InstanceBatch | undefined;
+    /**
+     * Get all batch keys
+     */
+    getBatchKeys(): string[];
+}
+
+/**
+ * @holoscript/core Asset Streamer Interface
+ *
+ * Defines the @builtin runtime interface for predictive asset streaming.
+ * Runtimes implement this to manage low-priority background loading and decompression.
+ */
+/**
+ * Asset streaming priority
+ */
+declare enum StreamPriority {
+    IMMEDIATE = 0,
+    PREDICTIVE_HIGH = 1,
+    PREDICTIVE_LOW = 2,
+    BACKGROUND = 3
+}
+/**
+ * Asset metadata for streaming
+ */
+interface AssetStreamRequest {
+    id: string;
+    url: string;
+    type: 'mesh' | 'texture' | 'audio' | 'script';
+    priority: StreamPriority;
+    size?: number;
+    compression?: 'draco' | 'meshopt' | 'none';
+}
+/**
+ * Streaming status
+ */
+interface StreamStatus {
+    id: string;
+    progress: number;
+    state: 'queued' | 'loading' | 'decompressing' | 'ready' | 'error';
+    error?: string;
+}
+/**
+ * AssetStreamer @builtin Interface
+ */
+interface AssetStreamer {
+    /** Initialize the streamer with config */
+    initialize(config: {
+        workerPoolSize?: number;
+        memoryLimitMB?: number;
+    }): Promise<void>;
+    /**
+     * Request an asset to be streamed.
+     * If priority is PREDICTIVE, it will be loaded in the background.
+     */
+    requestAsset(request: AssetStreamRequest): void;
+    /** Cancel a pending stream request */
+    cancelRequest(id: string): void;
+    /** Get the status of a specific asset stream */
+    getStatus(id: string): StreamStatus | undefined;
+    /** Purge old or distant assets from memory */
+    purgeAssets(distanceThreshold: number, currentPlayerPos: [number, number, number]): void;
+    /** Dispose resources */
+    dispose(): void;
+}
+/**
+ * Global registry for builtin AssetStreamers
+ */
+declare const assetStreamerRegistry: Map<string, AssetStreamer>;
+/**
+ * Register an asset streamer implementation
+ */
+declare function registerAssetStreamer(name: string, streamer: AssetStreamer): void;
+/**
+ * Get a registered asset streamer
+ */
+declare function getAssetStreamer(name: string): AssetStreamer | undefined;
+
+export { type AssetStreamRequest, type AssetStreamer, type CollisionCallback, type CollisionEvent, DEFAULT_GENERATION_OPTIONS, DEFAULT_LOD_CONFIG, DEFAULT_LOD_LEVEL, DEFAULT_MANAGER_OPTIONS, DEFAULT_MESHLET_OPTIONS, EngineSystem, type ExtractorOptions, GaussianSplatExtractor, type GeneratedLODLevel, HoloScriptPlusRuntimeImpl, type InstanceBatch, type InstancedObject, InstancedRenderer, type InstancedRenderingStats, index as LOD, LODBridge, type LODBridgeOptions, type LODChain, type LODChainLevel, type LODConfig, type LODEvent, type LODEventHandler, type LODEventType, type LODFeature, type LODGenerationOptions, type LODGenerationResult, LODGenerator, type LODGroup, type LODHierarchy, type LODLevel, type LODLevelHistogram, LODManager, type LODManagerOptions, LODMemoryPool, type LODMetrics, LODPerformanceMetrics, type LODState, type LODStrategy, LODTransition, type LODTransitionConfig, type MemoryPoolOptions, type MeshData, type MeshValidation, type Meshlet, type MeshletGenerationResult, MeshletGenerator, type MeshletGeneratorOptions, type NodeInstance, type PerformanceSnapshot, type PhysicsBodyState, PhysicsStep, type PoolStatistics, type PooledBuffer, type ProfilingData, type Renderer, type RuntimeOptions, STANDARD_DISTANCES, STANDARD_RATIOS, type ScheduledTransition, type SimplificationAlgorithm, StreamPriority, type StreamStatus, TetGenWasmMesher, type TransitionBudget, type TransitionCostAnalysis, type TransitionMode, TransitionScheduler, type TransitionState, type Vec3, assetStreamerRegistry, calculateOptimalDistances, calculateScreenCoverage, createLODGenerator, createLODGroup, createLODLevel, createLODManager, createLODMemoryPool, createLODMetrics, createLODPerformanceMetrics, createLODState, createMeshletGenerator, createMobileLODManager, createMobileMemoryPool, createRuntime, createStandardLODConfig, createTestCube, createTestSphere, createVRLODManager, createVRMemoryPool, generateLODs, generateMeshlets, getAssetStreamer, getRecommendedLODCount, getTrianglesSaved, mergeLODConfigs, registerAssetStreamer, selectLODLevelByDistance, selectLODLevelByScreenCoverage, validateLODConfig };