@forgeax/engine-render 0.1.2

package/dist/instance-buffer-cache.d.ts

@@ -0,0 +1,59 @@
+import type { GpuBuffer } from './gpu-resource';
+export declare function temporalInstanceUploadByteLength(current: Float32Array, storageBufferAvailable: boolean): number;
+/** Pack current and last-submitted instance transforms into the shared storage ABI. */
+export declare function packTemporalInstanceTransforms(current: Float32Array, previous: Float32Array | undefined): Float32Array;
+/**
+ * One entry of the per-RenderSystem instance-transform GPU storage cache.
+ *
+ * The `buffer` field is a `GpuBuffer` wrapper (feat-20260612 M-2/M-3): it
+ * holds the raw RHI handle, owns the lifecycle (`destroy()` + `isDestroyed`)
+ * and routes dispose through the RHI shim's destroy bookkeeping SSOT. The
+ * two `uploaded*` fields are the cache invalidation fingerprint -- when the
+ * archetype version bumps or the byte length changes, the record stage
+ * allocates a fresh GpuBuffer and replaces the entry.
+ */
+export interface InstanceBufferCacheEntry {
+    readonly buffer: GpuBuffer;
+    readonly uploadedByteLength: number;
+    readonly uploadedArchVersion: number;
+}
+/**
+ * Minimal error-registry surface accepted by disposeInstanceBuffers —
+ * only needs `fire`, matching RhiErrorListenerRegistry (feat-20260619 D-6).
+ */
+export interface InstanceBufferCacheErrorSink {
+    fire(e: {
+        code: string;
+    }): void;
+}
+/**
+ * Walk an instance-buffer cache Map, destroy every entry's GpuBuffer, then
+ * clear the Map. Called from `Renderer.dispose()` (M-5) as the per-frame
+ * instance-buffer release step in the dispose chain
+ * (plan-strategy D-2: gpuStore.destroyAll -> graph.drain ->
+ * frameState.instanceBuffers cleanup -> ...).
+ *
+ * Idempotent (architecture-principles §6): a second call after the Map was
+ * cleared is a no-op. Each `.destroy()` routes through the RHI shim's
+ * per-handle bookkeeping; a stray second-destroy on a handle that the
+ * runtime did not flip surfaces as the structured 'destroy-after-destroy'
+ * RhiError from the shim. That error is *not* re-thrown -- this helper
+ * is a sweep that tolerates per-handle failures so the dispose chain can
+ * make progress (mirrors `GpuResourceStore.destroyAll`'s policy;
+ * plan-strategy D-3 / D-8).
+ *
+ * feat-20260619 M4 (D-6): the optional `errorRegistry` parameter unifies
+ * the dispose path with the per-frame path — destroy failures fire
+ * errorRegistry + sweep continues. Callers that lack an error registry
+ * (unit tests of the helper itself) omit the parameter safely.
+ *
+ * Per-frame Map.delete cleanup at the record stage keeps its existing
+ * 'just delete the key' semantics (plan-strategy D-7 + OOS-11): the
+ * per-frame path bumps fingerprints when the archetype version changes,
+ * letting the next record stage replace the entry; only the dispose
+ * exit path walks-then-destroys.
+ */
+export declare function disposeInstanceBuffers(map: Map<number, InstanceBufferCacheEntry>, errorRegistry?: InstanceBufferCacheErrorSink): void;
+/** Destroy transient uniform-fallback chunks allocated for the previous frame. */
+export declare function disposeTransientInstanceBuffers(entries: InstanceBufferCacheEntry[], errorRegistry?: InstanceBufferCacheErrorSink): void;
+//# sourceMappingURL=instance-buffer-cache.d.ts.map

package/dist/instance-buffer-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-buffer-cache.d.ts","sourceRoot":"","sources":["../src/instance-buffer-cache.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,YAAY,EACrB,sBAAsB,EAAE,OAAO,GAC9B,MAAM,CAER;AAED,uFAAuF;AACvF,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,YAAY,GAAG,SAAS,GACjC,YAAY,CAed;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;CACtC;AAaD;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC3C,IAAI,CAAC,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,EAC1C,aAAa,CAAC,EAAE,4BAA4B,GAC3C,IAAI,CAGN;AAED,kFAAkF;AAClF,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,wBAAwB,EAAE,EACnC,aAAa,CAAC,EAAE,4BAA4B,GAC3C,IAAI,CAGN"}

package/dist/internal.d.ts

@@ -0,0 +1,74 @@
+export type { RenderAssetPort } from './assets/render-asset-port';
+export * from './authoring';
+export * from './cluster-binner';
+export * from './components/camera';
+export * from './components/light-helpers';
+export { createDebugDrawOnReady, releaseDebugDraw } from './debug-draw-glue';
+export { createEngineMetrics } from './engine-metrics';
+export * from './environment/generation';
+export * from './environment/graph';
+export * from './environment/signature';
+export * from './errors/index';
+export * from './errors/recover';
+export * from './extract/schema-readers';
+export * from './features/host';
+export { createRenderFeatureGraphicsPrepare, validateRenderFeatureGraphicsPass, } from './features/prepared-graphics';
+export type { RenderFeatureCapabilityMissingDetail, RenderFeatureCleanupFailure, RenderFeatureDrawRecordingFailedDetail, RenderFeatureErrorDetailByCode, RenderFeaturePassOrderConflictDetail, RenderFeaturePreparationFailedDetail, RenderFeaturePreparedStateMismatchDetail, RenderFeatureRegistrationConflictDetail, RenderFeatureStageFailedDetail, } from './features/types';
+export * from './fullscreen-post-process-pass';
+export type { GpuResource } from './gpu-resource';
+export { GpuBuffer, GpuTexture } from './gpu-resource';
+export { GpuResourceStore } from './gpu-resource-store';
+export * from './gpu-scene';
+export * from './gpu-scene-schema';
+export * from './hdrp-buffers';
+export * from './hdrp-pipeline';
+export * from './ibl/IblPipelineCache';
+export * from './ibl/skylight-bind-group';
+export * from './index';
+export * from './instance-buffer-cache';
+export * from './lifecycle';
+export * from './light-buffer-layout';
+export * from './mesh-material-bindings';
+export * from './pbr-pipeline';
+export * from './persistent-render-scene';
+export * from './pipeline-builder';
+export * from './pipeline-errors';
+export * from './pipeline-spec';
+export * from './post-process-errors';
+export * from './prepare/schema-readers';
+export * from './record/frame-snapshot';
+export * from './record/frame-targets';
+export * from './record/index';
+export * from './record/main-pass-material';
+export * from './record/membership-timing';
+export * from './record/skybox-post-pass';
+export * from './record/view-ubo';
+export * from './render-data';
+export * from './render-graph-primitives';
+export type { _InternalRenderPipelineContext } from './render-pipeline-context';
+export * from './render-scene-projection';
+export * from './render-system';
+export * from './render-system-extract';
+export * from './render-system-fold';
+export type { EngineEnvironmentErrorDetail } from './renderer/environment-error';
+export { EngineEnvironmentError } from './renderer/environment-error';
+export * from './renderer/renderer-factory';
+export * from './scene-instances/post-spawn-resolve-joints';
+export { collectSubtree } from './scene-utils/collect-subtree';
+export * from './shadow-atlas';
+export * from './ssao-buffers';
+export * from './ssao-config';
+export * from './ssao-data';
+export * from './surface-format';
+export * from './systems/active-camera';
+export * from './systems/pass-selector';
+export * from './systems/skin-palette-allocator';
+export * from './systems/transparent-sort-config';
+export * from './taa-history-store';
+export * from './temporal-coverage';
+export * from './temporal-frame-transaction';
+export * from './temporal-view';
+export * from './tilemap/resolve-tileset-runtime';
+export * from './tilemap-chunk-extract-system';
+export { URP_PIPELINE_ID, urpPipeline } from './urp-pipeline';
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAEA,YAAY,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,OAAO,EACL,kCAAkC,EAClC,iCAAiC,GAClC,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,oCAAoC,EACpC,2BAA2B,EAC3B,sCAAsC,EACtC,8BAA8B,EAC9B,oCAAoC,EACpC,oCAAoC,EACpC,wCAAwC,EACxC,uCAAuC,EACvC,8BAA8B,GAC/B,MAAM,kBAAkB,CAAC;AAC1B,cAAc,gCAAgC,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,SAAS,CAAC;AACxB,cAAc,yBAAyB,CAAC;AACxC,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,2BAA2B,CAAC;AAC1C,YAAY,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAChF,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,YAAY,EAAE,4BAA4B,EAAE,MAAM,8BAA8B,CAAC;AACjF,OAAO,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AACtE,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iBAAiB,CAAC;AAChC,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/internal.mjs

