@forgeax/engine-render 0.1.2

package/dist/gpu-driven/batch-topology.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-topology.d.ts","sourceRoot":"","sources":["../../src/gpu-driven/batch-topology.ts"],"names":[],"mappings":"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"}

package/dist/gpu-driven/production-raster.d.ts

@@ -0,0 +1,150 @@
+import type { RenderGraphBuilder, RenderGraphError } from '@forgeax/engine-render-graph';
+import type { BindGroupLayout, Result, RhiDevice } from '@forgeax/engine-rhi';
+import { RhiError } from '@forgeax/engine-rhi';
+import type { PersistentGpuDrivenState } from '../persistent-render-scene';
+import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
+import { type RasterItemKey } from '../record';
+import type { RenderPipelineFrame, RenderPipelineGpuDrivenProjection } from '../render-pipeline';
+import type { MeshGpuHandles } from '../render-system';
+import { type CameraSnapshot, type ExtractedFrame, type RenderableSnapshot } from '../render-system-extract';
+import { type GpuDrivenBatch, type SubmissionPlan } from './batch-topology';
+import { type CpuMultiViewVisibilityResult } from './view-gpu';
+export declare const GPU_DRIVEN_RIGID_UNLIT_WGSL: string;
+/**
+ * Depth-only shadow raster companion for the shared GPU Scene visibility
+ * buffers. It deliberately has no material-dependent fragment stage: alpha
+ * test and custom ShadowCaster variants stay on the CPU contract until their
+ * own batch shader is available. Opaque casters use the same primitive,
+ * instance, transform and compact-visible tables as the main view.
+ */
+export declare const GPU_DRIVEN_SHADOW_WGSL: string;
+export type GpuDrivenRasterEligibilityReason = 'missing-local-bounds-capability-lane' | 'skinned-capability-lane' | 'sprite-capability-lane' | 'not-geometry-queue' | 'unsafe-ordering' | 'pbr-capability-lane' | 'alpha-test-capability-lane' | 'resource-bindings-capability-lane' | 'transparent';
+export interface GpuDrivenRasterEligibility {
+    readonly eligible: boolean;
+    readonly reason: GpuDrivenRasterEligibilityReason | undefined;
+}
+/**
+ * The current shader remains a deliberately narrow capability lane. Semantic
+ * batch keys still retain PBR/alpha/resource/double-sided identity so those
+ * objects can share the CPU/shadow contract without being misreported as
+ * rigid-unlit GPU-owned raster work.
+ */
+export declare function gpuDrivenRasterEligibility(snapshot: RenderableSnapshot, batch: GpuDrivenBatch): GpuDrivenRasterEligibility;
+export interface GpuDrivenProductionInspection {
+    readonly gpuOwnedSnapshotsMaterialized: number;
+    readonly filteredPlanBuilds: number;
+    readonly gpuOwnedItemCount: number;
+    readonly candidateUploadBytes: number;
+    readonly batchUploadBytes: number;
+    readonly viewConstantsUploadBytes: number;
+    readonly batchBindGroupCreates: number;
+    readonly viewBindGroupCreates: number;
+    readonly topologyRevision: number | undefined;
+    readonly validatedGpuOwnedRows: number;
+    readonly cpuFallbackDrawItems: number;
+    readonly cpuVisibility: CpuMultiViewVisibilityResult | undefined;
+    readonly shadowBatchCount: number;
+    readonly shadowCandidateCount: number;
+    readonly shadowDrawCount: number;
+    readonly faults: readonly GpuDrivenVisibilityFault[];
+}
+export type GpuDrivenVisibilityFaultCode = 'visibility-overflow' | 'gpu-capability-unavailable' | 'gpu-scene-fact-unavailable' | 'device-recovery-required' | 'gpu-resource-failed';
+export interface GpuDrivenVisibilityFault {
+    readonly code: GpuDrivenVisibilityFaultCode;
+    readonly viewId: string;
+    readonly revision: number;
+    readonly fallback: 'cpu-batch-contract' | 'scene-rebuild';
+    readonly detail: string;
+}
+export interface PreparedGpuDrivenFrame {
+    readonly topologySignature: string;
+    readonly ownedItemKeys: ReadonlySet<RasterItemKey>;
+    readonly ownsAllForwardItems: boolean;
+    /** Batch-aligned ShadowCaster candidates from the same topology revision. */
+    readonly shadowSubmission: SubmissionPlan;
+    project(graph: RenderGraphBuilder<RenderPipelineFrame>, format: string, sampleCount: 1 | 4): Result<RenderPipelineGpuDrivenProjection, RenderGraphError | RhiError>;
+}
+/**
+ * Per-view production submission. The batch-aligned plan owns candidate
+ * membership; candidateIndexByStableId is a one-way adapter for the existing
+ * direct RHI draw encoder and must not be used to generate another view list.
+ */
+export interface MultiViewProductionSubmission {
+    readonly source: 'multi-view-indirect';
+    readonly viewId: string;
+    readonly kind: 'main' | 'cascade';
+    readonly cascadeIndex: number | undefined;
+    readonly volumeRevision: number | undefined;
+    readonly spatialIndexRevision: number | undefined;
+    readonly overflow: boolean;
+    readonly plan: SubmissionPlan;
+    readonly candidateIndexByStableId: ReadonlyMap<number, number>;
+    /** Immutable candidate membership adapter shared by CPU shadow fallback and observation. */
+    readonly candidateIndices: ReadonlySet<number>;
+    readonly faults: readonly GpuDrivenVisibilityFault[];
+}
+export declare class GpuDrivenProduction {
+    private readonly device;
+    private readonly shaderModuleFactory;
+    private view;
+    private raster;
+    private shadowRaster;
+    private readonly shadowViews;
+    private preparedShadowViews;
+    private readonly sceneIdentities;
+    private nextSceneIdentity;
+    private filteredCache;
+    private gpuOwnedSnapshotsMaterialized;
+    private filteredPlanBuilds;
+    private gpuOwnedItemCount;
+    private batchBindGroupCreates;
+    private validatedGpuOwnedRows;
+    private cpuFallbackDrawItems;
+    private cpuVisibility;
+    /** Candidate-domain ShadowCaster membership projected onto persistent slots. */
+    private shadowCasterSlotIndices;
+    private visibilityViews;
+    private shadowSubmission;
+    private readonly shadowPlanCache;
+    /**
+     * Reverse index for the immutable shadow topology. Cascade views provide
+     * stable slot ids, so rebuilding a view plan should walk the selected view
+     * domain instead of filtering every source candidate for every cascade.
+     */
+    private shadowCandidateMembership;
+    private faults;
+    private signatureCache;
+    constructor(device: RhiDevice, shaderModuleFactory: PipelineBuilderShaderModuleFactory);
+    prepareCpuVisibility(input: {
+        readonly scene: PersistentGpuDrivenState | undefined;
+        readonly frame: ExtractedFrame;
+        readonly camera: CameraSnapshot | undefined;
+    }): CpuMultiViewVisibilityResult | undefined;
+    prepare(input: {
+        readonly scene: PersistentGpuDrivenState | undefined;
+        readonly camera: CameraSnapshot;
+        readonly meshes: ReadonlyMap<number, MeshGpuHandles>;
+        readonly viewBindGroupLayout: BindGroupLayout;
+        readonly materialBindGroupLayout?: BindGroupLayout;
+        readonly meshResidencyEpoch: number;
+        readonly hdrp: boolean;
+    }): Result<PreparedGpuDrivenFrame | undefined, RhiError>;
+    /**
+     * Intersect the four-view visibility result with the shared ShadowCaster
+     * topology. This is the only production candidate-to-submission join; CPU
+     * fallback devices consume the same immutable plans as indirect-capable
+     * devices.
+     */
+    multiViewSubmissions(): readonly MultiViewProductionSubmission[];
+    private prepareShadowViews;
+    private shadowSubmissionForView;
+    dispose(): void;
+    inspect(): GpuDrivenProductionInspection;
+    recordCpuValidation(validated: readonly {
+        readonly source: RenderableSnapshot;
+    }[], gpuOwned: ReadonlySet<RasterItemKey>): void;
+    private sceneIdentity;
+    private addFault;
+    private addRhiFault;
+}
+//# sourceMappingURL=production-raster.d.ts.map

