@forgeax/engine-render 0.0.0-dev.8d955ade1c79

package/dist/fullscreen-post-process-pass.d.ts

@@ -0,0 +1,157 @@
+import type { BindGroup, BindGroupLayout, Buffer, RhiDevice, RhiError, RhiRenderPassEncoder, Sampler, TextureView } from '@forgeax/engine-rhi';
+/**
+ * Declared sample type for a post-process read entry.
+ *
+ * Closed union (plan-strategy D-7): only `'depth'` is an explicit sampleType
+ * discriminant; color inputs are the default (bare `string` or un-suffixed
+ * `{ key }`).  Future texture types (`r32float`, etc.) are add-only.
+ *
+ * AI-user affordance: IDE autocomplete exposes `'depth'` at the register call
+ * site; misspellings are caught by the type system (AC-08).
+ */
+export type PostProcessReadSampleType = 'depth';
+/**
+ * A fullscreen post-process shader entry owned by the feature host.
+ *
+ * Analogous to MaterialShaderEntry in the ShaderCatalog but with post-process-specific
+ * fields: the input-texture + sampler BGL is auto-built by the primitive,
+ * no paramSchema (params are passed inline via a {type, value} struct — plan-strategy D-4).
+ *
+ * `params` carries the WGSL struct definition + default value. When `params` is
+ * `undefined`, the post-process shader has no UBO (e.g. FXAA — Finding M2-1).
+ *
+ * `reads` declares graph resource keys this pass samples as input texture(s).
+ * If omitted, the pass samples the swap-chain color attachment (default path).
+ *
+ * Structured reads (plan-strategy D-1): each entry can be a bare string
+ * (backward-compatible color input) or an object `{ key, sampleType? }`.
+ * When `sampleType` is `'depth'`, the dispatcher resolves a depth-only view
+ * and binds it at depthTex@3 / depthSampler@4 in the fullscreen bind group.
+ */
+export interface PostProcessShaderEntry {
+    /** Composed WGSL source for the fragment stage (post-naga_oil). */
+    readonly source: string;
+    /**
+     * Params UBO schema. When undefined, the shader has no uniform buffer (e.g. FXAA)
+     * and the BGL degrades to 2 entries (texture@0 + sampler@1). When present, the
+     * primitive eager-creates a params UBO (at register, sized `byteSize`) and binds
+     * it at bindgroup(1) binding(2) as part of a 3-entry BGL
+     * (texture@0 + sampler@1 + buffer@2). feat-20260621 M-A2 / D-2.
+     */
+    readonly params?: PostProcessParamsSchema | undefined;
+    /**
+     * Graph resource keys this post-process reads (as input textures).
+     * The primitive binds the first read as its input texture at @group(1)
+     * @binding(0) (the sampler is @group(1) @binding(1); group 0 is reserved for a
+     * future view bind group — dispatchFullscreenPass calls setBindGroup(1, ...)).
+     * When empty or omitted, the pass reads the swap-chain directly.
+     *
+     * Each entry is either a bare string (backward-compatible color input) or an
+     * object `{ key: string; sampleType?: PostProcessReadSampleType }` for typed
+     * reads (e.g. `{ key: 'depth', sampleType: 'depth' }` for depth sampling).
+     * Bare strings and `{ key }` without `sampleType` are equivalent — both
+     * represent a color input (plan-strategy D-1 / D-7).
+     */
+    readonly reads?: readonly (string | PostProcessReadEntry)[] | undefined;
+}
+/**
+ * Structured read entry for a post-process shader.
+ *
+ * `key` is the graph resource key (matching a graph color target).
+ * `sampleType` is an optional type discriminant (D-1 SSOT); when omitted
+ * the entry is treated as a color input (same as a bare string).
+ */
+export interface PostProcessReadEntry {
+    readonly key: string;
+    readonly sampleType?: PostProcessReadSampleType | undefined;
+}
+/**
+ * Params schema: the WGSL struct definition + default byte array for a post-process
+ * UBO. The primitive allocates a GPU buffer of `byteSize` and uploads `defaultValue`
+ * at register time; the UBO is then updated per-frame via the data-driven
+ * `PostProcessParams` ECS component (component `data` -> extract snapshot ->
+ * dispatchFullscreenPass `queue.writeBuffer`), NOT via an imperative setter.
+ * feat-20260621 M-A1/M-A2 / D-1.
+ */
+export interface PostProcessParamsSchema {
+    /** Byte size of the WGSL params struct (must be UBO-aligned, min 16 B). */
+    readonly byteSize: number;
+    /** Default UBO contents (length must equal `byteSize`). */
+    readonly defaultValue: Uint8Array;
+}
+/**
+ * The minimal surface a `registerFullscreenPostProcess` injector receives.
+ * Contains the RHI device (for creating BGLs / pipelines / samplers) and the
+ * error registry for structured failure reporting.
+ */
+export interface FullscreenPostProcessDeviceContext {
+    readonly device: RhiDevice;
+    readonly errorRegistry: {
+        fire(error: RhiError): void;
+    };
+}
+/**
+ * Check whether the entry's {@link PostProcessShaderEntry.reads} declares a read
+ * with `sampleType: 'depth'`. Used by {@link buildFullscreenPostProcessPass} to
+ * select between the single-sample and multisample depth BGL variants and the
+ * existing color-only kinds.
+ */
+export declare function entryHasDepthRead(entry: PostProcessShaderEntry): boolean;
+/**
+ * Byte size of the minimal params UBO auto-allocated for a depth-reading entry
+ * that declares no `params`. The `'fullscreen-post-with-scene-depth'` BGL always
+ * declares `params@2`, so a bound UBO must exist even when the shader has no
+ * user params (plan D-3: param-less depth effect gets a minimal 16B UBO). 16 B
+ * is WebGPU's minimum uniform-buffer binding size.
+ */
+export declare const DEPTH_MIN_PARAMS_BYTE_SIZE = 16;
+/**
+ * State of a registered fullscreen post-process pass.
+ *
+ * Created by the typed fullscreen feature graph and stored per-pass in the render system.
+ * The `draw` method is called by the per-frame execute closure.
+ */
+export interface FullscreenPostProcessPassHandle {
+    /** The pass name (same as the `color` target key). */
+    readonly name: string;
+    /** Execute one fullscreen draw: bind input texture, set pipeline, draw 3 vertices. */
+    draw(encoder: RhiRenderPassEncoder, inputView: TextureView): void;
+    /**
+     * The per-frame params UBO this pass binds at group(1) binding(2), or null
+     * when `entry.params === undefined` (param-less consumer, 2-entry BGL). The
+     * dispatcher writes the snapshot bytes into it before draw and composes it
+     * into the bind group via {@link createFullscreenBindGroup}.
+     */
+    readonly paramsBuffer: Buffer | null;
+}
+/**
+ * Build a fullscreen post-process pass primitive.
+ *
+ * Creates BGL, sampler, and pipeline state from the registered shader entry.
+ * Returns the pass handle + the BGL + the sampler so the caller can compose
+ * bind groups. The BGL + sampler are shared across instances of the same shader.
+ *
+ * @returns The BGL, sampler, and a factory to create pass handles.
+ */
+export declare function buildFullscreenPostProcessPass(ctx: FullscreenPostProcessDeviceContext, entry: PostProcessShaderEntry, depthMultisampled?: boolean): {
+    bindGroupLayout: BindGroupLayout;
+    sampler: Sampler | null;
+    depthSampler: Sampler | null;
+    createHandle: (name: string, pipeline: unknown, paramsBuffer: Buffer | null) => FullscreenPostProcessPassHandle;
+} | null;
+/**
+ * Create a fullscreen bind group (lazy, per-frame). Composes the input texture
+ * view + the linear sampler into group(1) (texture@0 + sampler@1). When
+ * `paramsBuffer` is supplied (feat-20260621 D-2: `entry.params !== undefined`),
+ * appends the per-frame params UBO at binding 2 (uniform), matching the 3-entry
+ * `'fullscreen-post-with-params'` BGL. Omitting it yields the 2-entry shape
+ * param-less consumers degrade to (R-A7).
+ *
+ * When `depthTexView` + `depthSampler` are supplied (plan-strategy D-3:
+ * depth reads present), appends the depth texture view at binding 3 and the
+ * non-filtering depth sampler at binding 4, matching the 5-entry
+ * `'fullscreen-post-with-scene-depth'` BGL. Both must be supplied together
+ * (or both omitted for existing color-only consumers — AC-03 zero-regression).
+ */
+export declare function createFullscreenBindGroup(device: RhiDevice, bgl: BindGroupLayout, inputView: TextureView, sampler: Sampler | null, paramsBuffer?: Buffer | null, depthTexView?: TextureView | null, depthSampler?: Sampler | null): BindGroup | null;
+//# sourceMappingURL=fullscreen-post-process-pass.d.ts.map