@@ -0,0 +1,45 @@
+import './chunk-JMSB7AR4.mjs';
+export { EngineEnvironmentError, GpuResourceStore, HealthListenerRegistry, LostListenerRegistry, RhiErrorListenerRegistry, SHADOW_PROBE_WGSL, assembleMaterialProjection, buildPipelineForMaterialShader, createEngineMetrics, createMaterialAssetService, createMeshSsboGrowController, createRenderer, createSkinPaletteAllocator, deriveRecoverable, deriveStorageBufferCeiling, loadRhiPack, resolveMaterialShaderBindingContract, resolveMaterialShaderVariantSet, resolveMaterialShaderVertexInputContract, selectHdrpPbrPrewarmVariants, selectPipelineLayoutForVariant } from './chunk-33UF5SAO.mjs';
+export { _peekPerCellStreamingLayerKeys, computeChunkStreamBounds, effectivePivotYForTilemapFlip, encodeTilemapLayerValue, resetTilemapChunkExtractCache, resetTilemapDerivedEntityTracker, resolveTilesetRuntime, tilemapChunkExtractSystem } from './chunk-QRXPSX4X.mjs';
+export { MORPH_COMPUTE_WGSL, MORPH_MAX_TARGETS, collectSubtree, createMorphFeature, createMorphReentryState, deriveMorphBounds, materialContribution, morphCullDecision, ownedRendererPlugin, postSpawnResolveJoints, renderComponentsPlugin, renderFeaturePlugin, renderPipelineContribution, rendererPlugin, samplerContribution, stepMorphReentry } from './chunk-LXNGO6AO.mjs';
+import { MESH_PER_ENTITY_STRIDE } from './chunk-A5QCJSNL.mjs';
+export { ACTIVE_CAMERA_KEY, ATMOSPHERE_BACKGROUND_PARAMS_SLOT, ATMOSPHERE_PARAMS_BYTES, ATMOSPHERE_PARAMS_SLOT_BYTES, ATMOSPHERE_PARAMS_SLOT_COUNT, ATMOSPHERE_PRODUCER_KINDS, ATMOSPHERE_PRODUCER_PASS_COUNT, ATMOSPHERE_SUN_DISC_PARAMS_SLOT, BRDF_LUT_SIZE, BYTES_PER_LIGHT_SLOT, CAPTURE_VIEW_PROJS, CLUSTER_GRID_STRIDE_U32, CUBEMAP_FACE_VERTICES, CascadeVolumeSetBuilder, DEFAULT_CLUSTER_GRID, DEFERRED_COLOR_FORMATS, DEPTH_MIN_PARAMS_BYTE_SIZE, EMPTY_TEMPORAL_COVERAGE, FALLBACK_BYTES_PER_ROW, FOLDED_DRAWS_METRIC_KEY, FOLD_UNIFORM_INSTANCE_CAP, GPU_SCENE_LAYOUTS, GPU_SCENE_PRIMITIVE_FLAGS, GPU_SCENE_SCHEMAS, GPU_SCENE_WGSL, GpuBuffer, GpuScene, GpuTexture, HDRP_PIPELINE_ID, HDRP_UNIFORM_LIGHT_CAPACITY, RhiError as HdrpBufferAllocError, HdrpInstallError, INJECTION_KIND_LENGTHS, INSTANCE_UBO_FULL_ARRAY_BYTES, IRRADIANCE_SIZE, IblCapabilityLossError, KNOWN_PASS_KINDS, LIGHTSLOT_LAYOUT, LIGHT_ARRAY_HEADER_BYTES, LIGHT_ARRAY_MAX_SLOTS, LIGHT_INDEX_LIST_CAPACITY, LightSlotKind, MATERIAL_PER_ENTITY_STRIDE, MAX_LIGHTS, MAX_UNIFORM_INSTANCES, MEMBERSHIP_TIMING_REASON_CODES, MEMBERSHIP_TIMING_REASON_MAPPING, MEMBERSHIP_TIMING_REASON_SCHEMA, MESH_PER_ENTITY_STRIDE, MESH_SSBO_BYTES, MESH_UBO_FULL_ARRAY_BYTES, MembershipTimingError, MeshUpdateError, POINT_LIGHT_SHADOW_LAYER_SENTINEL, POINT_LIGHT_STD430_BYTES, POINT_SHADOW_VIEW_SLOT_COUNT, PREFILTER_MIP_LEVELS, PREFILTER_SIZE, PersistentRenderScene, PipelineError, PipelineSpecError, PostProcessError, RENDER_FEATURE_VERTEX_LAYOUTS, RENDER_PHASE_CATALOG, RecoverError, RenderFeatureComputeGraphProjection, RenderFeatureGraphBufferRegistry, RenderFeatureRasterGraphProjection, RenderSceneProjection, SCENE_TEMPORAL_CLEAR_VALUE, SCENE_TEMPORAL_PACKED_ABI, SCENE_TEMPORAL_TARGET_FORMAT, SCENE_TEMPORAL_TARGET_SAMPLE_COUNT, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS, SKIN_MATERIAL_SHADER_ID, SPEC_CONST_TABLE, SPOT_LIGHT_SHADOW_TILE_SENTINEL, SPOT_LIGHT_STD430_BYTES, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, SSAO_DEFAULT_BIAS, SSAO_DEFAULT_INTENSITY, SSAO_DEFAULT_RADIUS, SSAO_KERNEL_SAMPLE_COUNT, SSAO_UNIFORM_BYTES, SSAO_UNIFORM_INTENSITY_OFFSET, STORAGE_BUFFER_MIN_REQUIRED, ShadowAtlas, TEMPORAL_JITTER_SAMPLE_COUNT, TEMPORAL_MISSING_REASONS, TEMPORAL_PRODUCER_LANES, TEMPORAL_REACTIVE_REASONS, TONEMAP_POST_PROCESS_ID, TaaHistoryStore, TemporalFrameTransaction, URP_PIPELINE_ID, VIEW_UNIFORM_BUFFER_SIZE, VIEW_UNIFORM_BYTES, VIEW_UNIFORM_SLOT_STRIDE, ZERO_CAMERA_CLEAR_FALLBACK, acquireSwapChainTarget, addBloomPasses, addEnvironmentCompositionPass, addEnvironmentProducerPasses, addFullscreenPass, addPointShadowPass, addScenePass, addShadowPass, addSkyboxPass, addSpotShadowPass, addSsaoPasses, addTonemapPass, addTypedBloomPasses, addTypedCompositePostEffects, addTypedFrameObservationPass, addTypedFullscreenPass, addTypedScenePass, addTypedSkyboxPass, addTypedSsaoPasses, addTypedTonemapPass, appendInjection, applyParamSnapshotToUbo, assembleMaterialWithSkylightEntries, assertStorageBufferCap, beginEnvironmentGeneration, bin, buildBeginRenderPassDescriptor, buildBindGroupLayoutDescriptor, buildCascadeLocalCacheTokens, buildFoldDispatchPlan, buildFullscreenPostProcessPass, buildLinearLdrMaterialSpecTable, buildMatchedRenderableIndices, buildPbrMaterialUserRegionEntries, buildPbrPipelineLayouts, buildPbrSkinLayouts, buildPbrViewBglEntries, buildPerSubmeshMaterialBg, buildPipelineDescriptor, buildPointShadowMatrices, buildRenderVisibilityViewDescriptors, buildSpecConstTable, buildUnlitMaterialBgl, buildUnlitMaterialBindGroupEntries, cacheKeyOf, calculateSphereClusterBounds, floatBits as canonicalEnvironmentFloatBits, clampPcfKernelSize, cleanPerEntityCache, clearIblCacheForDevice, clusterSpaceObjectAabb, colorFormatsForPassKind, computeDirectionalCsm, computeInvRangeSquared, computeProjectionMatrix, computeSplitLdrSprite, computeViewMatrix, configureSurface, createClusterBinScratch, createDebugDrawOnReady, createDerivedMaterialSlotPlan, createEnvironmentGenerationState, createEnvironmentPipelineTopology, createEnvironmentProducerGraph, createFullscreenBindGroup, createHdrpBindGroupLayoutDescriptor, createHdrpClusterMembershipBindGroup, createHdrpClusterMembershipBindGroupLayoutDescriptor, createHdrpUnifiedBindGroup, createIblPipelines, createMembershipTiming, createRenderFeatureContributionStaging, createRenderFeatureGpuWorkResolver, createRenderFeatureGraphicsPrepare, createRenderFeatureHost, createRenderFeatureTarget, createRenderPipelineTarget, createRenderSystem, createSkylightFallback, defaultMaterialSnapshot, defaultTransformSnapshot, defaultViewForUserRegionField, degToCos, deriveBglShapeFromShader, deriveCullingRadius, deriveEnvironmentBundleDescriptors, deriveGpuSceneTableLayout, deriveMipUploadLayout, deriveRenderDataCubemap, deriveRenderDataMesh, deriveRenderDataTexture, deriveTextureExtent, derivedParamSchema, detectNineSliceScaleTooSmall, directionalCascadeAtlasSize, directionalCascadeRasterViewport, disposeInstanceBuffers, disposeTransientInstanceBuffers, driveLazyEquirectProjection, encodeDirectionalShadowPass, encodeFullscreenPass, encodeMainPass, encodePointShadowPass, encodeSkyboxPass, encodeSpotShadowPass, ensureMeshSsboCapacity, entityHasTransparentSubmesh, entryHasDepthRead, environmentBundleBytes, environmentClearColor, environmentConsumerSnapshot, environmentGenerationDirty, environmentGenerationEnabled, environmentSignature, evaluateDirectionalShadowCache, evaluateFoldBucketUniformCap, executeEnvironmentProducerTransaction, extractCameraSnapshots, extractEntryResourceHandle, extractFrame, extractFrames, extractRenderableEntity, filterDispatchBySelector, foldDispatchBuckets, generateSsaoKernel, generateSsaoNoise, getActiveCamera, getIblComposedShaders, getIblWgslSource, getOrBuildPipeline, getOrCreateFromChain, getOrCreateHdrpBuffers, getOrCreateIblCache, getOrCreatePerEntity, getOrCreateSsaoBuffers, getOrCreateSsaoFallbackTexture, getRenderFeatureGraphState, getSsaoParameters, gpuSceneFieldOffset, gpuSceneWgsl, graphExecutionPhase, hasIblCache, hdrpPipeline, iblCacheSize, importEnvironmentGraphTargets, importEnvironmentResources, importRenderPipelineSurface, incrementFoldedDrawsMetric, inspectEnvironmentGeneration, interleaveSpriteInstanceBuffer, isEntityFullyTransparent, isGpuMembershipProducerAvailable, isLitMaterialSnapshot, isMaterialBgAssemblyCacheHit, isMeshSsboDevMode, isRenderFeatureTargetHandle, isStandardPbrMaterialShader, makeZeroCameraFallbackSnapshot, matchPass, materialBindingByteLength, materialUboFloatView, mergeSkylightIntoMaterialBgl, ndcPositionToCluster, observeCurrentFrame, packClusterUniform, packLightArrayHeader, packLightSlot, packPointLight, packSpotLight, packTemporalInstanceTransforms, passKindPolicyTable, pointShadowViewOffset, prepareExtractContext, projectFogEnvironment, projectMaterialPipeline, projectRenderFeatureContributions, projectTemporalView, pssmSplit, publishEnvironmentGeneration, rasterItemKey, recordBloomBlurHPass, recordBloomBlurVPass, recordBloomBrightPass, recordBloomCompositePass, recordFrame, recordFxaaPass, recordMainPass, recordPointShadowPass, recordRenderFeatureGraphicsPass, recordResolvedRenderFeatureGraphicsPass, recordShadowPass, recordSkyboxPass, recordSpotShadowPass, recordSsaoBlurPass, recordSsaoCalcPass, refreshExtractedFrameCameras, refreshExtractedFrameLights, refreshExtractedFramePostProcessParams, refreshRenderableMaterialSnapshot, releaseDebugDraw, renderFeatureAttachmentResource, renderStateHash, reportRenderFeatureGraphError, residentTextureView, resolveDepthOnlyView, resolveMaterialSnapshot, resolveMeshMaterialBindings, resolvePostColorDomainContract, resolveShadowMapSize, resolveSpotShadowMapSize, resolveSsaoParameters, resolveSurfaceFormatPair, resolveToneOutputContract, resolveVisibility, routeMaterialPipeline, runIblPrecompute, runRenderFeatureFrame, selectActiveCameraIndex, selectCookedMaterialPipelineForRender, selectEnvironmentSource, selectFog, selectGeometryPipeline, selectLazyEquirectHandle, selectMaterialDrawForRender, selectMaterialPipelineForRender, selectPasses, selectSpritePassVariantSet, selectSwapChainFormat, setActiveCamera, setIblComposedShaders, setIblWgslSource, setMeshSsboDevModeProbeForTests, settlePreparedGraphicsCompletion, snapshotSubmittedTemporalView, sortDispatchByQueue, specsEqual, spriteInstancesCacheHit, summarizeTemporalCoverage, temporalInstanceUploadByteLength, temporalJitterSample, temporalViewId, updateMaterialRuntimeValues, uploadMeshSsboBatch, urpPipeline, userRegionTextureFieldOrder, validateClusterGrid, validateDirection, validateDirectionalLightData, validatePointLightData, validatePointLightShadowData, validateRenderFeatureGraphicsPass, validateSpec, validateSpotLightData, variantSetFromDefines, videoTextureView, viewZToZSlice, warnMultiLightDirectional, warnMultiLightPoint, warnMultiLightSpot, warnMultiSkybox, warnMultiSkylight, worldEntityKey, writeDerivedMaterialPayload, writeMaterialSnapshotPayload, writeViewUbo } from './chunk-A5QCJSNL.mjs';
+export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, AtmosphereCapsInsufficientError, AtmosphereCardinalityInvalidError, AtmosphereParameterInvalidError, AtmosphereProducerFailedError, AtmosphereSunMissingError, BLOOM_DISABLED, BLOOM_ENABLED, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, Camera, DirectionalLight, EnvironmentSourceConflictError, EquirectProjectionFailedError, Fog, FogOwnerConflictError, FogParametersInvalidError, GbufferAttachmentCountMismatchError, GbufferRtAllocFailedError, GlyphText, HdrpCapsInsufficientError, HdrpDeferredCapsInsufficientError, HdrpIndexListOverflowError, HdrpLightBudgetExceededError, Instances, Layer, MaterialSkinAttrMissingError, Materials, MeshFilter, MeshRenderer, MeshSsboCapacityExceededError, MeshSsboCeilingReachedError, ObservationUnavailableError, PointLight, PointLightShadow, PointShadowAtlasBoundsViolationError, PointShadowAtlasUninitializedError, PostProcessParams, RenderFeatureCapabilityMissingError, RenderFeatureDrawRecordingFailedError, RenderFeaturePassOrderConflictError, RenderFeaturePreparationFailedError, RenderFeaturePreparedStateMismatchError, RenderFeatureRegistrationConflictError, RenderFeatureStageFailedError, ResourceInvalidValueError, SKYBOX_MODE_CUBEMAP, SPRITE_PLAYBACK_MODE_CLAMP, SPRITE_PLAYBACK_MODE_LOOP, SPRITE_PREMULTIPLIED_ALPHA_BLEND, SceneInstance, ShadowInvalidConfigError, SkinMaterialMismatchError, SkinPaletteOverflowError, SkyboxBackground, Skylight, SortKey, SpawnLightInvalidBoundsError, SpotLight, SpriteAnimation, SpriteInstances, SpriteInstancesCountMismatchError, SpriteInstancesMutuallyExclusiveWithInstancesError, SpriteInstancesRequiresSpriteShaderError, SpriteRegionOverride, TONEMAP_ACES_FILMIC, TONEMAP_AGX, TONEMAP_CINEON, TONEMAP_LINEAR, TONEMAP_NEUTRAL, TONEMAP_NONE, TONEMAP_REINHARD, TONEMAP_REINHARD_EXTENDED, TRANSPARENT_SORT_CONFIG_KEY, TRANSPARENT_SORT_MODE_DISTANCE, TRANSPARENT_SORT_MODE_LAYER_Y, TRANSPARENT_SORT_MODE_LAYER_YZ, TRANSPARENT_SORT_MODE_LAYER_Z, TaaCapsInsufficientError, TemporalUnsupportedError, TileLayer, Tilemap, VertexStorageBufferUnavailableError, VideoUploadUnsupportedError, Visibility, VisibilityStateValue, antialiasFromF32, bloomEnabledFromF32, cameraProjectionFromF32, decodeSortScope, encodeSortScope, getTransparentSortConfig, glyphTextLayoutSystem, markTileLayerDirty, materialDrawDiagnostic, materialTextureValue, orthographic, perspective, resetGlyphBakeCache, setTransparentSortConfig, skyboxModeFromF32, spritePlaybackModeFromU32, tonemapFromF32, tonemapToU32, visibilityStateFromU32 } from './chunk-YAKEQPWO.mjs';
+
+// src/extract/schema-readers.ts
+function readRenderSchemas(mesh, light, camera) {
+  return {
+    mesh: { assetHandle: mesh.assetHandle },
+    light: { direction: light.direction, intensity: Number(light.intensity ?? 1) },
+    camera: {
+      projection: Number(camera.projection ?? 0),
+      near: Number(camera.near),
+      far: Number(camera.far)
+    }
+  };
+}
+
+// src/record/main-pass-skin.ts
+function _computeSkinGroup2DynOffsets(meshSlotIdx, skinByteOffset) {
+  const meshOffset = meshSlotIdx * MESH_PER_ENTITY_STRIDE;
+  if (skinByteOffset === void 0) return [meshOffset];
+  return [meshOffset, skinByteOffset, skinByteOffset];
+}
+function _skinBgCacheStats(pipelineState) {
+  return pipelineState._skinBgCacheStats;
+}
+
+// src/prepare/schema-readers.ts
+function prepareRenderSchemas(frame) {
+  return {
+    meshAssetHandle: frame.mesh.assetHandle,
+    lightDirection: frame.light.direction,
+    cameraProjection: frame.camera.projection,
+    cameraNear: frame.camera.near,
+    cameraFar: frame.camera.far
+  };
+}
+
+export { _computeSkinGroup2DynOffsets, _skinBgCacheStats, prepareRenderSchemas, readRenderSchemas };
+//# sourceMappingURL=internal.mjs.map
+//# sourceMappingURL=internal.mjs.map