package/dist/gpu-driven/production-raster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"production-raster.d.ts","sourceRoot":"","sources":["../../src/gpu-driven/production-raster.ts"],"names":[],"mappings":"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"}

package/dist/gpu-driven/view-gpu.d.ts

@@ -0,0 +1,141 @@
+import type { GraphBuffer, RenderGraphBuilder, RenderGraphFrame } from '@forgeax/engine-render-graph';
+import { RenderGraphError } from '@forgeax/engine-render-graph';
+import type { Buffer, Result, RhiDevice } from '@forgeax/engine-rhi';
+import { RhiError } from '@forgeax/engine-rhi';
+import type { GpuScene } from '../gpu-scene';
+import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
+import type { RenderVisibilityViewDescriptor, RenderVisibilityViewKind } from '../render-system-extract';
+import type { SubmissionPlan } from './batch-topology';
+export declare const GPU_DRIVEN_VIEW_WGSL = "\nstruct PrimitiveRecord {\n  generation: u32,\n  flags: u32,\n  transformIndex: u32,\n  materialIndex: u32,\n  drawTemplateIndex: u32,\n  instanceStart: u32,\n  instanceCount: u32,\n  assetHandle: u32,\n  localBoundsMin: vec4<f32>,\n  localBoundsMax: vec4<f32>,\n};\n\nstruct TransformRecord {\n  currentWorld: mat4x4<f32>,\n  previousWorld: mat4x4<f32>,\n};\n\nstruct CandidateRecord {\n  primitiveIndex: u32,\n  generation: u32,\n  instanceOrdinal: u32,\n  materialSlot: u32,\n  batchIndex: u32,\n  visibleBase: u32,\n  visibleCapacity: u32,\n};\n\nstruct InstanceRecord {\n  primitiveIndex: u32,\n  transformIndex: u32,\n  customDataStart: u32,\n  flags: u32,\n};\n\nstruct BatchRecord {\n  visibleBase: u32,\n  visibleCapacity: u32,\n  count: u32,\n  first: u32,\n  baseVertex: i32,\n  indirectIndex: u32,\n  indexed: u32,\n};\n\nstruct ViewConstants {\n  planes: array<vec4<f32>, 6>,\n  candidateCount: u32,\n  batchCount: u32,\n  pad0: u32,\n  pad1: u32,\n};\n\n@group(0) @binding(0) var<storage, read> primitives: array<PrimitiveRecord>;\n@group(0) @binding(1) var<storage, read> instances: array<InstanceRecord>;\n@group(0) @binding(2) var<storage, read> transforms: array<TransformRecord>;\n@group(0) @binding(3) var<storage, read> candidates: array<CandidateRecord>;\n@group(0) @binding(4) var<storage, read> batches: array<BatchRecord>;\n@group(0) @binding(5) var<uniform> view: ViewConstants;\n@group(0) @binding(6) var<storage, read_write> counters: array<atomic<u32>>;\n@group(0) @binding(7) var<storage, read_write> visibleIndices: array<vec2<u32>>;\n@group(0) @binding(8) var<storage, read_write> indirectArgs: array<u32>;\n\nfn counterIndex(batchIndex: u32) -> u32 { return batchIndex * 2u; }\nfn overflowIndex(batchIndex: u32) -> u32 { return batchIndex * 2u + 1u; }\n\nfn isVisible(primitive: PrimitiveRecord, world: mat4x4<f32>) -> bool {\n  if ((primitive.flags & 7u) != 7u) { return false; }\n  let localCenter = (primitive.localBoundsMin.xyz + primitive.localBoundsMax.xyz) * 0.5;\n  let localExtent = (primitive.localBoundsMax.xyz - primitive.localBoundsMin.xyz) * 0.5;\n  let worldCenter = (world * vec4<f32>(localCenter, 1.0)).xyz;\n  let worldExtent =\n    abs(world[0].xyz) * localExtent.x +\n    abs(world[1].xyz) * localExtent.y +\n    abs(world[2].xyz) * localExtent.z;\n  for (var planeIndex = 0u; planeIndex < 6u; planeIndex += 1u) {\n    let plane = view.planes[planeIndex];\n    let radius = dot(abs(plane.xyz), worldExtent);\n    if (dot(plane.xyz, worldCenter) + plane.w < -radius) { return false; }\n  }\n  return true;\n}\n\n@compute @workgroup_size(64)\nfn resetView(@builtin(global_invocation_id) id: vec3<u32>) {\n  let batchIndex = id.x;\n  if (batchIndex >= view.batchCount) { return; }\n  atomicStore(&counters[counterIndex(batchIndex)], 0u);\n  atomicStore(&counters[overflowIndex(batchIndex)], 0u);\n}\n\n@compute @workgroup_size(64)\nfn cullView(@builtin(global_invocation_id) id: vec3<u32>) {\n  let candidateIndex = id.x;\n  if (candidateIndex >= view.candidateCount) { return; }\n  let candidate = candidates[candidateIndex];\n  let primitive = primitives[candidate.primitiveIndex];\n  if (primitive.generation != candidate.generation) { return; }\n  if (candidate.instanceOrdinal >= primitive.instanceCount) { return; }\n  let instanceIndex = primitive.instanceStart + candidate.instanceOrdinal;\n  let instance = instances[instanceIndex];\n  let world = transforms[primitive.transformIndex].currentWorld * transforms[instance.transformIndex].currentWorld;\n  if (!isVisible(primitive, world)) { return; }\n  let localVisible = atomicAdd(&counters[counterIndex(candidate.batchIndex)], 1u);\n  if (localVisible >= candidate.visibleCapacity) {\n    atomicStore(&counters[overflowIndex(candidate.batchIndex)], 1u);\n    return;\n  }\n  visibleIndices[candidate.visibleBase + localVisible] = vec2<u32>(\n    instanceIndex,\n    primitive.materialIndex + candidate.materialSlot,\n  );\n}\n\n@compute @workgroup_size(64)\nfn finalizeView(@builtin(global_invocation_id) id: vec3<u32>) {\n  let batchIndex = id.x;\n  if (batchIndex >= view.batchCount) { return; }\n  let batch = batches[batchIndex];\n  let visibleCount = min(\n    atomicLoad(&counters[counterIndex(batchIndex)]),\n    batch.visibleCapacity,\n  );\n  let args = batch.indirectIndex * 5u;\n  indirectArgs[args] = batch.count;\n  indirectArgs[args + 1u] = visibleCount;\n  indirectArgs[args + 2u] = batch.first;\n  indirectArgs[args + 3u] = select(0u, bitcast<u32>(batch.baseVertex), batch.indexed != 0u);\n  indirectArgs[args + 4u] = 0u;\n}\n";
+export interface GpuDrivenViewGraphResources {
+    readonly primitive: GraphBuffer;
+    readonly instance: GraphBuffer;
+    readonly transform: GraphBuffer;
+    readonly material: GraphBuffer;
+    readonly visible: GraphBuffer;
+    readonly indirect: GraphBuffer;
+    readonly overflow: GraphBuffer;
+}
+export interface GpuDrivenViewInspection {
+    readonly topologyRevision: number | undefined;
+    readonly candidateCount: number;
+    readonly batchCount: number;
+    readonly visibleCapacity: number;
+    readonly candidateCapacity: number;
+    readonly batchCapacity: number;
+    readonly indirectCapacity: number;
+    readonly updateCount: number;
+    readonly uploadBytes: number;
+    readonly candidateUploadBytes: number;
+    readonly batchUploadBytes: number;
+    readonly viewConstantsUploadBytes: number;
+    readonly bindGroupCreates: number;
+    readonly bufferRebuilds: number;
+    readonly resourceGeneration: number;
+}
+export interface CpuVisibilityCandidate {
+    /** Stable projection slot; generation disambiguates slot reuse. */
+    readonly stableId: number;
+    readonly generation: number;
+    /** Candidate-domain index consumed by CascadeVolumeSet membership. */
+    readonly candidateIndex: number | undefined;
+    readonly worldAabb: Float32Array | undefined;
+    readonly casterEligible: boolean;
+    readonly batchId: number | undefined;
+    readonly instanceOrdinal: number | undefined;
+}
+export interface CpuVisibleItem {
+    readonly stableId: number;
+    readonly generation: number;
+    readonly candidateIndex: number | undefined;
+    readonly batchId: number | undefined;
+    readonly instanceOrdinal: number | undefined;
+}
+export interface CpuVisibilityBatchSpan {
+    readonly batchId: number;
+    readonly first: number;
+    readonly count: number;
+    readonly capacity: number;
+    readonly overflow: boolean;
+}
+export interface CpuVisibilityViewResult {
+    readonly viewId: string;
+    readonly kind: RenderVisibilityViewKind;
+    readonly cascadeIndex: number | undefined;
+    readonly stableIds: readonly number[];
+    readonly generations: readonly number[];
+    readonly compactVisible: readonly CpuVisibleItem[];
+    readonly batchSpans: readonly CpuVisibilityBatchSpan[];
+    readonly capacity: number;
+    readonly overflow: boolean;
+    readonly volumeRevision: number | undefined;
+    readonly spatialIndexRevision: number | undefined;
+}
+export interface CpuVisibilityCascadeMaskEntry {
+    readonly stableId: number;
+    readonly generation: number;
+    /** Bit 0..2 corresponds to cascade 0..2. */
+    readonly cascadeMask: number;
+}
+export interface CpuMultiViewVisibilityResult {
+    readonly views: readonly CpuVisibilityViewResult[];
+    readonly cascadeMasks: readonly CpuVisibilityCascadeMaskEntry[];
+    readonly spatialIndexRevision: number | undefined;
+}
+/**
+ * CPU production executor for the shared main/CSM visibility contract.
+ *
+ * The executor consumes stable Scene Fact candidates and memberships already
+ * selected by CascadeVolumeSet. It deliberately keeps the main list separate
+ * from the caster domain, so a main-view cull cannot remove a shadow caster.
+ */
+export declare function executeCpuMultiViewVisibility(input: {
+    readonly views: readonly RenderVisibilityViewDescriptor[];
+    readonly candidates: readonly CpuVisibilityCandidate[];
+    /** Broadphase-selected domains keyed by view. */
+    readonly candidatesByView?: ReadonlyMap<string, readonly CpuVisibilityCandidate[]>;
+    readonly capacityByView?: ReadonlyMap<string, number>;
+    readonly capacityByBatch?: ReadonlyMap<number, number>;
+}): CpuMultiViewVisibilityResult;
+export declare class GpuDrivenView {
+    private readonly device;
+    private readonly bindGroupLayout;
+    private readonly pipelineLayout;
+    private readonly resetPipeline;
+    private readonly cullPipeline;
+    private readonly finalizePipeline;
+    private buffers;
+    private bindGroup;
+    private candidateCapacity;
+    private batchCapacity;
+    private indirectCapacity;
+    private plan;
+    private scenePrimitive;
+    private sceneInstance;
+    private sceneTransform;
+    private sceneMaterial;
+    private sceneCapacity;
+    private updateCount;
+    private uploadBytes;
+    private candidateUploadBytes;
+    private batchUploadBytes;
+    private viewConstantsUploadBytes;
+    private bindGroupCreates;
+    private bufferRebuilds;
+    private resourceGeneration;
+    private constructor();
+    static create(input: {
+        readonly device: RhiDevice;
+        readonly shaderModuleFactory: PipelineBuilderShaderModuleFactory;
+    }): Result<GpuDrivenView, RhiError>;
+    update(plan: SubmissionPlan, scene: GpuScene, planes: Float32Array): Result<void, RhiError>;
+    inspect(): GpuDrivenViewInspection;
+    get visibleBuffer(): Buffer | undefined;
+    get indirectBuffer(): Buffer | undefined;
+    get overflowBuffer(): Buffer | undefined;
+    get overflowByteOffset(): number;
+    addPasses<FrameCtx extends RenderGraphFrame>(builder: RenderGraphBuilder<FrameCtx>, labelPrefix?: string): Result<GpuDrivenViewGraphResources, RenderGraphError>;
+    dispose(): void;
+    private rebuildBuffers;
+}
+//# sourceMappingURL=view-gpu.d.ts.map