package/dist/fullscreen-post-process-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fullscreen-post-process-pass.d.ts","sourceRoot":"","sources":["../src/fullscreen-post-process-pass.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EACf,MAAM,EACN,SAAS,EACT,QAAQ,EACR,oBAAoB,EACpB,OAAO,EACP,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAsB7B;;;;;;;;;GASG;AACH,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAAC;AAIhD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,sBAAsB;IACrC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;IACtD;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,oBAAoB,CAAC,EAAE,GAAG,SAAS,CAAC;CACzE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,CAAC,EAAE,yBAAyB,GAAG,SAAS,CAAC;CAC7D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,uBAAuB;IACtC,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC;CACnC;AAID;;;;GAIG;AACH,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE;QACtB,IAAI,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;KAC7B,CAAC;CACH;AAmDD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAGxE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAI7C;;;;;GAKG;AACH,MAAM,WAAW,+BAA+B;IAC9C,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sFAAsF;IACtF,IAAI,CAAC,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,WAAW,GAAG,IAAI,CAAC;IAClE;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAED;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,kCAAkC,EACvC,KAAK,EAAE,sBAAsB,EAC7B,iBAAiB,UAAQ,GACxB;IACD,eAAe,EAAE,eAAe,CAAC;IACjC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,YAAY,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,CACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,EACjB,YAAY,EAAE,MAAM,GAAG,IAAI,KACxB,+BAA+B,CAAC;CACtC,GAAG,IAAI,CAqDP;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,SAAS,EACjB,GAAG,EAAE,eAAe,EACpB,SAAS,EAAE,WAAW,EACtB,OAAO,EAAE,OAAO,GAAG,IAAI,EACvB,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,EAC5B,YAAY,CAAC,EAAE,WAAW,GAAG,IAAI,EACjC,YAAY,CAAC,EAAE,OAAO,GAAG,IAAI,GAC5B,SAAS,GAAG,IAAI,CA0BlB"}