package/dist/internal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extract/schema-readers.ts","../src/record/main-pass-skin.ts","../src/prepare/schema-readers.ts"],"names":[],"mappings":";;;;;;;;;AASO,SAAS,iBAAA,CACd,IAAA,EACA,KAAA,EACA,MAAA,EACe;AACf,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,EAAE,WAAA,EAAa,IAAA,CAAK,WAAA,EAAY;AAAA,IACtC,KAAA,EAAO,EAAE,SAAA,EAAW,KAAA,CAAM,SAAA,EAAW,WAAW,MAAA,CAAO,KAAA,CAAM,SAAA,IAAa,CAAC,CAAA,EAAE;AAAA,IAC7E,MAAA,EAAQ;AAAA,MACN,UAAA,EAAY,MAAA,CAAO,MAAA,CAAO,UAAA,IAAc,CAAC,CAAA;AAAA,MACzC,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,IAAI,CAAA;AAAA,MACxB,GAAA,EAAK,MAAA,CAAO,MAAA,CAAO,GAAG;AAAA;AACxB,GACF;AACF;;;ACCO,SAAS,4BAAA,CACd,aACA,cAAA,EACmB;AACnB,EAAA,MAAM,aAAa,WAAA,GAAc,sBAAA;AACjC,EAAA,IAAI,cAAA,KAAmB,MAAA,EAAW,OAAO,CAAC,UAAU,CAAA;AACpD,EAAA,OAAO,CAAC,UAAA,EAAY,cAAA,EAAgB,cAAc,CAAA;AACpD;AAeO,SAAS,kBAAkB,aAAA,EAEA;AAChC,EAAA,OAAO,aAAA,CAAc,iBAAA;AACvB;;;ACvCO,SAAS,qBAAqB,KAAA,EAA6C;AAChF,EAAA,OAAO;AAAA,IACL,eAAA,EAAiB,MAAM,IAAA,CAAK,WAAA;AAAA,IAC5B,cAAA,EAAgB,MAAM,KAAA,CAAM,SAAA;AAAA,IAC5B,gBAAA,EAAkB,MAAM,MAAA,CAAO,UAAA;AAAA,IAC/B,UAAA,EAAY,MAAM,MAAA,CAAO,IAAA;AAAA,IACzB,SAAA,EAAW,MAAM,MAAA,CAAO;AAAA,GAC1B;AACF","file":"internal.mjs","sourcesContent":["import type { Camera, DirectionalLight } from '../components';\n\nexport interface RenderExtract {\n  readonly mesh: { readonly assetHandle: unknown };\n  readonly light: { readonly direction: unknown; readonly intensity: number };\n  readonly camera: { readonly projection: number; readonly near: number; readonly far: number };\n}\n\n/** Project the canonical render component rows without copying or adapting their shape. */\nexport function readRenderSchemas(\n  mesh: Record<string, unknown>,\n  light: Record<string, unknown>,\n  camera: Record<string, unknown>,\n): RenderExtract {\n  return {\n    mesh: { assetHandle: mesh.assetHandle },\n    light: { direction: light.direction, intensity: Number(light.intensity ?? 1) },\n    camera: {\n      projection: Number(camera.projection ?? 0),\n      near: Number(camera.near),\n      far: Number(camera.far),\n    },\n  };\n}\n\nexport type RenderCameraSchema = typeof Camera;\nexport type RenderDirectionalLightSchema = typeof DirectionalLight;\n","import { MESH_PER_ENTITY_STRIDE } from './mesh-ssbo';\n\n/**\n * feat-20260612-skin-palette-per-frame-upload M3 / m3-2: pure helper that\n * builds the `setBindGroup(2, ...)` dynamic-offset tuple at the skin /\n * non-skin draw site.\n *\n * - Skin entries (`skinByteOffset !== undefined`) bind a 3-entry mesh-array\n *   BGL (binding 0 mesh-array UBO, bindings 1/2 current/previous palette UBOs;\n *   all `hasDynamicOffset: true`), so the tuple carries three offsets: the\n *   mesh slot follows the per-entity 256-byte stride and both palette slots\n *   carry the per-entity cursor M2 m2-6 wrote into\n *   `entry.source.skin.byteOffset`.\n * - Non-skin entries bind the URP / HDRP 1-entry mesh-array BGL, so the\n *   tuple carries only the mesh slot offset (length 1). Adding palette\n *   offset there would trip WebGPU validation against the 1-binding BGL.\n *\n * Extracted from the inline `group2DynamicOffsets = [i * MESH_PER_ENTITY_STRIDE,\n * 0]` site (PR #353 stub) so the contract `group2DynamicOffsets[1] ===\n * byteOffset` is testable from a focused unit fixture without driving\n * recordFrame end-to-end.\n *\n * @internal -- exported for unit test access (m3-1)\n */\nexport function _computeSkinGroup2DynOffsets(\n  meshSlotIdx: number,\n  skinByteOffset: number | undefined,\n): readonly number[] {\n  const meshOffset = meshSlotIdx * MESH_PER_ENTITY_STRIDE;\n  if (skinByteOffset === undefined) return [meshOffset];\n  return [meshOffset, skinByteOffset, skinByteOffset];\n}\n\n/**\n * feat-20260612-skin-palette-per-frame-upload M3 / m3-2: read-side accessor\n * for the per-frame skin BG cache miss / hit counters published by the\n * record stage. Mirrors the existing `bindGroupCounts.createBindGroup`\n * surface but scoped to the skin-mesh BG cache so the m3-1 acceptanceCheck\n * (miss=1 + hit=N-1 across N skinned entities sharing one allocator buffer\n * + mesh SSBO) can be observed without traversing the full record-stage\n * dispatch log. The PipelineState carries the mutable counter object\n * (`_skinBgCacheStats: { miss, hit }`); the record-stage cache miss / hit\n * branches bump it; this accessor returns the live reference.\n *\n * @internal -- exported for unit test access (m3-1)\n */\nexport function _skinBgCacheStats(pipelineState: {\n  readonly _skinBgCacheStats: { miss: number; hit: number };\n}): { miss: number; hit: number } {\n  return pipelineState._skinBgCacheStats;\n}\n","import type { RenderExtract } from '../extract/schema-readers';\n\nexport interface PreparedRenderSchemas {\n  readonly meshAssetHandle: unknown;\n  readonly lightDirection: unknown;\n  readonly cameraProjection: number;\n  readonly cameraNear: number;\n  readonly cameraFar: number;\n}\n\n/** Prepare the extracted fields for record without substituting provisional defaults. */\nexport function prepareRenderSchemas(frame: RenderExtract): PreparedRenderSchemas {\n  return {\n    meshAssetHandle: frame.mesh.assetHandle,\n    lightDirection: frame.light.direction,\n    cameraProjection: frame.camera.projection,\n    cameraNear: frame.camera.near,\n    cameraFar: frame.camera.far,\n  };\n}\n"]}