package/dist/gpu-driven/view-gpu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-gpu.d.ts","sourceRoot":"","sources":["../../src/gpu-driven/view-gpu.ts"],"names":[],"mappings":"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"}

package/dist/gpu-driven/view-reference.d.ts

@@ -0,0 +1,15 @@
+import type { RenderSceneProjectionSlot } from '../render-scene-projection';
+import type { SubmissionPlan } from './batch-topology';
+export declare const INDEXED_INDIRECT_STRIDE = 20;
+export interface GpuDrivenViewReferenceResult {
+    readonly visibleInstanceIndices: Uint32Array;
+    readonly batchCounters: Uint32Array;
+    readonly indirectArgs: ArrayBuffer;
+    readonly candidateCount: number;
+    readonly rejectedCount: number;
+    readonly visibleCount: number;
+    readonly overflowedBatches: readonly number[];
+}
+/** CPU oracle for the storage-buffer compute protocol and WebGL2 fallback semantics. */
+export declare function classifyGpuDrivenView(plan: SubmissionPlan, slots: readonly RenderSceneProjectionSlot[], planes: Float32Array, capacityByBatch?: ReadonlyMap<number, number>): GpuDrivenViewReferenceResult;
+//# sourceMappingURL=view-reference.d.ts.map

package/dist/gpu-driven/view-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-reference.d.ts","sourceRoot":"","sources":["../../src/gpu-driven/view-reference.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,sBAAsB,EAAE,WAAW,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC;IACpC,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC;IACnC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/C;AAED,wFAAwF;AACxF,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,yBAAyB,EAAE,EAC3C,MAAM,EAAE,YAAY,EACpB,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5C,4BAA4B,CAuF9B"}