package/dist/glyph-text-layout-system.d.ts

@@ -0,0 +1,19 @@
+import type { World } from '@forgeax/engine-ecs';
+import type { Handle } from '@forgeax/engine-types';
+import { type Result, TextError } from '@forgeax/engine-types';
+import type { GpuResidencyCache } from './device/gpu-residency';
+/** Clear the per-entity bake + per-font material caches (test isolation). */
+export declare function resetGlyphBakeCache(): void;
+/** @internal archetype-walk view (same shape reached for in render-system-extract). */
+/**
+ * Lay out + bake every `GlyphText` entity, attaching MeshFilter + MeshRenderer
+ * on first observation and re-baking in place on a text / size / color change.
+ *
+ * @param world The ECS world holding the GlyphText entities.
+ * @returns `ok(void)` on a clean pass, or `err(TextError)` carrying the FIRST
+ *   structured failure (currently only `font-concurrency-exceeded`). Healthy
+ *   entities observed before the failing one are still baked.
+ */
+export declare function glyphTextLayoutSystem(world: World, gpuStore: GpuResidencyCache): Result<void, TextError>;
+export declare function ensureGlyphMeshMaterialSlots(world: World, meshHandle: Handle<'MeshAsset', 'shared'>): void;
+//# sourceMappingURL=glyph-text-layout-system.d.ts.map

package/dist/glyph-text-layout-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glyph-text-layout-system.d.ts","sourceRoot":"","sources":["../src/glyph-text-layout-system.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAgB,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAS/D,OAAO,KAAK,EAAa,MAAM,EAAqC,MAAM,uBAAuB,CAAC;AAClG,OAAO,EAAW,KAAK,MAAM,EAAE,SAAS,EAAwB,MAAM,uBAAuB,CAAC;AAG9F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AA6BhE,6EAA6E;AAC7E,wBAAgB,mBAAmB,IAAI,IAAI,CAI1C;AAsED,uFAAuF;AACvF;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,iBAAiB,GAC1B,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAuBzB;AA2JD,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,KAAK,EACZ,UAAU,EAAE,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,GACxC,IAAI,CAKN"}

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