package/dist/lifecycle.d.ts

@@ -0,0 +1,28 @@
+import type { HealthChangeListener, HealthReason, HealthSnapshot, RendererError, RendererErrorListener, RendererLostInfo, RendererLostListener } from './renderer';
+export declare function deriveRecoverable(reason: HealthReason): boolean;
+export declare class LostListenerRegistry {
+    private readonly listeners;
+    private fired;
+    private lastInfo;
+    add(listener: RendererLostListener): () => void;
+    fire(info: RendererLostInfo): void;
+    clear(): void;
+}
+export declare class RhiErrorListenerRegistry {
+    private readonly listeners;
+    private fired;
+    private lastError;
+    add(listener: RendererErrorListener): () => void;
+    fire(error: RendererError): void;
+    clear(): void;
+}
+export declare class HealthListenerRegistry {
+    private readonly listeners;
+    private fired;
+    private lastSnapshot;
+    add(listener: HealthChangeListener): () => void;
+    fire(snapshot: HealthSnapshot): void;
+    clear(): void;
+    getLastSnapshot(): HealthSnapshot;
+}
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,YAAY,EACZ,cAAc,EACd,aAAa,EACb,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAS/D;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmC;IAC7D,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAiC;IAEjD,GAAG,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,IAAI;IAM/C,IAAI,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IAMlC,KAAK,IAAI,IAAI;CAGd;AAED,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+B;IACzD,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,SAAS,CAA8B;IAE/C,GAAG,CAAC,QAAQ,EAAE,qBAAqB,GAAG,MAAM,IAAI;IAehD,IAAI,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAgBhC,KAAK,IAAI,IAAI;CAGd;AAED,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmC;IAC7D,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,YAAY,CAA+B;IAEnD,GAAG,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,IAAI;IAY/C,IAAI,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAYpC,KAAK,IAAI,IAAI;IAIb,eAAe,IAAI,cAAc;CAKlC"}

