@forgeax/engine-render 0.1.4 → 0.1.6

package/dist/renderer/renderer-factory.d.ts

@@ -1,289 +0,0 @@
-import type { Buffer, PipelineLayout, Result, RhiCanvasContext, RhiDevice, RhiInstance, ShaderModule } from '@forgeax/engine-rhi';
-import { RhiError } from '@forgeax/engine-rhi';
-import { type MaterialShaderManifestEntry, type MaterialShaderManifestVariant } from '@forgeax/engine-shader';
-import type { ImportTransport } from '@forgeax/engine-types';
-import { type RenderAssetResolver } from '../assets/render-asset-port';
-import { MeshSsboCapacityExceededError, MeshSsboCeilingReachedError } from '../errors/render';
-import type { Renderer, RendererOptions } from '../renderer';
-import { type RhiBackendInstrumentation } from './backend-selection';
-export { createMaterialAssetService } from './asset-service';
-export { assembleMaterialProjection } from './material/assembly';
-export { projectMaterialPipeline, routeMaterialPipeline, updateMaterialRuntimeValues, } from './material/pipeline-projection';
-/**
- * Bundler-layer injection accepted by `createRenderer` (and proxied by
- * `createApp`) as the optional third argument.
- *
- * feat-20260608-create-app-param-surface-trim / M2 / D-3: aggregates the two
- * host-injected build-tool channels:
- *
- *   - shaderManifestUrl: the URL the host's vite-plugin-shader emit step
- *     wrote `manifest.json` to. When this field is omitted (or `bundler`
- *     itself is omitted), createRenderer falls back to
- *     '/shaders/manifest.json' (D-2 q5-A) so the LO 1.1 zero-config takeoff
- *     path keeps working without explicit injection. Tests can inject via a
- *     `data:application/json,...` URL to bypass fetch.
- *
- *   - importTransport: dev-only ImportTransport forwarded verbatim to the
- *     AssetRegistry third ctor slot so DDC-miss assets can lazy-import.
- *     Absent => shipped form (a DDC miss fails fast with `asset-not-imported`).
- *
- * The interface is duplicated structurally in `@forgeax/engine-app`
- * (BundlerOptions exported from packages/app); demos consume through the app
- * package, the engine accepts via this local minimal shape so packages/runtime
- * does NOT depend on packages/app (charter P4 + reverse-coupling deny-list).
- * TypeScript structural typing makes the two interchangeable at every call
- * site (M3 forgeaxBundlerAdapter() returns the same shape).
- */
-export interface BundlerOptions {
-    readonly importTransport?: ImportTransport | undefined;
-    readonly shaderManifestUrl?: string | undefined;
-    /** Render-only projection resolver owned by the active asset owner. */
-    readonly assetResolver?: RenderAssetResolver | undefined;
-}
-/**
- * Internal "backend pack" carries the two dynamic-import-loaded entries the
- * engine consumes (rhi singleton + the optional top-level async
- * `createShaderModule`). Defining this interface in the engine layer keeps
- * the rhi-webgpu / rhi-wgpu shim surfaces structurally aligned without
- * forcing both shims to grow an identical top-level factory — when the
- * wgpu-wasm path does not expose a top-level `createShaderModule`, the
- * facade falls back to the synchronous `device.createShaderModule` path
- * inside `makeShaderDeviceAdapter` (charter proposition 9 graceful
- * degradation).
- */
-interface RhiBackendPack {
-    readonly rhi: RhiInstance & {
-        readonly acquireCanvasContext: (canvas: HTMLCanvasElement | OffscreenCanvas) => Result<RhiCanvasContext, RhiError>;
-    };
-    /** Async top-level shader module factory; rhi-webgpu exposes this; rhi-wgpu falls back to device.createShaderModule. */
-    readonly createShaderModule?: ((device: RhiDevice, desc: {
-        code: string;
-        label?: string | undefined;
-    }) => Promise<Result<ShaderModule, RhiError>>) | undefined;
-    /**
-     * D-VD2 dispatch translator (feat-20260511-rhi-spec-realign-aggressive
-     * Round 2): translates spec `GPUUncapturedErrorEvent` / `GPUDeviceLostInfo`
-     * shapes into the 17-member `RhiErrorCode` union. rhi-webgpu provides this;
-     * other backends (rhi-wgpu, explicit escape hatch) may omit — when undefined
-     * the engine falls back to a minimal device-lost-only translator inline so
-     * the AGENTS.md break-point #4 fan-out promise still holds on the lost path
-     * (charter proposition 5 consistent abstraction — both `Renderer.onError`
-     * channel members fire across all three load channels).
-     */
-    readonly translateErrorEventToRhiError?: ((event: unknown) => {
-        readonly ok: false;
-        readonly error: RhiError;
-    }) | undefined;
-    /**
-     * D-VD2 raw GPUDevice escape hatch (feat-20260511-rhi-spec-realign-aggressive
-     * Round 2): given a forgeax `RhiDevice`, returns the underlying raw
-     * `GPUDevice` so the engine can register `onuncapturederror` listener on
-     * the spec event target. Only the rhi-webgpu pack exposes this entry; the
-     * rhi-wgpu wasm pack and explicit escape hatch skip the listener
-     * registration (graceful degradation — device.lost dual-channel still
-     * fires through the forgeax RhiDevice.lost Promise on every path).
-     * @internal
-     */
-    readonly _internal_getRawDevice?: ((device: RhiDevice) => unknown | undefined) | undefined;
-    readonly instrumentation?: RhiBackendInstrumentation;
-}
-/**
- * Fold a raw module object (from a static import, dynamic import, or explicit
- * escape-hatch wrapper) into a typed `RhiBackendPack` by probing for known
- * optional fields via the `'x' in mod` pattern (existing convention).
- *
- * For the explicit escape hatch (Channel 1) where the instance IS the rhi
- * singleton, wrap it as `{ rhi: instance, ...extras }` before calling this
- * helper — the function always reads `mod.rhi` for the singleton.
- *
- * @param mod Raw module object with at least `rhi: RhiInstance & { acquireCanvasContext }`
- * @returns Typed RhiBackendPack with optional fields populated when present on mod
- * @internal — exported for unit test access (w20)
- */
-export declare function loadRhiPack(mod: Record<string, unknown>): RhiBackendPack;
-/**
- * Async factory: probes WebGPU (channel 2: rhi-webgpu, channel 3: rhi-wgpu);
- * returns a fully-initialized Renderer or throws `EngineEnvironmentError`.
- *
- * Channel priority (bug-20260526-channel2-adapter-fail-no-channel3-fallback):
- *   1. `options.rhi` → escape hatch (D-R5), verbatim use.
- *   2. `navigator.gpu` present → static `rhiWebgpu` namespace.
- *      If adapter/device/context fails → falls back to channel 3.
- *   3. Dynamic `import('@forgeax/engine-rhi-wgpu')` + wasm load.
- *   4. All fail → throw `EngineEnvironmentError` with `detail.webgpuError`
- *      + `detail.wgpuError`.
- *
- * @param canvas HTMLCanvasElement | OffscreenCanvas — render surface.
- * @param options RendererOptions — clear color / shader manifest URL /
- *                D-S1 raw-device single-point exemption / M3 `rhi` escape hatch.
- *
- * **Error propagation — three channels (D-P4 RK-04):**
- *   (a) Construction-time: this Promise rejects with `EngineEnvironmentError`
- *       whose `detail.webgpuError` is the Channel 2 `RhiError` and
- *       `detail.wgpuError` is the Channel 3 failure (when both fail).
- *   (b) Run-time pipeline build: `renderer.ready` rejects with a
- *       structured `RhiError` once the dynamic-import path is past.
- *   (c) Fan-out observability: `renderer.onError(listener)` captures the
- *       same errors as a fallback channel.
- *
- * @throws {EngineEnvironmentError} when no backend is usable.
- */
-/**
- * Per-variant PipelineLayout selector (M4.5 / D-10 option A).
- *
- * The HDRP variant (`CLUSTER_FORWARD_AVAILABLE=true` or canonical `''`
- * all-true when the shader declares the cluster axis) needs the 7-slot
- * group(2) BGL chain (`hdrpPbrPipelineLayout`); URP variants
- * (`CLUSTER_FORWARD_AVAILABLE=false` / undefined / no axis) keep the
- * 1-slot mesh-array BGL chain (`pbrPipelineLayout`).
- *
- * Returns `null` only when the URP fallback layout itself is null
- * (Camera-only / empty-manifest path). When the HDRP layout is null but
- * URP exists, the HDRP variant gracefully falls back to URP — the WGSL
- * resolved upstream by `findVariantByKey` is the URP variant in that
- * case (manifest entry with all-true definesKey === '' was registered
- * with isHdrpActive=false at boot when storage-buffer caps are absent).
- *
- * Pure function — exported for unit-test access (M4.5 / w35).
- */
-/**
- * Closed enum of pipeline-layout kinds the selector can dispatch to.
- *
- * `pbr` — standard PBR (1-entry mesh-array BGL).
- * `pbr-skin` — bug-20260611-skin-pipeline-layout: 3-entry mesh-array BGL
- *   (binding 0 meshes + bindings 1/2 current/previous palettes) for the `forgeax::pbr-skin`
- *   material shader.
- * `hdrp-pbr` — feat-20260609 HDRP cluster-forward variant (7-slot group(2)
- *   BGL substituted at slot 2).
- * `sprite-urp` — bug-20260708 M2 (c): sprite / sprite-lit shaders reuse
- *   the URP 1-slot mesh-array BGL (they don't declare
- *   CLUSTER_FORWARD_AVAILABLE) but their canonical all-true variant key
- *   `''` (`SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET`) MUST NOT trigger
- *   the `variantSet===''` → HDRP branch of the selector. Callers
- *   (`buildPipelineContext`) resolve `sprite-urp` from the sprite
- *   `materialShaderId` and pass it through; the selector short-circuits
- *   to `pbrPipelineLayout` before the HDRP check.
- *
- * AC-09 grep gate: the selector body (`selectPipelineLayoutForVariant`)
- * **MUST NOT** contain literal `'forgeax::pbr-skin'` (or any other
- * shader-id literal). The caller resolves `LayoutKind` upstream and passes
- * the structured value through (charter P4 consistent abstraction). New
- * material-shader layouts add a `LayoutKind` member + a PipelineState slot
- * + a switch arm here in one cut (charter P3 extensibility).
- */
-export type LayoutKind = 'pbr' | 'pbr-skin' | 'hdrp-pbr' | 'sprite-urp' | 'unlit-urp';
-/**
- * Return every device-capability HDRP PBR variant that needs a lazy module
- * label seeded during renderer boot. Color availability is intentionally not
- * filtered: colored and no-color meshes use distinct composed WGSL modules.
- */
-export declare function selectHdrpPbrPrewarmVariants(manifestEntry: MaterialShaderManifestEntry | undefined, storageBufferCapable: boolean): readonly MaterialShaderManifestVariant[];
-/**
- * Select the PBR variant that matches a fallback mesh with no COLOR_0 input.
- * Unknown/custom material IDs may still use the legacy PBR fallback, so that
- * path must obey the same geometry-owned vertex-color axis as registered PBR.
- */
-export declare function selectNoColorPbrVariant(manifestEntry: MaterialShaderManifestEntry | undefined, storageBufferCapable: boolean, variantSet: string | undefined): MaterialShaderManifestVariant | undefined;
-export type MaterialShaderBindingContract = 'group-0' | 'group-0-resource' | 'view-only' | 'view-with-resource' | 'render-material';
-export type MaterialShaderVertexInputContract = 'none' | 'render-material';
-export declare function resolveMaterialShaderBindingContract(source: string): MaterialShaderBindingContract;
-export declare function resolveMaterialShaderVertexInputContract(source: string): MaterialShaderVertexInputContract;
-export declare function selectPipelineLayoutForVariant(state: {
-    readonly pbrPipelineLayout: PipelineLayout | null;
-    readonly hdrpPbrPipelineLayout: PipelineLayout | null;
-    readonly pbrSkinPipelineLayout: PipelineLayout | null;
-} | null, variantSet: string | undefined, layoutKind?: LayoutKind): PipelineLayout | null;
-/**
- * Resolve a requested material variant against the actual backend capabilities.
- * Record callers use the native-capability request; the backend-owned axes
- * must be rewritten before the request reaches shader lookup and PSO layout
- * selection.
- */
-export declare function resolveMaterialShaderVariantSet(requestedVariantSet: string | undefined, variants: ReadonlyArray<{
-    readonly defines: Readonly<Record<string, boolean>>;
-}>, backendKind: RhiDevice['caps']['backendKind'], storageBuffer: boolean): string | undefined;
-export declare function createRenderer(canvas: unknown, options?: RendererOptions, bundler?: BundlerOptions): Promise<Renderer>;
-/** @internal Exact producer-owned probe shader, exported for Dawn falsifiers. */
-export declare const SHADOW_PROBE_WGSL = "\nstruct CsmLsm {\n  m0 : mat4x4<f32>,\n  m1 : mat4x4<f32>,\n  m2 : mat4x4<f32>,\n  m3 : mat4x4<f32>,\n  view : mat4x4<f32>,\n  splitPlanes : vec4<f32>,\n  cascadeCount : u32,\n  pcfKernelSize : u32,\n  cascadeBlend : f32,\n  probePadC : u32,\n};\nstruct WorldPositions { p : array<vec4<f32>, 64> };\n\n@group(0) @binding(0) var<uniform> lsm : CsmLsm;\n@group(0) @binding(1) var<storage, read> worldPositions : WorldPositions;\n@group(0) @binding(2) var shadowMap : texture_depth_2d;\n@group(0) @binding(3) var shadowSampler : sampler_comparison;\n\nstruct VsOut {\n  @builtin(position) clip : vec4<f32>,\n  @location(0) @interpolate(flat) probeIdx : u32,\n};\n\n@vertex fn vs_main(@builtin(vertex_index) v : u32, @builtin(instance_index) i : u32) -> VsOut {\n  let n = f32(64);\n  let xL = (f32(i) / n) * 2.0 - 1.0;\n  let xR = (f32(i + 1u) / n) * 2.0 - 1.0;\n  var x : f32 = xL;\n  var y : f32 = -1.0;\n  switch (v) {\n    case 0u: { x = xL; y = -1.0; }\n    case 1u: { x = xR; y = -1.0; }\n    case 2u: { x = xR; y =  1.0; }\n    case 3u: { x = xL; y = -1.0; }\n    case 4u: { x = xR; y =  1.0; }\n    default: { x = xL; y =  1.0; }\n  }\n  var out : VsOut;\n  out.clip = vec4<f32>(x, y, 0.0, 1.0);\n  out.probeIdx = i;\n  return out;\n}\n\nfn _probeCascadeMatrix(layer : u32) -> mat4x4<f32> {\n  switch (layer) {\n    case 0u: { return lsm.m0; }\n    case 1u: { return lsm.m1; }\n    case 2u: { return lsm.m2; }\n    default: { return lsm.m3; }\n  }\n}\n\nfn _pickCascadeLayer(viewDepth : f32, count : u32) -> u32 {\n  var layer : u32 = count - 1u;\n  for (var i : u32 = 0u; i < count - 1u; i = i + 1u) {\n    if (viewDepth < lsm.splitPlanes[i]) {\n      layer = i;\n      break;\n    }\n  }\n  return layer;\n}\n\nfn _sampleProbeCascade(\n  worldPosition : vec3<f32>,\n  layer : u32,\n  count : u32,\n  bias : f32,\n) -> vec3<f32> {\n  let columns : u32 = select(2u, 1u, count <= 1u);\n  let rows : u32 = (count + columns - 1u) / columns;\n  let grid = vec2<u32>(columns, rows);\n  let tileScale = vec2<f32>(1.0) / vec2<f32>(grid);\n  let m = _probeCascadeMatrix(layer);\n  let lightClip = m * vec4<f32>(worldPosition, 1.0);\n  let projCoords = lightClip.xyz / lightClip.w;\n  let tileUv = vec2<f32>(projCoords.x * 0.5 + 0.5, -projCoords.y * 0.5 + 0.5);\n  let tile = vec2<u32>(layer % grid.x, layer / grid.x);\n  let tileOrigin = vec2<f32>(tile) / vec2<f32>(grid);\n  let uv = tileUv * tileScale + tileOrigin;\n  let currentDepth = projCoords.z;\n  var sampledDepth : f32 = 1.0;\n  var shadow : f32 = 1.0;\n  // The host computes max(normalBias * (1 - N.L), depthBias) from the same\n  // DirectionalLight snapshot and puts it in the input w lane. This keeps\n  // the probe's receiver comparison tied to the exact surface normal used by\n  // the evidence caller instead of inventing a fixed floor bias.\n  let adjustedDepth : f32 = currentDepth - bias;\n  // Keep this check in cascade-local coordinates. An atlas-space check would\n  // accept an out-of-cascade receiver that still lands inside the atlas,\n  // clamp it to a tile edge, and report a false shadow. The production\n  // receiver uses the same local tileUv contract.\n  if (tileUv.x >= 0.0 && tileUv.x <= 1.0 && tileUv.y >= 0.0 && tileUv.y <= 1.0 && currentDepth <= 1.0) {\n    let texelDims = vec2<f32>(textureDimensions(shadowMap, 0));\n    let texel = vec2<f32>(1.0 / texelDims.x, 1.0 / texelDims.y);\n    let tileLo = tileOrigin + texel;\n    let tileHi = tileOrigin + tileScale - texel;\n    let baseCoord = vec2<i32>(uv * texelDims);\n    let maxCoord = vec2<i32>(texelDims) - vec2<i32>(1, 1);\n    let centerCoord = clamp(baseCoord, vec2<i32>(0, 0), maxCoord);\n    sampledDepth = textureLoad(shadowMap, centerCoord, 0);\n    let requestedKernel = clamp(lsm.pcfKernelSize, 1u, 5u);\n    let kernel = select(select(5u, 3u, requestedKernel <= 4u), 1u, requestedKernel == 1u);\n    if (kernel == 1u) {\n      shadow = textureSampleCompareLevel(shadowMap, shadowSampler, clamp(uv, tileLo, tileHi), adjustedDepth);\n    } else if (kernel == 3u) {\n      // Keep the same bilinear 3x3 optimization as lighting-directional.wgsl.\n      // The edge path deliberately falls back to clamped nine-tap comparisons.\n      let interior = all(uv >= tileLo + texel) && all(uv <= tileHi - texel);\n      if (interior) {\n        let pcfFraction = fract(uv / texel - vec2<f32>(0.5));\n        let loWeight = vec2<f32>(2.0) - pcfFraction;\n        let hiWeight = vec2<f32>(1.0) + pcfFraction;\n        let loOffset = vec2<f32>(-1.0) - pcfFraction + vec2<f32>(1.0) / loWeight;\n        let hiOffset = vec2<f32>(1.0) - pcfFraction + pcfFraction / hiWeight;\n        let litLoLo = textureSampleCompareLevel(\n          shadowMap, shadowSampler, uv + vec2<f32>(loOffset.x, loOffset.y) * texel, adjustedDepth,\n        );\n        let litHiLo = textureSampleCompareLevel(\n          shadowMap, shadowSampler, uv + vec2<f32>(hiOffset.x, loOffset.y) * texel, adjustedDepth,\n        );\n        let litLoHi = textureSampleCompareLevel(\n          shadowMap, shadowSampler, uv + vec2<f32>(loOffset.x, hiOffset.y) * texel, adjustedDepth,\n        );\n        let litHiHi = textureSampleCompareLevel(\n          shadowMap, shadowSampler, uv + vec2<f32>(hiOffset.x, hiOffset.y) * texel, adjustedDepth,\n        );\n        shadow = (\n          litLoLo * loWeight.x * loWeight.y +\n          litHiLo * hiWeight.x * loWeight.y +\n          litLoHi * loWeight.x * hiWeight.y +\n          litHiHi * hiWeight.x * hiWeight.y\n        ) / 9.0;\n      } else {\n        var blocked : f32 = 0.0;\n        for (var x = -1; x <= 1; x++) {\n          for (var y = -1; y <= 1; y++) {\n            let offsetUv = clamp(uv + vec2<f32>(f32(x), f32(y)) * texel, tileLo, tileHi);\n            let lit = textureSampleCompareLevel(shadowMap, shadowSampler, offsetUv, adjustedDepth);\n            blocked = blocked + (1.0 - lit);\n          }\n        }\n        shadow = 1.0 - blocked / 9.0;\n      }\n    } else {\n      var blocked : f32 = 0.0;\n      for (var x = -2; x <= 2; x++) {\n        for (var y = -2; y <= 2; y++) {\n          let offsetUv = clamp(uv + vec2<f32>(f32(x), f32(y)) * texel, tileLo, tileHi);\n          let lit = textureSampleCompareLevel(shadowMap, shadowSampler, offsetUv, adjustedDepth);\n          blocked = blocked + (1.0 - lit);\n        }\n      }\n      shadow = 1.0 - blocked / 25.0;\n    }\n  }\n  return vec3<f32>(shadow, sampledDepth, currentDepth);\n}\n\n@fragment fn fs_main(in : VsOut) -> @location(0) vec4<f32> {\n  let p4 = worldPositions.p[in.probeIdx];\n  let count = max(lsm.cascadeCount, 1u);\n  let viewPosition = lsm.view * vec4<f32>(p4.xyz, 1.0);\n  let viewDepth = -viewPosition.z;\n  // Match the production shadowDistance early-out. A receiver past the last\n  // split is fully lit instead of being assigned to the last atlas tile.\n  if (viewDepth > lsm.splitPlanes[count - 1u]) {\n    return vec4<f32>(1.0, 1.0, -1.0, 1.0);\n  }\n  let selectedLayer = _pickCascadeLayer(viewDepth, count);\n  let current = _sampleProbeCascade(p4.xyz, selectedLayer, count, p4.w);\n  var shadow = current.x;\n  if (lsm.cascadeBlend > 0.0 && selectedLayer + 1u < count) {\n    let split = lsm.splitPlanes[selectedLayer];\n    let blendWidth = split * lsm.cascadeBlend;\n    if (blendWidth > 0.0) {\n      let distanceToSplit = split - viewDepth;\n      let t = clamp(1.0 - distanceToSplit / blendWidth, 0.0, 1.0);\n      if (t > 0.0) {\n        let next = _sampleProbeCascade(p4.xyz, selectedLayer + 1u, count, p4.w);\n        shadow = mix(current.x, next.x, t);\n      }\n    }\n  }\n  return vec4<f32>(shadow, current.y, f32(selectedLayer), current.z);\n}\n";
-/**
- * Derive a usable storage-buffer ceiling from device limits.
- *
- * Mirrors the `SKIN_PALETTE_MAX_BINDING_BYTES` 0/undefined floor pattern
- * (createRenderer.ts:4070-4073): when `maxStorageBufferBindingSize` is 0 or
- * undefined (WebKit `downlevel_webgl2_defaults`), climb the fallback chain —
- * `maxBufferSize` → `maxUniformBufferBindingSize` → WebGPU spec floor
- * 134217728 (128 MiB).
- *
- * Pure helper — no device dependency, directly testable in node.
- */
-export declare function deriveStorageBufferCeiling(limits: Readonly<{
-    maxStorageBufferBindingSize?: number;
-    maxBufferSize?: number;
-    maxUniformBufferBindingSize?: number;
-}>): number;
-/**
- * Mesh + material buffer wrapper carrying the inner `Buffer` handle plus
- * the byte-size at the time of allocation. The wrapper-object identity is
- * stable across grow events — only `.buffer` and `.sizeInBytes` are mutated
- * in place — so `PipelineState.meshStorageBuffer` / `materialUniformBuffer`
- * fields capture the wrapper once and survive grow events without a re-bind
- * cycle through the public Renderer surface (research §F8 R1).
- */
-export interface MeshSsboBufferWrapper {
-    buffer: Buffer;
-    sizeInBytes: number;
-}
-/** Closure-local grow state surfaced for spy assertions in unit tests. */
-export interface MeshSsboState {
-    slotCount: number;
-    mesh: MeshSsboBufferWrapper;
-    material: MeshSsboBufferWrapper;
-}
-/** `growMeshSsbo` return shape (D-5: Result-like, never throws). */
-export type MeshSsboGrowResult = {
-    readonly ok: true;
-} | {
-    readonly ok: false;
-    readonly code: 'mesh-ssbo-ceiling-reached' | 'mesh-ssbo-capacity-exceeded';
-    /** Pre-grow slotCount — the caller can render up to this many slots (degraded subset). */
-    readonly degradedToSlotCount: number;
-};
-/** Minimal device surface the grow controller needs (mocked in unit tests). */
-export interface MeshSsboGrowDevice {
-    readonly limits: {
-        readonly maxStorageBufferBindingSize: number;
-    };
-    readonly createBuffer: (descriptor: {
-        readonly label?: string;
-        readonly size: number;
-        readonly usage: number;
-        readonly mappedAtCreation?: boolean;
-    }) => Buffer;
-}
-/** Minimal error-registry surface (just `fire` — `RhiErrorListenerRegistry` matches). */
-export interface MeshSsboGrowErrorRegistry {
-    fire: (e: MeshSsboCeilingReachedError | MeshSsboCapacityExceededError) => void;
-}
-export interface MeshSsboGrowControllerInit {
-    readonly device: MeshSsboGrowDevice;
-    readonly errorRegistry: MeshSsboGrowErrorRegistry;
-    readonly initialSlotCount: number;
-    readonly perEntityStride: number;
-    readonly meshUsage: number;
-    readonly materialUsage: number;
-}
-export interface MeshSsboGrowController {
-    readonly state: MeshSsboState;
-    /** Allocate the initial mesh + material buffer pair at `initialSlotCount`. */
-    readonly initialBuild: () => void;
-    /** Grow to satisfy `neededSlots`; idempotent + ceiling-aware. */
-    readonly growMeshSsbo: (neededSlots: number) => MeshSsboGrowResult;
-}
-/**
- * Build a closure-scoped mesh-SSBO grow controller. Module-scope so unit
- * tests (`__tests__/mesh-ssbo-grow.test.ts`) can construct it with a fake
- * device + spy errorRegistry without spinning up the full WebGPU renderer
- * (charter F2 minimal surface — the controller is the testable seam).
- */
-export declare function createMeshSsboGrowController(init: MeshSsboGrowControllerInit): MeshSsboGrowController;
-//# sourceMappingURL=renderer-factory.d.ts.map

package/dist/renderer/renderer-factory.d.ts.map

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