@@ -0,0 +1,55 @@
+import type { PrimitiveTopology } from '@forgeax/engine-types';
+import type { BatchTopologyInspection } from '../inspection-types';
+import type { RenderSceneApplyResult, RenderSceneSlot } from '../scene/render-scene-types';
+export type { BatchTopologyInspection } from '../inspection-types';
+export interface GpuDrivenBatchKey {
+    readonly assetHandle: number;
+    readonly drawKind: 'indexed' | 'non-indexed';
+    readonly first: number;
+    readonly count: number;
+    readonly baseVertex: number;
+    readonly materialSlot: number;
+    readonly topology: PrimitiveTopology;
+    readonly pipelineClass: string;
+    readonly materialResourceClass: string;
+}
+export interface GpuDrivenCandidate {
+    readonly primitiveIndex: number;
+    readonly generation: number;
+    readonly drawItemIndex: number;
+    readonly instanceOrdinal: number;
+}
+export interface GpuDrivenBatch {
+    readonly batchId: number;
+    readonly generation: number;
+    readonly key: GpuDrivenBatchKey;
+    readonly candidates: readonly GpuDrivenCandidate[];
+    readonly visibleBase: number;
+    readonly visibleCapacity: number;
+    readonly indirectOffset: number;
+}
+export interface SubmissionPlan {
+    readonly revision: number;
+    readonly batches: readonly GpuDrivenBatch[];
+    readonly candidateCount: number;
+    readonly visibleCapacity: number;
+}
+/** Stable compatibility grouping; per-view visibility never mutates this owner. */
+export declare class BatchTopology {
+    private readonly batches;
+    private readonly membershipByPrimitive;
+    private readonly ineligiblePrimitives;
+    private readonly generationByBatchId;
+    private readonly freeBatchIds;
+    private revision;
+    private rebuilds;
+    private patches;
+    private cachedPlan;
+    rebuild(slots: readonly RenderSceneSlot[]): void;
+    apply(delta: RenderSceneApplyResult): boolean;
+    plan(): SubmissionPlan;
+    inspect(): BatchTopologyInspection;
+    private add;
+    private remove;
+}
+//# sourceMappingURL=batch-topology.d.ts.map

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":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAE3F,YAAY,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAEnE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,GAAG,aAAa,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;CACxC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,GAAG,EAAE,iBAAiB,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AA+CD,mFAAmF;AACnF,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAC3D,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAGlC;IACJ,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAqB;IAC1D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAgB;IACpD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAgB;IAC7C,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,UAAU,CAA6B;IAE/C,OAAO,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,IAAI;IAYhD,KAAK,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO;IA+B7C,IAAI,IAAI,cAAc;IAiCtB,OAAO,IAAI,uBAAuB;IAalC,OAAO,CAAC,GAAG;IAqCX,OAAO,CAAC,MAAM;CAgBf"}

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