package/dist/light-buffer-layout.d.ts

@@ -0,0 +1,164 @@
+import { type Result, RhiError } from '@forgeax/engine-rhi';
+import type { PointLightSnapshot, SpotLightSnapshot } from './render-system-extract';
+/** Byte size of one HDRP LightSlot in std430 (16 x f32). AC-11 absolute-value lock. */
+export declare const BYTES_PER_LIGHT_SLOT = 64;
+/**
+ * LightSlot kind discriminant — closed enum matching WGSL `KIND_POINT` / `KIND_SPOT`.
+ * Values are u32 bit-tags (not sequential); AC-12 exhaustive switch.
+ */
+export declare const LightSlotKind: {
+    readonly POINT: 0;
+    readonly SPOT: 1;
+};
+export type LightSlotKind = (typeof LightSlotKind)[keyof typeof LightSlotKind];
+/**
+ * Byte-offset layout of one LightSlot in std430 (16 f32 = 64 B).
+ *
+ * Mirrors the WGSL `LightSlot` struct field order byte-for-byte.
+ * All offsets verified by w14 lightslot-layout.test.ts.
+ *
+ * feat-20260612-point-light-shadows-urp-hdrp M4 / T-M4-4 (plan-strategy §D-8):
+ * the prior u32x3 pad lanes at byte 52..64 carry shadow-side data on the HDRP
+ * path. `kind_and_pad.x = kind` (u32), `.y = shadow identity` (i32, sentinel
+ * -1 = no shadow), `.z = near` (f32 via bitcast), `.w = far`
+ * (f32 via bitcast). The shader reads near/far through `bitcast<f32>(...)`
+ * to keep the WGSL struct as `vec4<u32>` (alignment + naga_oil unchanged).
+ */
+export declare const LIGHTSLOT_LAYOUT: {
+    readonly byteSize: 64;
+    readonly positionOffset: 0;
+    readonly invRangeSquaredOffset: 12;
+    readonly colorOffset: 16;
+    readonly cosInnerOffset: 28;
+    readonly directionOffset: 32;
+    readonly cosOuterOffset: 44;
+    readonly kindOffset: 48;
+    readonly shadowPayloadOffset: 52;
+    readonly shadowAtlasLayerOffset: 52;
+    readonly shadowAtlasTileOffset: 52;
+    readonly shadowNearOffset: 56;
+    readonly shadowFarOffset: 60;
+    readonly floatCount: 16;
+    readonly vec4Count: 4;
+};
+/**
+ * Minimum storage-buffer count needed by the M3 record stage.
+ *
+ *   1. Mesh SSBO (entity_world + normalMatrix; per-renderable dynamic
+ *      offset, 256 B stride).
+ *   2. PointLight std430 array (this feat).
+ *   3. SpotLight std430 array (this feat).
+ *
+ * Plan R-4 + plan-strategy section 4 risk table: assert >= 4 to keep the
+ * head-room margin for todo-125 (cluster expansion lifts to 4-5 entries).
+ */
+export declare const STORAGE_BUFFER_MIN_REQUIRED = 4;
+/** Byte size of one PointLight std430 slot (vec4 * 2). */
+export declare const POINT_LIGHT_STD430_BYTES = 32;
+/**
+ * Byte size of one SpotLight std430 slot (vec4 * 4).
+ *
+ * feat-20260625-spot-light-shadow-mapping M2 / w8 (D-4): grew 48 -> 64 to make
+ * room for the `shadowAtlasTile: i32` clip-signal lane (slot 15). Slots 0..11
+ * keep the prior layout; slots 12..14 are vec4-alignment padding.
+ */
+export declare const SPOT_LIGHT_STD430_BYTES = 64;
+/** Sentinel value for SpotLight slot[15] meaning "no shadow / clipped". */
+export declare const SPOT_LIGHT_SHADOW_TILE_SENTINEL = -1;
+/** Byte size of the array header (count u32 + 12 B pad to 16 B stride). */
+export declare const LIGHT_ARRAY_HEADER_BYTES = 16;
+/** Maximum number of slots packed in the first-slice cap layout (D-S3). */
+export declare const LIGHT_ARRAY_MAX_SLOTS = 4;
+/** Sentinel value for PointLight slot[7] / LightSlot pad meaning "no shadow". */
+export declare const POINT_LIGHT_SHADOW_LAYER_SENTINEL = -1;
+/**
+ * Pack one PointLightSnapshot into 8 floats / 32 B byte-for-byte std430.
+ *
+ * Returns a fresh `Float32Array` per call; `Float32Array.byteLength === 32`
+ * by construction (Float32Array(8).buffer.byteLength === 32). Slot 7
+ * (byte 28..32) carries `shadowAtlasLayer: i32` (sentinel -1 = no shadow,
+ * 0..3 = cube_array atlas layer index for shadow casters). The lane is
+ * written through an Int32Array view of the same backing ArrayBuffer so the
+ * shader's `i32` read at byte 28..32 of `struct PointLight` (common.wgsl)
+ * sees the correct two's-complement bits (-1 = 0xFFFFFFFF).
+ */
+export declare function packPointLight(snap: PointLightSnapshot): Float32Array;
+/**
+ * Pack one SpotLightSnapshot into 16 floats (64 B byte-for-byte std430).
+ *
+ * cosInner / cosOuter ride the otherwise-padding `.w` lanes of the
+ * `color` and `direction` vec4 columns (AC-04 c + plan D-S2 16 B alignment
+ * via packing rather than padding rows). Slot 15 carries `shadowAtlasTile: i32`
+ * (sentinel -1 = unassigned/clipped, 0..3 = atlas tile) written through an
+ * Int32Array view so the shader's `i32` read at byte 60..64 of struct SpotLight
+ * (common.wgsl) sees the correct two's-complement bits (-1 = 0xFFFFFFFF).
+ * Slots 12..14 stay zero (vec4-alignment padding). feat-20260625 M2 / w8 (D-4).
+ */
+export declare function packSpotLight(snap: SpotLightSnapshot): Float32Array;
+/**
+ * Pack the 16-byte std430 array header (count u32 + 12 B pad) for the
+ * point/spot light storage buffers.
+ *
+ * Returns a fresh `ArrayBuffer` so callers can either re-view it as
+ * `Uint8Array` for `queue.writeBuffer` or as `Uint32Array` for in-place
+ * inspection.
+ */
+export declare function packLightArrayHeader(count: number): ArrayBuffer;
+/**
+ * Cap gate at createRenderer time: check whether the device has enough
+ * storage-buffer slots for the PBR pipeline (M3 requires
+ * `STORAGE_BUFFER_MIN_REQUIRED = 4`). Returns a three-way signal:
+ *
+ *  - `Result.ok(true)`  — storage buffer capable (cap >= 4);
+ *  - `Result.ok(false)` — no storage buffer capability at all (cap === 0);
+ *    consumer walks the uniform-fallback path;
+ *  - `Result.err(RhiError)` — cap in (0, 4); not enough storage slots to run
+ *    but also not a clean zero-cap uniform-fallback case (e.g. downlevel
+ *    adapter with 1-3 slots). The error carries `'limit-exceeded'` with
+ *    `LimitExceededDetail` shape.
+ *
+ * Uniform-fallback path decision (plan D-5): `cap === 0` is the wgpu
+ * WebGL2 backend signal (`downlevel_webgl2_defaults().limits.
+ * maxStorageBuffersPerShaderStage = 0`). Uniform fallback covers pointLight
+ * + spotLight + meshes + instances + skin palette — every storage-buffer
+ * entry in the PBR pipeline switches to `uniform`.
+ */
+/**
+ * Optional shadow info attached to a HDRP LightSlot for point lights with a
+ * companion `PointLightShadow` component. Sentinel `layer = -1` (the default
+ * when the snapshot has no shadow) makes the shader skip cube_array sampling
+ * and stay on the unshadowed `evalPoint` path.
+ *
+ * `near` / `far` ride the otherwise-pad lanes (`kind_and_pad.zw` in the WGSL
+ * struct, byte 56..64) and feed the depth-ref reconstruction in
+ * `evalPointShadowed`. Spot lights (and shadow-less point lights) leave these
+ * lanes zero per std430 init.
+ */
+export interface PointShadowSlotInfo {
+    readonly shadowAtlasLayer: number;
+    readonly near: number;
+    readonly far: number;
+}
+/**
+ * Pack one PointLightSnapshot or SpotLightSnapshot into a 64-byte LightSlot
+ * (16 floats, std430). Point lights fill `cosInner=1.0`, `direction=vec3(0)`,
+ * `cosOuter=0.0`, `kind=POINT(0)`. Spot lights fill all fields verbatim;
+ * `direction` is already normalized by extract and this owner never repeats
+ * that operation.
+ *
+ * feat-20260612-point-light-shadows-urp-hdrp M4 / T-M4-4 (plan-strategy §D-8):
+ * the optional point `shadow` info threads through to bytes 52..64 as
+ * `(shadowAtlasLayer i32, near f32, far f32)`. Spot snapshots write their
+ * `shadowAtlasTile` directly into the same identity lane and keep near/far 0.
+ * The shader reads `near`/`far`
+ * through `bitcast<f32>(kind_and_pad.zw)` so the WGSL struct stays
+ * `kind_and_pad: vec4<u32>` (alignment + naga_oil compose unchanged). When
+ * `shadow` is undefined (no PointLightShadow) the lanes default to
+ * `(layer = -1, 0, 0)` -- shader gates on `layer >= 0` so unshadowed lights
+ * stay on the `evaluate_point_light` path. Spot lights write their tile or -1.
+ *
+ * Returns a fresh `Float32Array(16)` per call.
+ */
+export declare function packLightSlot(snap: PointLightSnapshot | SpotLightSnapshot, shadow?: PointShadowSlotInfo): Float32Array;
+export declare function assertStorageBufferCap(cap: number): Result<boolean, RhiError>;
+//# sourceMappingURL=light-buffer-layout.d.ts.map