package/dist/gpu-resource-store.d.ts

@@ -0,0 +1,294 @@
+import type { World } from '@forgeax/engine-ecs';
+import type { VertexLayoutProjection } from '@forgeax/engine-geometry';
+import { type Result, type RhiCaps, RhiError, type Sampler, type TextureView } from '@forgeax/engine-rhi';
+import { type AssetError, type DecodedImage, type EquirectAsset, type Handle, type ImageError, type PrimitiveTopology, type SamplerAsset, type Submesh, type TextureAsset, type MeshAsset as TypesMeshAsset } from '@forgeax/engine-types';
+import { GpuBuffer, GpuTexture } from './gpu-resource';
+import type { RhiErrorListenerRegistry } from './lifecycle';
+import { type MeshUpdateError as MeshUpdateErrorType } from './mesh-update-errors';
+import { type MipmapBlitDevice, type MipmapShaderModuleFactory } from './mipmap-generator';
+/** Cube-POD register-relay injected by the wire layer (D-3). */
+type RegisterCube = (world: World, pod: EquirectAsset) => Result<Handle<'EquirectAsset', 'shared'>, AssetError>;
+interface MeshGpuEntry {
+    readonly vertexBuffer: GpuBuffer;
+    /**
+     * Index buffer wrapper, or `null` for a vertex-only mesh
+     * (no `MeshAsset.indices`). When `null` the record stage takes the
+     * non-indexed `pass.draw(vertexCount)` path and never calls
+     * `setIndexBuffer`. Gated on `indexed` below.
+     */
+    readonly indexBuffer: GpuBuffer | null;
+    /**
+     * Allocation byte sizes for the vbo / ibo (mirrors GPUBuffer.size). Used
+     * by `updateMeshById` to decide reuse vs reallocation; tracked here so
+     * the runtime never reads `.size` off the opaque RHI handle (which is
+     * not on the spec-aligned RHI Buffer interface; charter §RHI form rules).
+     */
+    readonly vboBytes: number;
+    /** Allocation byte size for the ibo, or 0 when indexBuffer is null. */
+    readonly iboBytes: number;
+    /** Immutable geometry-owned layout projection used for all resident stride checks. */
+    readonly layoutProjection: VertexLayoutProjection;
+    readonly indexCount: number;
+    readonly indexFormat: 'uint16' | 'uint32';
+    /** Vertex count is derived from the geometry-owned projection stride. */
+    readonly vertexCount: number;
+    /** True when `MeshAsset.indices` is present (indexed draw path). */
+    readonly indexed: boolean;
+    /** Primitive topology (default 'triangle-list'). Mirrors MeshGpuHandles. */
+    readonly topology: PrimitiveTopology;
+    /**
+     * Submeshes from MeshAsset.submeshes, carried through to the record stage
+     * so per-submesh drawIndexed can iterate independently (feat-20260608 M4 / w16).
+     * For single-submesh meshes this is a 1-element array (byte-identical to pre-M4).
+     */
+    readonly submeshes: readonly import('@forgeax/engine-types').Submesh[];
+}
+/**
+ * GPU residency store. Owns the per-handle GPU caches and the upload
+ * primitives that build them. Constructed once per renderer; wired with the
+ * GPU device via `configureGpuDevice` after `Renderer.ready` resolves.
+ */
+export declare class GpuResourceStore {
+    /** Monotonic token for mesh GPU residency or contents changes. */
+    meshResidencyEpoch: number;
+    /** Monotonic token for texture/sampler identities used by material bind groups. */
+    materialResourceEpoch: number;
+    private gpuDevice;
+    private asyncCreateShaderModule;
+    private registerCube;
+    private errorRegistry;
+    private caps;
+    private readonly textureGpuHandles;
+    private readonly samplerGpuHandles;
+    private readonly cubemapGpuHandles;
+    private readonly cubemapIdempotentMap;
+    private readonly meshGpuHandles;
+    /**
+     * feat-20260723-cross-world-gpu-cache-collision: compose a cache key from
+     * the raw handle slot and the worldId so two worlds that independently
+     * allocate assets at the same slot number never collide in the GPU store.
+     * worldId=0 produces the bare slot (backward compat with single-world path).
+     */
+    private worldKey;
+    /**
+     * Wire the GPU device, shader-module factory, and cube-POD register relay.
+     * Called once by createRenderer after `Renderer.ready` resolves. This
+     * performs NO replay of CPU asset state:
+     * the pull model builds resources lazily at first `ensureResident` access.
+     */
+    configureGpuDevice(device: MipmapBlitDevice, asyncCreateShaderModule: MipmapShaderModuleFactory | undefined, registerCube: RegisterCube, caps: RhiCaps): void;
+    /**
+     * Wrap a raw RHI Buffer handle into a GpuBuffer. The wrapper holds a
+     * reference to the device so `.destroy()` forwards to
+     * `device.destroyBuffer(handle)` (M-3 / w11; plan-strategy D-2).
+     *
+     * Pre: `configureGpuDevice` has been called. Callers that build a buffer
+     * via `device.createBuffer` already gate on a wired device, so this private
+     * helper trusts the caller; an unwired call is a programmer error and
+     * surfaces as a non-null assertion rather than a structured error.
+     */
+    private wrapBuf;
+    private destroyMeshBuffer;
+    /** Wrap a raw RHI Texture handle into a GpuTexture (mirror of wrapBuf). */
+    private wrapTex;
+    /**
+     * Walk the three handle maps and destroy every GpuResource, then clear
+     * the maps. Called from `Renderer.dispose()` (M-5) as the first step of
+     * the dispose chain (plan-strategy D-2: dispose chain walks
+     * `gpuStore.destroyAll()` → `graph.drain()` → `instanceBuffers.clear()`
+     * → ...).
+     *
+     * Idempotent: a second call after the maps were cleared is a no-op
+     * (architecture-principles §6 idempotency). Each `.destroy()` call
+     * routes through the RHI shim's per-handle bookkeeping, so a stray
+     * second-destroy on a handle the runtime did not flip to destroyed
+     * surfaces as the structured `'destroy-after-destroy'` error from the
+     * RHI shim; that error is *not* re-thrown here -- destroyAll is a
+     * sweep that tolerates per-handle failures so the dispose chain can
+     * make progress (plan-strategy D-3 / D-8).
+     */
+    destroyAll(): void;
+    /**
+     * Set the error registry channel (wired by createRenderer). evict /
+     * releaseUnreferenced fire structured errors here instead of throwing -
+     * sweeps continue past individual failures (feat-20260619 D-1/D-6).
+     */
+    setErrorRegistry(registry: RhiErrorListenerRegistry): void;
+    /**
+     * evictTexture / evictMesh / evictCubemap — per-handle evict primitives.
+     *
+     * Reuses destroyAll's isDestroyed dedup logic + cubemap wrapper
+     * shared-dedup (feat-20260619 D-1). Returns {freed, errors} so callers
+     * can consume the aggregate result (D-3). Key not present -> no-op
+     * returning {freed:0, errors:[]}.
+     */
+    evictTexture(handle: Handle<'TextureAsset', 'shared'>, worldId?: number): {
+        freed: number;
+        errors: RhiError[];
+    };
+    evictMesh(handle: Handle<'MeshAsset', 'shared'>, worldId?: number): {
+        freed: number;
+        errors: RhiError[];
+    };
+    evictCubemap(id: number): {
+        freed: number;
+        errors: RhiError[];
+    };
+    /**
+     * releaseUnreferenced — iterate the three handle maps and evict entries
+     * whose key is NOT in `liveSet`.
+     *
+     * Iterates Map keys (not liveSet — store has no reverse index, D-8).
+     * IDs in liveSet that don't exist in the store are naturally ignored.
+     * Empty liveSet -> full release; second call -> no-op (maps empty,
+     * evict primitives are key-not-present no-op).
+     */
+    releaseUnreferenced(liveSet: Set<number>): {
+        freed: number;
+        errors: RhiError[];
+    };
+    /**
+     * Prewarm the mipmap pipeline cache for the given texture formats (D-9).
+     * Called from `createRenderer.ready` (already async): builds the one-time
+     * mipmap shader module + per-format render pipeline into the mipmap-generator
+     * deviceCache so the per-texture mipmap blit at record-stage `ensureResident`
+     * is pure synchronous encoder work. A format absent from this list will make
+     * the sync `ensureResident` texture arm return a structured RhiError rather
+     * than lazily await a build (which would break the sync draw contract).
+     */
+    prewarmMipmapPipeline(device: MipmapBlitDevice, formats: readonly GPUTextureFormat[]): Promise<Result<void, RhiError>>;
+    /**
+     * Return the GpuTexture wrapper for a `Handle<TextureAsset>` if it has been
+     * made resident, else `undefined`.
+     *
+     * @internal — test-only seam for cow-survivor / AC-02 integration tests; not
+     * part of the engine's public API surface.
+     */
+    _getTextureGpuTexture(handle: Handle<'TextureAsset', 'shared'>, worldId?: number): GpuTexture | undefined;
+    /**
+     * Return the GPU texture-view for a `Handle<TextureAsset>` if it has been
+     * made resident, else `undefined`.
+     */
+    getTextureGpuView(handle: Handle<'TextureAsset', 'shared'>, worldId?: number): TextureView | undefined;
+    /**
+     * Lazily materialise and cache a sampler descriptor for a material texture.
+     * Samplers are opaque, non-destroyable RHI handles, so disposal only drops
+     * this store's cache and lets the device own their lifetime.
+     */
+    ensureSamplerResident(handle: Handle<'SamplerAsset', 'shared'>, pod: SamplerAsset, worldId?: number): Result<Sampler, RhiError>;
+    /**
+     * Return the GpuTexture wrapper for the cubemap, or `undefined` if not
+     * uploaded yet. Consumers that need the raw RHI Texture handle (e.g.
+     * `device.createTextureView` arguments) read `.handle` on the wrapper;
+     * `.destroy()` routes through the destroy chain (M-3 / w11).
+     */
+    getCubemapGpuTexture(handle: Handle<'EquirectAsset', 'shared'>): GpuTexture | undefined;
+    /** Return the full-cube texture view, or `undefined` if not uploaded yet. */
+    getCubemapGpuView(handle: Handle<'EquirectAsset', 'shared'>): any | undefined;
+    /** Return per-face 2D views (6 faces), or `undefined` if not uploaded yet. */
+    getCubemapFaceViews(handle: Handle<'EquirectAsset', 'shared'>): readonly any[] | undefined;
+    /**
+     * Query the projection status for an equirect source handle (D-3 SSOT: the
+     * store's CubemapGpuEntry is the single authority). Returns `undefined` when
+     * no projection has been launched for this source yet (the record arm reads
+     * this to decide whether to fire the lazy projection; feat-20260630 M3 / w18):
+     *   - undefined -> no entry: caller may launch projection (fire-and-forget)
+     *   - 'pending' -> projection launched, not complete: bind white-cube fallback
+     *   - 'ready'   -> projected cube + IBL views live: bind real IBL
+     *   - 'failed'  -> projection errored: bind white fallback, do NOT retry (R-2)
+     */
+    getCubemapStatus(handle: Handle<'EquirectAsset', 'shared'>): 'pending' | 'ready' | 'failed' | undefined;
+    /**
+     * Return the GPU vertex / index buffer handles + index count for a
+     * `Handle<MeshAsset>` if resident, else `undefined`. Consumers treat this
+     * as the canonical "mesh asset has GPU residency" probe.
+     */
+    getMeshGpuHandles(handle: Handle<'MeshAsset', 'shared'>, worldId?: number): MeshGpuEntry | undefined;
+    /**
+     * Pull-model residency: build the GPU resource for `handle` from the
+     * caller-provided POD on a miss, return the cached handles on a hit (D-2).
+     *
+     * - mesh POD -> synchronous vertex / index buffer upload (mirrors the
+     *   pre-extraction `uploadMeshById`).
+     * - texture POD -> synchronous texture upload + mipmap blit (D-9). The
+     *   mipmap pipeline MUST have been prewarmed via `prewarmMipmapPipeline`;
+     *   an un-prewarmed format returns a structured RhiError (never awaits).
+     *
+     * Cubemap is NOT routed here -- it is an eager user call
+     * (`_uploadCubemapFromEquirect`). Builtin meshes are NOT routed here either
+     * (createRenderer step-3 owns them; D-1).
+     */
+    ensureResident(handle: Handle<'MeshAsset', 'shared'> | Handle<'TextureAsset', 'shared'>, pod: TypesMeshAsset | TextureAsset, worldId?: number): Result<any, RhiError | AssetError | ImageError>;
+    /**
+     * Eager public surface: upload decoded image bytes into a GPU texture and
+     * cache (texture + view) under the handle. The TextureAsset POD supplies the
+     * GPU format (D-2: caller provides POD, store never reaches a registry); the
+     * DecodedImage supplies the pixel bytes + colorSpace. Retains the async
+     * signature so callers that have not prewarmed can drive a mipmap build here
+     * (the one async source).
+     */
+    uploadTexture(handle: Handle<'TextureAsset', 'shared'>, pod: TextureAsset, decoded: DecodedImage, worldId?: number): Promise<Result<void, AssetError | ImageError | RhiError>>;
+    /**
+     * Synchronous texture upload used by `ensureResident` (D-9). Identical to
+     * `uploadTexture` except the mipmap pipeline is read from the prewarmed
+     * cache via the synchronous `blitMipmapsSync` -- an un-prewarmed format
+     * returns a structured RhiError instead of awaiting a build.
+     */
+    private uploadTextureSync;
+    /**
+     * Shared texture-upload prelude: format / colorSpace consistency assertion,
+     * GPU texture allocation + writeTexture. Returns `gpuTexture: undefined`
+     * (with ok) when no device is wired (deferred path).
+     */
+    private prepareTextureUpload;
+    /**
+     * Project an equirectangular HDR `EquirectAsset` into a GPU cubemap + IBL
+     * precompute. NOT part of the `ensureResident` pull path.
+     *
+     * @internal — feat-20260630 D-3 / F-9: the cubemap projection is engine
+     * internals, not a user surface. AI users declare `Skylight{equirect}` and
+     * the render-system record arm (same package) drives this method per-frame;
+     * the `_` prefix + `@internal` mark it package-internal (lint:internal gate)
+     * so it never appears as a user-facing call. (A cross-file `private` is not
+     * reachable by the record arm; package-internal is the correct visibility.)
+     *
+     * Idempotent: a second call with the same source handle returns the cached
+     * cubemap handle (no second GPU texture). The minted cubemap handle is an
+     * `EquirectAsset` shared ref catalogued via the injected `registerCube` relay
+     * (D-3); the store never imports AssetRegistry.
+     *
+     * Status (D-3): every entry written carries `status`. A failed projection
+     * records `status:'failed'` EXPLICITLY (R-2 / AC-09) so the caller never
+     * retries by inferring "no entry => try again".
+     */
+    _uploadCubemapFromEquirect(world: World, sourceHandle: Handle<'EquirectAsset', 'shared'>, sourcePod: EquirectAsset): Promise<Result<Handle<'EquirectAsset', 'shared'>, AssetError | RhiError>>;
+    /**
+     * Upload `MeshAsset.vertices` + `MeshAsset.indices` to GPU buffers and cache
+     * the handles under the asset id. Synchronous; mirrors the pre-extraction
+     * `uploadMeshById` byte-for-byte. Returns the cached entry on success.
+     */
+    private uploadMeshById;
+    /**
+     * Update an existing resident mesh without changing its shape or metadata.
+     * A shape change must use a new asset handle; this method never reallocates
+     * or silently changes the draw contract.
+     */
+    private updateMeshById;
+    /**
+     * Internal explicit rebuild path used when an owner has deliberately
+     * replaced a mesh shape. Public callers should register a new MeshAsset
+     * handle so CPU recovery data and GPU residency remain one authority.
+     */
+    private replaceMeshById;
+    /**
+     * Public surface for updating an existing unmanaged mesh handle's GPU buffer
+     * data in-place. The handle must have been made resident.
+     */
+    updateMesh(handle: Handle<'MeshAsset', 'shared'>, newVertices: Float32Array, newIndices: Uint16Array | Uint32Array | undefined, worldId?: number, submeshes?: readonly Submesh[]): Result<void, MeshUpdateErrorType | RhiError>;
+    /** Explicit internal rebuild path; public callers should use a new asset handle. */
+    replaceMesh(handle: Handle<'MeshAsset', 'shared'>, newVertices: Float32Array, newIndices: Uint16Array | Uint32Array | undefined, worldId?: number, submeshes?: readonly Submesh[]): Result<void, MeshUpdateErrorType | RhiError>;
+    /** Upload a contiguous vertex range using the resident mesh stride. */
+    updateMeshVertexRange(handle: Handle<'MeshAsset', 'shared'>, vertices: Float32Array, firstVertex: number, vertexCount: number, worldId?: number): Result<void, MeshUpdateErrorType | RhiError>;
+}
+export {};
+//# sourceMappingURL=gpu-resource-store.d.ts.map