@@ -0,0 +1,51 @@
+import type { RenderGraphBuilder, RenderGraphError } from '@forgeax/engine-render-graph';
+import type { BindGroupLayout, Result, RhiDevice, TextureFormat } from '@forgeax/engine-rhi';
+import { RhiError } from '@forgeax/engine-rhi';
+import type { MeshGpuHandles } from '../device/gpu-residency';
+import type { GpuDrivenProductionInspection } from '../inspection-types';
+import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
+import type { CameraSnapshot } from '../render-contract';
+import type { RenderPipelineFrame, RenderPipelineGpuDrivenProjection } from '../render-pipeline';
+import type { RenderableSnapshot } from '../render-system-extract';
+import type { PersistentGpuDrivenState } from '../scene/render-scene';
+export declare const GPU_DRIVEN_RIGID_UNLIT_WGSL: string;
+export interface PreparedGpuDrivenFrame {
+    readonly topologySignature: string;
+    readonly entityKeys: ReadonlySet<number>;
+    readonly ownsAllRenderables: boolean;
+    /** @internal Commits a replacement generation only after graph promotion. */
+    readonly _commitResourceReplacement: () => void;
+    project(graph: RenderGraphBuilder<RenderPipelineFrame>, format: TextureFormat, sampleCount: 1 | 4): Result<RenderPipelineGpuDrivenProjection, RenderGraphError | RhiError>;
+}
+export declare class GpuDrivenProduction {
+    private readonly device;
+    private readonly shaderModuleFactory;
+    private view;
+    private raster;
+    private readonly sceneIdentities;
+    private nextSceneIdentity;
+    private filteredCache;
+    private gpuOwnedSnapshotsMaterialized;
+    private filteredPlanBuilds;
+    private gpuOwnedEntityCount;
+    private batchBindGroupCreates;
+    private validatedGpuOwnedRows;
+    private cpuFallbackDrawItems;
+    private signatureCache;
+    constructor(device: RhiDevice, shaderModuleFactory: PipelineBuilderShaderModuleFactory);
+    prepare(input: {
+        readonly scene: PersistentGpuDrivenState | undefined;
+        readonly camera: CameraSnapshot;
+        readonly meshes: ReadonlyMap<number, MeshGpuHandles>;
+        readonly viewBindGroupLayout: BindGroupLayout;
+        readonly meshResidencyEpoch: number;
+        readonly hdrp: boolean;
+    }): Result<PreparedGpuDrivenFrame | undefined, RhiError>;
+    dispose(): void;
+    inspect(): GpuDrivenProductionInspection;
+    recordCpuValidation(validated: readonly {
+        readonly source: RenderableSnapshot;
+    }[], gpuOwned: ReadonlySet<number>): void;
+    private sceneIdentity;
+}
+//# 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":"AACA,OAAO,KAAK,EAIV,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAEV,eAAe,EAEf,MAAM,EACN,SAAS,EAET,aAAa,EACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAW,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAO9D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AAG9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AACjG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAQtE,eAAO,MAAM,2BAA2B,QA0CvC,CAAC;AAsSF,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACzC,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,6EAA6E;IAC7E,QAAQ,CAAC,0BAA0B,EAAE,MAAM,IAAI,CAAC;IAChD,OAAO,CACL,KAAK,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,EAC9C,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,CAAC,GAAG,CAAC,GACjB,MAAM,CAAC,iCAAiC,EAAE,gBAAgB,GAAG,QAAQ,CAAC,CAAC;CAC3E;AAED,qBAAa,mBAAmB;IA6B5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IA7BtC,OAAO,CAAC,IAAI,CAA4B;IACxC,OAAO,CAAC,MAAM,CAAmC;IACjD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiC;IACjE,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,aAAa,CAMP;IACd,OAAO,CAAC,6BAA6B,CAAK;IAC1C,OAAO,CAAC,kBAAkB,CAAK;IAC/B,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,qBAAqB,CAAK;IAClC,OAAO,CAAC,qBAAqB,CAAK;IAClC,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,cAAc,CAQR;gBAGK,MAAM,EAAE,SAAS,EACjB,mBAAmB,EAAE,kCAAkC;IAG1E,OAAO,CAAC,KAAK,EAAE;QACb,QAAQ,CAAC,KAAK,EAAE,wBAAwB,GAAG,SAAS,CAAC;QACrD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;QAChC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QACrD,QAAQ,CAAC,mBAAmB,EAAE,eAAe,CAAC;QAC9C,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;QACpC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;KACxB,GAAG,MAAM,CAAC,sBAAsB,GAAG,SAAS,EAAE,QAAQ,CAAC;IA2NxD,OAAO,IAAI,IAAI;IAQf,OAAO,IAAI,6BAA6B;IAiBxC,mBAAmB,CACjB,SAAS,EAAE,SAAS;QAAE,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAA;KAAE,EAAE,EAC7D,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,GAC5B,IAAI;IASP,OAAO,CAAC,aAAa;CAQtB"}

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

@@ -0,0 +1,85 @@
+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 { 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 declare class GpuDrivenView {
+    private readonly device;
+    private readonly bindGroupLayout;
+    private readonly pipelineLayout;
+    private readonly resetPipeline;
+    private readonly cullPipeline;
+    private readonly finalizePipeline;
+    private buffers;
+    private supersededBuffers;
+    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>): Result<GpuDrivenViewGraphResources, RenderGraphError>;
+    dispose(): void;
+    /**
+     * @internal
+     * Accept the current buffer generation after its typed graph compiles.
+     * Superseded imports stay alive while the last-known-good graph remains
+     * executable, then retire behind the queue fence only after promotion.
+     */
+    _commitResourceReplacement(): void;
+    private rebuildBuffers;
+    private destroyAfterSubmittedWork;
+}
+//# 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":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAGV,MAAM,EAGN,MAAM,EACN,SAAS,EACV,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAW,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAS7C,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAQvD,eAAO,MAAM,oBAAoB,88IAmIhC,CAAC;AAaF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;CAChC;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;IAC1C,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;CACrC;AAaD,qBAAa,aAAa;IAuBtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IA3BnC,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,iBAAiB,CAAqB;IAC9C,OAAO,CAAC,SAAS,CAAwB;IACzC,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,IAAI,CAA6B;IACzC,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,wBAAwB,CAAK;IACrC,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,kBAAkB,CAAK;IAE/B,OAAO;IASP,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE;QACnB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;QAC3B,QAAQ,CAAC,mBAAmB,EAAE,kCAAkC,CAAC;KAClE,GAAG,MAAM,CAAC,aAAa,EAAE,QAAQ,CAAC;IA4DnC,MAAM,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC;IAsH3F,OAAO,IAAI,uBAAuB;IAoBlC,IAAI,aAAa,IAAI,MAAM,GAAG,SAAS,CAEtC;IAED,IAAI,cAAc,IAAI,MAAM,GAAG,SAAS,CAEvC;IAED,IAAI,cAAc,IAAI,MAAM,GAAG,SAAS,CAEvC;IAED,IAAI,kBAAkB,IAAI,MAAM,CAE/B;IAED,SAAS,CAAC,QAAQ,SAAS,gBAAgB,EACzC,OAAO,EAAE,kBAAkB,CAAC,QAAQ,CAAC,GACpC,MAAM,CAAC,2BAA2B,EAAE,gBAAgB,CAAC;IAiJxD,OAAO,IAAI,IAAI;IAkBf;;;;;OAKG;IACH,0BAA0B,IAAI,IAAI;IAOlC,OAAO,CAAC,cAAc;IAgDtB,OAAO,CAAC,yBAAyB;CAWlC"}