package/dist/light-buffer-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"light-buffer-layout.d.ts","sourceRoot":"","sources":["../src/light-buffer-layout.ts"],"names":[],"mappings":"AAqDA,OAAO,EAAW,KAAK,MAAM,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAyBrF,uFAAuF;AACvF,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,aAAa;;;CAGhB,CAAC;AACX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAE/E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAgBnB,CAAC;AAEX;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C,0DAA0D;AAC1D,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C,2EAA2E;AAC3E,eAAO,MAAM,+BAA+B,KAAK,CAAC;AAClD,2EAA2E;AAC3E,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,iFAAiF;AACjF,eAAO,MAAM,iCAAiC,KAAK,CAAC;AAEpD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,YAAY,CAarE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,YAAY,CAmBnE;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAM/D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH;;;;;;;;;;GAUG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,kBAAkB,GAAG,iBAAiB,EAC5C,MAAM,CAAC,EAAE,mBAAmB,GAC3B,YAAY,CAmCd;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,CAkB7E"}

package/dist/materials.d.ts

@@ -0,0 +1,50 @@
+import type { MaterialAsset, MaterialColorSpace, MaterialRenderState, MaterialValue } from '@forgeax/engine-types';
+export declare const SPRITE_PREMULTIPLIED_ALPHA_BLEND: GPUBlendState;
+declare const SPRITE_MODULE = "forgeax_material::sprite";
+export declare function materialTextureValue(value: MaterialValue): MaterialValue;
+export declare function materialTextureValue(value: string): MaterialValue;
+export declare function materialTextureValue(value: undefined): undefined;
+interface UnlitOpts {
+    /** Asset-side authored color space. Defaults to sRGB. */
+    readonly colorSpace?: MaterialColorSpace;
+    readonly castShadow?: boolean;
+    readonly baseColorTexture?: MaterialValue;
+    readonly alphaCutoff?: number;
+    readonly renderState?: MaterialRenderState;
+    readonly queue?: number;
+}
+declare function unlit(rgba: readonly [number, number, number, number], opts?: UnlitOpts): MaterialAsset;
+interface StandardOpts {
+    /** Asset-side authored color space for baseColor/emissive/specularTint. Defaults to sRGB. */
+    readonly colorSpace?: MaterialColorSpace;
+    readonly baseColor: readonly [number, number, number, number];
+    readonly metallic?: number;
+    readonly roughness?: number;
+    /** Texture channel used for the metallic factor; glTF defaults to B (2). */
+    readonly metallicChannel?: number;
+    /** Texture channel used for the roughness factor; glTF defaults to G (1). */
+    readonly roughnessChannel?: number;
+    readonly clearcoat?: number;
+    readonly clearcoatRoughness?: number;
+    readonly specularTint?: readonly [number, number, number];
+    readonly specularTintTexture?: MaterialValue;
+    readonly emissive?: readonly [number, number, number];
+    readonly emissiveIntensity?: number;
+    readonly emissiveTexture?: MaterialValue;
+    readonly baseColorTexture?: MaterialValue;
+    readonly metallicRoughnessTexture?: MaterialValue;
+    readonly normalTexture?: MaterialValue;
+    readonly occlusionTexture?: MaterialValue;
+    readonly occlusionStrength?: number;
+    readonly alphaCutoff?: number;
+    readonly renderState?: MaterialRenderState;
+    readonly castShadow?: boolean;
+    readonly queue?: number;
+}
+declare function standard(opts: StandardOpts): MaterialAsset;
+export declare const Materials: {
+    readonly unlit: typeof unlit;
+    readonly standard: typeof standard;
+};
+export { SPRITE_MODULE };
+//# sourceMappingURL=materials.d.ts.map

package/dist/materials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materials.d.ts","sourceRoot":"","sources":["../src/materials.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,kBAAkB,EAGlB,mBAAmB,EAEnB,aAAa,EACd,MAAM,uBAAuB,CAAC;AAE/B,eAAO,MAAM,gCAAgC,EAAE,aAG9C,CAAC;AAIF,QAAA,MAAM,aAAa,6BAA6B,CAAC;AAEjD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,aAAa,CAAC;AAC1E,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAAC;AACnE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,CAAC;AAqFlE,UAAU,SAAS;IACjB,yDAAyD;IACzD,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,aAAa,CAAC;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,iBAAS,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,aAAa,CAsB/F;AAED,UAAU,YAAY;IACpB,6FAA6F;IAC7F,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,4EAA4E;IAC5E,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,6EAA6E;IAC7E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1D,QAAQ,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,eAAe,CAAC,EAAE,aAAa,CAAC;IACzC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,aAAa,CAAC;IAC1C,QAAQ,CAAC,wBAAwB,CAAC,EAAE,aAAa,CAAC;IAClD,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;IACvC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,aAAa,CAAC;IAC1C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAWD,iBAAS,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,aAAa,CAsDnD;AAED,eAAO,MAAM,SAAS;;;CAA+B,CAAC;AAEtD,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/mesh-material-bindings.d.ts

@@ -0,0 +1,44 @@
+import type { AssetErrorDetail, AssetGuid, MeshAsset } from '@forgeax/engine-types';
+export type MeshMaterialBindingSource = 'renderer-override' | 'mesh-default' | 'engine-default';
+export interface MeshMaterialBindingDiagnostic {
+    readonly code: 'mesh-renderer-material-override-invalid' | 'mesh-renderer-material-override-overflow';
+    readonly slotIndex: number;
+    readonly handle?: number;
+    /** Structured detail mirrors the renderer error for the active frame. */
+    readonly detail?: Readonly<AssetErrorDetail>;
+}
+export interface ResolvedMeshMaterialBinding {
+    readonly handle: number;
+    readonly source: MeshMaterialBindingSource;
+}
+/** Public read-only observation of the bindings used by the last frame. */
+export interface MeshMaterialBindingObservation {
+    /** Renderer-local identity for one attached World generation; never a draw-array index. */
+    readonly worldId: number;
+    readonly entityKey: number;
+    readonly bindings: readonly ResolvedMeshMaterialBinding[];
+    readonly diagnostics: readonly MeshMaterialBindingDiagnostic[];
+}
+export type ResolveMeshMaterialBindingsResult = {
+    readonly ok: true;
+    readonly bindings: readonly ResolvedMeshMaterialBinding[];
+    readonly diagnostics: readonly MeshMaterialBindingDiagnostic[];
+} | {
+    readonly ok: false;
+    readonly code: 'mesh-material-slots-missing';
+} | {
+    readonly ok: false;
+    readonly code: 'mesh-default-material-not-ready';
+    readonly slotIndex: number;
+    readonly defaultMaterial: AssetGuid;
+};
+/**
+ * Single owner of the instance override -> mesh default -> engine default
+ * inheritance rule. It resolves once per logical slot; submeshes only project
+ * their materialSlot index onto the returned table.
+ */
+export declare function resolveMeshMaterialBindings(mesh: MeshAsset, rendererOverrides: ArrayLike<number>, deps: {
+    readonly isValidOverride: (handle: number) => boolean;
+    readonly resolveMeshDefault: (guid: AssetGuid) => number | undefined;
+}): ResolveMeshMaterialBindingsResult;
+//# sourceMappingURL=mesh-material-bindings.d.ts.map