package/dist/gpu-resource.d.ts

@@ -0,0 +1,73 @@
+import type { Buffer, Result, RhiDevice, RhiError, Texture } from '@forgeax/engine-rhi';
+/**
+ * Runtime wrapper around an RHI `Buffer` opaque handle that exposes
+ * an explicit `.destroy()` lifecycle.
+ *
+ * Holds the device by reference (no clone); the device's own lifetime
+ * outlives the buffer. After `.destroy()` returns ok, `isDestroyed`
+ * flips to true; a second `.destroy()` returns err code
+ * `'destroy-after-destroy'` forwarded from `device.destroyBuffer(...)`.
+ *
+ * @example
+ *   import { GpuBuffer } from './gpu-resource';
+ *   const created = device.createBuffer({ size: 64, usage: GPUBufferUsage.STORAGE });
+ *   if (!created.ok) return;
+ *   const gpuBuf = new GpuBuffer(device, created.value);
+ *   // ... use gpuBuf.handle in RHI calls ...
+ *   const r = gpuBuf.destroy();
+ *   if (!r.ok) {
+ *     // r.error.code is one of the RhiErrorCode union members,
+ *     // typically 'destroy-after-destroy' on a stale handle.
+ *   }
+ */
+export declare class GpuBuffer {
+    readonly device: RhiDevice;
+    readonly handle: Buffer;
+    private destroyed;
+    constructor(device: RhiDevice, handle: Buffer);
+    get isDestroyed(): boolean;
+    /**
+     * Destroy the underlying GPU buffer. Forwards to
+     * `device.destroyBuffer(handle)`; on ok flips `isDestroyed` to true,
+     * on err leaves the flag unchanged so a downstream second destroy
+     * still surfaces the underlying RHI fail-fast.
+     */
+    destroy(): Result<void, RhiError>;
+}
+/**
+ * Runtime wrapper around an RHI `Texture` opaque handle that exposes
+ * an explicit `.destroy()` lifecycle. Mirrors `GpuBuffer` exactly --
+ * the only difference is the underlying RHI surface
+ * (`device.destroyTexture` instead of `device.destroyBuffer`) and the
+ * handle brand. Same SSOT rationale: the destroyed bookkeeping lives
+ * on the RHI shim's TEXTURE_META_MAP; the local flag is a derived view.
+ *
+ * @example
+ *   import { GpuTexture } from './gpu-resource';
+ *   const r = device.createTexture({ size: [w, h, 1], format: 'rgba8unorm', usage: ... });
+ *   if (!r.ok) return;
+ *   const gpuTex = new GpuTexture(device, r.value);
+ *   // ... use gpuTex.handle in RHI calls ...
+ *   gpuTex.destroy();
+ */
+export declare class GpuTexture {
+    readonly device: RhiDevice;
+    readonly handle: Texture;
+    private destroyed;
+    constructor(device: RhiDevice, handle: Texture);
+    get isDestroyed(): boolean;
+    /**
+     * Destroy the underlying GPU texture. Forwards to
+     * `device.destroyTexture(handle)`; ok branch sets `isDestroyed=true`.
+     */
+    destroy(): Result<void, RhiError>;
+}
+/**
+ * Union of runtime-managed GPU resources requiring explicit
+ * `.destroy()`. AI-user-facing code that needs to dispose "a GPU
+ * resource" types its parameter as `GpuResource` and lets TS narrow
+ * via `instanceof GpuBuffer / GpuTexture` if branch-specific access
+ * is required. Charter F1 single-entry indexability.
+ */
+export type GpuResource = GpuBuffer | GpuTexture;
+//# sourceMappingURL=gpu-resource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-resource.d.ts","sourceRoot":"","sources":["../src/gpu-resource.ts"],"names":[],"mappings":"AAqDA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAExF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,SAAS;IACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAIxB,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM;IAK7C,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED;;;;;OAKG;IACH,OAAO,IAAI,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC;CAOlC;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,UAAU;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO;IAK9C,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED;;;OAGG;IACH,OAAO,IAAI,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC;CAOlC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,UAAU,CAAC"}

package/dist/gpu-scene-schema.d.ts

@@ -0,0 +1,78 @@
+export type GpuSceneScalar = 'u32' | 'i32' | 'f32';
+export type GpuSceneFieldType = GpuSceneScalar | 'vec4<f32>' | 'mat4x4<f32>';
+export interface GpuSceneField {
+    readonly name: string;
+    readonly type: GpuSceneFieldType;
+}
+export interface GpuSceneTableSchema {
+    readonly name: string;
+    readonly fields: readonly GpuSceneField[];
+}
+export interface GpuSceneFieldLayout extends GpuSceneField {
+    readonly offset: number;
+    readonly size: number;
+    readonly alignment: number;
+}
+export interface GpuSceneTableLayout {
+    readonly name: string;
+    readonly stride: number;
+    readonly fields: readonly GpuSceneFieldLayout[];
+}
+export declare function deriveGpuSceneTableLayout(schema: GpuSceneTableSchema): GpuSceneTableLayout;
+export declare function gpuSceneFieldOffset(layout: GpuSceneTableLayout, name: string): number;
+export declare function gpuSceneWgsl(layout: GpuSceneTableLayout): string;
+export declare const GPU_SCENE_SCHEMAS: Readonly<{
+    primitive: {
+        name: string;
+        fields: ({
+            name: string;
+            type: "u32";
+        } | {
+            name: string;
+            type: "vec4<f32>";
+        })[];
+    };
+    instance: {
+        name: string;
+        fields: {
+            name: string;
+            type: "u32";
+        }[];
+    };
+    transform: {
+        name: string;
+        fields: {
+            name: string;
+            type: "mat4x4<f32>";
+        }[];
+    };
+    drawTemplate: {
+        name: string;
+        fields: ({
+            name: string;
+            type: "u32";
+        } | {
+            name: string;
+            type: "i32";
+        })[];
+    };
+    material: {
+        name: string;
+        fields: ({
+            name: string;
+            type: "vec4<f32>";
+        } | {
+            name: string;
+            type: "u32";
+        })[];
+    };
+}>;
+export declare const GPU_SCENE_LAYOUTS: Readonly<{
+    readonly primitive: GpuSceneTableLayout;
+    readonly instance: GpuSceneTableLayout;
+    readonly transform: GpuSceneTableLayout;
+    readonly drawTemplate: GpuSceneTableLayout;
+    readonly material: GpuSceneTableLayout;
+}>;
+export declare const GPU_SCENE_WGSL: string;
+//# sourceMappingURL=gpu-scene-schema.d.ts.map

package/dist/gpu-scene-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-scene-schema.d.ts","sourceRoot":"","sources":["../src/gpu-scene-schema.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AACnD,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG,WAAW,GAAG,aAAa,CAAC;AAE7E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;CAClC;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,mBAAoB,SAAQ,aAAa;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACjD;AAgBD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,mBAAmB,GAAG,mBAAmB,CAY1F;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAIrF;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAGhE;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0D4B,CAAC;AAE3D,eAAO,MAAM,iBAAiB;;;;;;EAS7B,CAAC;AAEF,eAAO,MAAM,cAAc,QAAkE,CAAC"}

package/dist/gpu-scene.d.ts