package/dist/mesh-material-bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-material-bindings.d.ts","sourceRoot":"","sources":["../src/mesh-material-bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEpF,MAAM,MAAM,yBAAyB,GAAG,mBAAmB,GAAG,cAAc,GAAG,gBAAgB,CAAC;AAEhG,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,IAAI,EACT,yCAAyC,GACzC,0CAA0C,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;CAC5C;AAED,2EAA2E;AAC3E,MAAM,WAAW,8BAA8B;IAC7C,2FAA2F;IAC3F,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,SAAS,2BAA2B,EAAE,CAAC;IAC1D,QAAQ,CAAC,WAAW,EAAE,SAAS,6BAA6B,EAAE,CAAC;CAChE;AAED,MAAM,MAAM,iCAAiC,GACzC;IACE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,QAAQ,EAAE,SAAS,2BAA2B,EAAE,CAAC;IAC1D,QAAQ,CAAC,WAAW,EAAE,SAAS,6BAA6B,EAAE,CAAC;CAChE,GACD;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,IAAI,EAAE,6BAA6B,CAAC;CAC9C,GACD;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,IAAI,EAAE,iCAAiC,CAAC;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,eAAe,EAAE,SAAS,CAAC;CACrC,CAAC;AAEN;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,SAAS,EACf,iBAAiB,EAAE,SAAS,CAAC,MAAM,CAAC,EACpC,IAAI,EAAE;IACJ,QAAQ,CAAC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IACtD,QAAQ,CAAC,kBAAkB,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,MAAM,GAAG,SAAS,CAAC;CACtE,GACA,iCAAiC,CA8CnC"}

package/dist/mesh-update-errors.d.ts

@@ -0,0 +1,71 @@
+/** Structured failures for typed resident-mesh updates. */
+export type MeshUpdateErrorCode = keyof typeof MESH_UPDATE_POLICY;
+export interface MeshNotResidentDetail {
+    readonly handle: number;
+}
+export interface MeshShapeMismatchDetail {
+    readonly handle: number;
+    readonly expected: string;
+    readonly actual: string;
+}
+export type MeshRangeInvalidReason = 'non-integer' | 'negative' | 'empty' | 'out-of-bounds' | 'stride-mismatch';
+interface MeshRangeInvalidLocationDetail {
+    readonly handle: number;
+    readonly firstVertex: number;
+    readonly vertexCount: number;
+    readonly residentVertexCount: number;
+    readonly reason: Exclude<MeshRangeInvalidReason, 'stride-mismatch'>;
+}
+interface MeshRangeInvalidStrideDetail {
+    readonly handle: number;
+    readonly firstVertex: number;
+    readonly vertexCount: number;
+    readonly residentVertexCount: number;
+    readonly reason: 'stride-mismatch';
+    readonly expectedByteLength: number;
+    readonly actualByteLength: number;
+}
+export type MeshRangeInvalidDetail = MeshRangeInvalidLocationDetail | MeshRangeInvalidStrideDetail;
+export type MeshUpdateErrorDetailFor<C extends MeshUpdateErrorCode> = C extends 'mesh-not-resident' ? MeshNotResidentDetail : C extends 'mesh-shape-mismatch' ? MeshShapeMismatchDetail : C extends 'mesh-range-invalid' ? MeshRangeInvalidDetail : never;
+type MeshUpdateErrorDetail = MeshUpdateErrorDetailFor<MeshUpdateErrorCode>;
+declare const MESH_UPDATE_POLICY: {
+    'mesh-not-resident': {
+        expected: string;
+        hint: (detail: MeshNotResidentDetail) => string;
+    };
+    'mesh-shape-mismatch': {
+        expected: string;
+        hint: (detail: MeshShapeMismatchDetail) => string;
+    };
+    'mesh-range-invalid': {
+        expected: string;
+        hint: (detail: MeshRangeInvalidDetail) => string;
+    };
+};
+declare class MeshUpdateErrorClass extends Error {
+    readonly code: MeshUpdateErrorCode;
+    readonly expected: string;
+    readonly hint: string;
+    readonly detail: MeshUpdateErrorDetail;
+    constructor(args: {
+        code: MeshUpdateErrorCode;
+        detail: MeshUpdateErrorDetail;
+    });
+}
+type MeshUpdateErrorVariant<C extends MeshUpdateErrorCode> = MeshUpdateErrorClass & {
+    readonly code: C;
+    readonly detail: MeshUpdateErrorDetailFor<C>;
+};
+export type MeshUpdateError = {
+    [C in MeshUpdateErrorCode]: MeshUpdateErrorVariant<C>;
+}[MeshUpdateErrorCode];
+interface MeshUpdateErrorConstructor {
+    new <C extends MeshUpdateErrorCode>(args: {
+        code: C;
+        detail: MeshUpdateErrorDetailFor<C>;
+    }): MeshUpdateErrorVariant<C>;
+    readonly prototype: MeshUpdateErrorClass;
+}
+export declare const MeshUpdateError: MeshUpdateErrorConstructor;
+export {};
+//# sourceMappingURL=mesh-update-errors.d.ts.map

package/dist/mesh-update-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-update-errors.d.ts","sourceRoot":"","sources":["../src/mesh-update-errors.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAE3D,MAAM,MAAM,mBAAmB,GAAG,MAAM,OAAO,kBAAkB,CAAC;AAElE,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,sBAAsB,GAC9B,aAAa,GACb,UAAU,GACV,OAAO,GACP,eAAe,GACf,iBAAiB,CAAC;AAEtB,UAAU,8BAA8B;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,sBAAsB,EAAE,iBAAiB,CAAC,CAAC;CACrE;AAED,UAAU,4BAA4B;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,MAAM,sBAAsB,GAAG,8BAA8B,GAAG,4BAA4B,CAAC;AAEnG,MAAM,MAAM,wBAAwB,CAAC,CAAC,SAAS,mBAAmB,IAAI,CAAC,SAAS,mBAAmB,GAC/F,qBAAqB,GACrB,CAAC,SAAS,qBAAqB,GAC7B,uBAAuB,GACvB,CAAC,SAAS,oBAAoB,GAC5B,sBAAsB,GACtB,KAAK,CAAC;AAEd,KAAK,qBAAqB,GAAG,wBAAwB,CAAC,mBAAmB,CAAC,CAAC;AAE3E,QAAA,MAAM,kBAAkB;;;uBAGL,qBAAqB;;;;uBAKrB,uBAAuB;;;;uBAKvB,sBAAsB;;CAO0D,CAAC;AAEpG,cAAM,oBAAqB,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;gBAE3B,IAAI,EAAE;QAAE,IAAI,EAAE,mBAAmB,CAAC;QAAC,MAAM,EAAE,qBAAqB,CAAA;KAAE;CAa/E;AAED,KAAK,sBAAsB,CAAC,CAAC,SAAS,mBAAmB,IAAI,oBAAoB,GAAG;IAClF,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC,CAAC,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;KAC3B,CAAC,IAAI,mBAAmB,GAAG,sBAAsB,CAAC,CAAC,CAAC;CACtD,CAAC,mBAAmB,CAAC,CAAC;AAEvB,UAAU,0BAA0B;IAClC,KAAK,CAAC,SAAS,mBAAmB,EAAE,IAAI,EAAE;QACxC,IAAI,EAAE,CAAC,CAAC;QACR,MAAM,EAAE,wBAAwB,CAAC,CAAC,CAAC,CAAC;KACrC,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;CAC1C;AAED,eAAO,MAAM,eAAe,EAAE,0BACiC,CAAC"}