@@ -0,0 +1,55 @@
+import type { Buffer, Result, RhiDevice } from '@forgeax/engine-rhi';
+import { RhiError } from '@forgeax/engine-rhi';
+import type { GpuSceneInspection } from './inspection-types';
+import type { RenderSceneApplyResult, RenderSceneSlot } from './scene/render-scene-types';
+export type { GpuSceneInspection } from './inspection-types';
+export interface GpuSceneSyncResult {
+    readonly ranges: number;
+    readonly bytes: number;
+    readonly grew: boolean;
+    readonly cleared: number;
+}
+export type GpuSceneAvailability = {
+    readonly status: 'available';
+    readonly scene: GpuScene;
+} | {
+    readonly status: 'unavailable';
+    readonly reason: 'storage-buffer-unavailable';
+};
+/** Persistent GPU tables derived only from renderer projection slots. */
+export declare class GpuScene {
+    private readonly device;
+    private capacity;
+    private tableBytes;
+    private buffers;
+    private uploadRanges;
+    private uploadBytes;
+    private capacityGrows;
+    private fullRebuilds;
+    private clearedSlots;
+    private noChangeFrames;
+    private readonly allocations;
+    private readonly instances;
+    private readonly transforms;
+    private readonly draws;
+    private readonly materials;
+    private constructor();
+    static create(device: RhiDevice, initialCapacity?: number): Result<GpuSceneAvailability, RhiError>;
+    get primitiveBuffer(): Buffer;
+    get instanceBuffer(): Buffer;
+    get transformBuffer(): Buffer;
+    get drawTemplateBuffer(): Buffer;
+    get materialBuffer(): Buffer;
+    sync(delta: RenderSceneApplyResult): Result<GpuSceneSyncResult, RhiError>;
+    rebuild(slots: readonly RenderSceneSlot[]): Result<GpuSceneSyncResult, RhiError>;
+    inspect(): GpuSceneInspection;
+    dispose(): void;
+    private writeSlot;
+    private clearSlot;
+    private uploadRows;
+    private ensureAllocation;
+    private clearAllocation;
+    private grow;
+    private allocateCpuTables;
+}
+//# sourceMappingURL=gpu-scene.d.ts.map

package/dist/gpu-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-scene.d.ts","sourceRoot":"","sources":["../src/gpu-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAW,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAWxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE1F,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AA0F7D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,GAC1D;IAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,4BAA4B,CAAA;CAAE,CAAC;AA8EtF,yEAAyE;AACzE,qBAAa,QAAQ;IAgBjB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ;IAhBlB,OAAO,CAAC,UAAU,CAAyC;IAC3D,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA0C;IACtE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8B;IACxD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA8B;IACzD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IACpD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8B;IAExD,OAAO;IASP,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,eAAe,SAAM,GAAG,MAAM,CAAC,oBAAoB,EAAE,QAAQ,CAAC;IAa/F,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,IAAI,cAAc,IAAI,MAAM,CAE3B;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,IAAI,kBAAkB,IAAI,MAAM,CAE/B;IAED,IAAI,cAAc,IAAI,MAAM,CAE3B;IAED,IAAI,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CAAC,kBAAkB,EAAE,QAAQ,CAAC;IA8CzE,OAAO,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,MAAM,CAAC,kBAAkB,EAAE,QAAQ,CAAC;IA2ChF,OAAO,IAAI,kBAAkB;IAkC7B,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,SAAS;IAgMjB,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,UAAU;IA0BlB,OAAO,CAAC,gBAAgB;IA4BxB,OAAO,CAAC,eAAe;IA8CvB,OAAO,CAAC,IAAI;IA+BZ,OAAO,CAAC,iBAAiB;CAS1B"}

package/dist/gpu-stage.d.ts

@@ -0,0 +1,4 @@
+export declare const GPU_SHADER_STAGE_VERTEX = 1;
+export declare const GPU_SHADER_STAGE_FRAGMENT = 2;
+export declare const GPU_SHADER_STAGE_COMPUTE = 4;
+//# sourceMappingURL=gpu-stage.d.ts.map

package/dist/gpu-stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-stage.d.ts","sourceRoot":"","sources":["../src/gpu-stage.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,uBAAuB,IAAM,CAAC;AAC3C,eAAO,MAAM,yBAAyB,IAAM,CAAC;AAC7C,eAAO,MAAM,wBAAwB,IAAM,CAAC"}

package/dist/gpu-texture-usage.d.ts

@@ -0,0 +1,6 @@
+export declare const GPU_TEXTURE_USAGE_COPY_SRC = 1;
+export declare const GPU_TEXTURE_USAGE_COPY_DST = 2;
+export declare const GPU_TEXTURE_USAGE_TEXTURE_BINDING = 4;
+export declare const GPU_TEXTURE_USAGE_RENDER_ATTACHMENT = 16;
+export declare const GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING: number;
+//# sourceMappingURL=gpu-texture-usage.d.ts.map