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

package/dist/record/mesh-ssbo.d.ts

@@ -0,0 +1,446 @@
+import { type BindGroup, type Buffer, RhiError, type RhiQueue } from '@forgeax/engine-rhi';
+import type { DispatchEntry } from '../render-system-extract';
+import { type TransparentSortConfig } from '../systems/transparent-sort-config';
+import type { ValidatedRenderable } from './frame-snapshot';
+/**
+ * Stride between per-renderable `entity_world` mat4 slots inside the
+ * shared `pipelineState.meshStorageBuffer`. The 256-byte alignment is
+ * required because the storage buffer is bound with
+ * `hasDynamicOffset: true` and WebGPU spec
+ * `minStorageBufferOffsetAlignment` defaults to 256.
+ */
+export declare const MESH_PER_ENTITY_STRIDE = 256;
+export declare const MESH_SSBO_BYTES = 192;
+export declare const MESH_UBO_FULL_ARRAY_BYTES: number;
+export declare const INSTANCE_UBO_FULL_ARRAY_BYTES: number;
+export declare const MAX_UNIFORM_INSTANCES = 128;
+/** The storage-backed InstanceData layout is current + previous mat4. */
+export declare const INSTANCE_STORAGE_STRIDE_FLOATS = 32;
+/**
+ * Project the ECS transform snapshot into the storage-backed InstanceData
+ * layout. The extract contract carries one current mat4 per instance; until
+ * the ECS snapshot owns a previous-instance column, current is the honest
+ * previous value as well. Uniform-backed variants keep the compact 16-float
+ * payload and do not use this projection.
+ */
+export declare function packInstanceStorageBuffer(transforms: Float32Array): Float32Array;
+/**
+ * M3 / w12: extracts the underlying GPU resource object from a bind
+ * group entry descriptor. Returns the raw object reference (Buffer,
+ * TextureView, or Sampler) usable as a WeakMap chain key.
+ */
+export declare function extractEntryResourceHandle(entry: {
+    resource: {
+        kind: string;
+        value: unknown;
+    };
+}): object;
+/**
+ * feat-20260622-handle-to-id-allocator-elimination M2 / w7: walks a nested
+ * WeakMap chain to find or create a BindGroup leaf. Each handle in the
+ * `handles` array is a chain node; the final leaf is a Map<string, BindGroup>
+ * keyed by `variant` (D-2). Chain keys are always object references, never
+ * numeric ids — GC reclaims entries for dead handles automatically.
+ *
+ * On cache hit returns the cached BindGroup. On miss calls `factory`,
+ * bumps `bindGroupCounts.createBindGroup`, stores the result at the leaf,
+ * and returns it. Hit/miss accounting is observable via `bindGroupCounts`
+ * (D-8: the skin probe reads `counts.createBindGroup` delta).
+ */
+export declare function getOrCreateFromChain(root: WeakMap<object, unknown>, handles: readonly object[], variant: string, factory: () => BindGroup, counts: {
+    createBindGroup: number;
+    keys: string[];
+}): BindGroup;
+/**
+ * feat-20260622-handle-to-id-allocator-elimination M2 / w8: per-entity bind
+ * group lookup-or-create helper (D-2). Two-step lookup: outer Map.get(outerKey)
+ * finds or lazily creates an inner WeakMap chain, then delegates to
+ * `getOrCreateFromChain` for the chain walk. outerKey is `string | number`
+ * to cover both per-entity (number entityKey) and material-shared
+ * (string shaderId) caches (D-1 / OQ-1).
+ */
+export declare function getOrCreatePerEntity(outerMap: Map<string | number, WeakMap<object, unknown>>, outerKey: string | number, handles: readonly object[], variant: string, factory: () => BindGroup, counts: {
+    createBindGroup: number;
+    keys: string[];
+}): BindGroup;
+/**
+ * feat-20260622-handle-to-id-allocator-elimination M2 / w8: evicts per-entity
+ * cache entries whose entityKey is not in the validated set. Works on
+ * Map<entityKey, WeakMap<handle, BindGroup>> by iterating the outer Map keys
+ * and deleting entries for which validatedEntityKeys.has(ek) is false.
+ * No string parsing, no Number / Number.isNaN — the entityKey is already a
+ * number (D-1 / RD4).
+ *
+ * @internal — exported for unit test access (AC-08)
+ */
+export declare function cleanPerEntityCache(cache: Map<number, WeakMap<object, unknown>>, validatedEntityKeys: Set<number>): void;
+/**
+ * feat-20260608-mesh-ssbo-dynamic-grow-l1-lift-1024-entity-cap M3 / T-M3-04:
+ * record-stage entry-point hook to the closure-scoped mesh-SSBO grow
+ * controller (createRenderer.ts). Called once per frame, after
+ * `validatedOrdered` has been finalised and BEFORE the first per-entity
+ * `queue.writeBuffer`. Returns Result-like (never throws — D-5):
+ *
+ *  - `{ ok: true }`       — slotCount already covers `neededSlots` (idempotent
+ *                           short-circuit), or the controller successfully grew
+ *                           in this call. Caller proceeds with the frame.
+ *  - `{ ok: false, code, degradedToSlotCount }` — controller hit ceiling /
+ *                           capacity and ALREADY fired the structured error
+ *                           via errorRegistry.  Caller truncates the draw
+ *                           list to the largest complete entity prefix that
+ *                           fits within `degradedToSlotCount` slots (graceful
+ *                           degradation per plan-strategy D-2): renders the
+ *                           subset that fits, discards overflow, no black
+ *                           frame.
+ *
+ * This helper does NOT re-fire on `ok:false` — the controller is the single
+ * fire site (createRenderer.ts grow factory), so callers see exactly one
+ * structured error per ceiling event (charter P3 explicit failure: no
+ * double-fire).
+ *
+ * Dev-mode visibility: when grow actually grew (slotCount transition) AND
+ * `import.meta.env?.DEV` is truthy, a single `console.info('[mesh-ssbo] ...')`
+ * line reports the before / after / requested counts. The optional-chain
+ * keeps non-vite envs (dawn-node smoke, plain tsup tests) silent —
+ * `import.meta.env` is undefined there, the chain short-circuits to
+ * undefined, the if-guard is falsy (AC-11 + plan-strategy §2.D-3).
+ *
+ * Bind-group cache invalidation is automatic: on grow, the controller
+ * mutates `meshSsboState.mesh.buffer` / `.material.buffer` in place
+ * (wrapper-object identity preserved, inner buffer replaced — research §F8).
+ * Downstream the fresh inner buffer object is a new WeakMap chain key, so
+ * `getOrCreateFromChain` misses and rebuilds the BindGroup on the next frame
+ * (AC-07; T-M3-03 (a) test).
+ *
+ * @internal — exported for unit-test access (`mesh-ssbo-grow.test.ts`
+ * T-M3-01 / T-M3-02 / T-M3-03 cover idempotency, ceiling, dev info).
+ */
+export declare function ensureMeshSsboCapacity(internals: {
+    readonly growMeshSsbo?: ((neededSlots: number) => {
+        readonly ok: true;
+    } | {
+        readonly ok: false;
+        readonly code: 'mesh-ssbo-ceiling-reached' | 'mesh-ssbo-capacity-exceeded';
+        readonly degradedToSlotCount: number;
+    }) | undefined;
+    readonly meshSsboState?: {
+        readonly slotCount: number;
+    } | undefined;
+}, neededSlots: number): {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly code: 'mesh-ssbo-ceiling-reached' | 'mesh-ssbo-capacity-exceeded';
+    readonly degradedToSlotCount: number;
+};
+/**
+ * @internal — test-only injection seam for `ensureMeshSsboCapacity`'s
+ * dev-mode gate. Pass `undefined` to restore the production probe
+ * (`isMeshSsboDevMode`). Production code paths NEVER call this.
+ */
+export declare function setMeshSsboDevModeProbeForTests(probe: (() => boolean) | undefined): void;
+/**
+ * Dev-mode probe for `ensureMeshSsboCapacity`'s console.info gate
+ * (plan-strategy §2.D-3 + AC-11). True when the build is in dev mode:
+ *   - `import.meta.env?.DEV` is truthy (vite dev / vitest), OR
+ *   - `process.env.NODE_ENV !== 'production'` (esbuild / tsup / dawn-node).
+ * Optional-chain keeps it safe in non-vite ESM envs that never inject
+ * `import.meta.env` (the chain short-circuits to undefined → falsy).
+ *
+ * Vite's `import.meta.env.DEV` is constant-folded at build time, so the
+ * production bundle dead-code-strips the entire branch even though the
+ * test fall-through reads `process.env.NODE_ENV`.
+ *
+ * @internal — exported as a function (not a const) so unit tests can
+ * `vi.spyOn(...).mockReturnValue(false)` to exercise the dev=false path
+ * (vitest 4.x cannot toggle `import.meta.env.DEV` at runtime — it is
+ * compile-time-frozen by the vite transform).
+ */
+export declare function isMeshSsboDevMode(): boolean;
+/**
+ * feat-20260704 M3/w21: per-renderable `entity_world` upload (batched). All N
+ * mat4+normalMatrix slots are assembled into a single contiguous scratch
+ * buffer, then flushed as one `writeBuffer` call instead of N individual
+ * calls. Extracted verbatim from `recordFrame` (frame.ts) — the module-scoped
+ * `_meshSsboScratch` let and its only reassignment site now co-locate in this
+ * file so the two mesh-SSBO module lets live together (AC-06).
+ *
+ * feat-20260518 M3 / w14 (AC-08): each 256-byte slot carries a 16-float mat4
+ * at [0..64B) and a 48-byte mat3 normalMatrix at [64..112B) (3 vec4 columns;
+ * padding at indices 19/23/27 stays 0). The mat3 =
+ * transpose(invert(mat3(worldFromLocal))) for correct normal transform under
+ * non-uniform scale.
+ *
+ * feat-20260622-chunk-gpu-instancing-sprite-tilemap M1 / w4-record-swap (D-1):
+ * fold-bucket heads write identity into their slot; the fold path assembles
+ * per-instance world matrices into the @group(3) instances buffer instead
+ * (sprite/unlit shaders ignore normals; AC-01/AC-02).
+ *
+ * @internal
+ */
+export declare function uploadMeshSsboBatch(queue: RhiQueue, meshStorageBuffer: {
+    readonly buffer: Buffer;
+}, validatedOrdered: readonly ValidatedRenderable[], foldDispatchPlan: FoldDispatchPlan | null): void;
+/**
+ * Per-bucket descriptor produced by {@link foldDispatchBuckets}.
+ *
+ * One bucket = one fold-eligible run of consecutive DispatchEntry whose
+ * `(layer, sortKey, materialHandle)` triple is equal. Singleton buckets
+ * (bucketSize=1) appear when the mode bypasses fold (D-5 mode 2/3) or
+ * when consecutive entries differ in one of the three keys.
+ *
+ * Fields:
+ *   - `entries` — original DispatchEntry slice for this bucket (preserves
+ *     the input ordering); the consumer uses these to look up per-entity
+ *     material BG handles, mesh handles (which are bucket-uniform by
+ *     construction since materialHandle key is included), etc.
+ *   - `bucketSize` — `entries.length`. Surfaced as a top-level field so
+ *     the consumer can pass it directly as `instanceCount` to
+ *     `drawIndexed`.
+ *   - `transforms` — assembled Float32Array of bucketSize world mat4s,
+ *     stride=16 floats per instance, column-major. Suitable for direct
+ *     `device.queue.writeBuffer` into an instance buffer used at @group(3).
+ *   - `materialHandle` / `layer` / `sortKey` — the three-tuple key for this
+ *     bucket. `sortKey` is mode-dependent: posZ (world[14]) for mode 0
+ *     (LAYER_Z), posY (world[13]) for mode 1 (LAYER_Y). Consumed by the
+ *     dispatch loop for bind-group selection / sort-stability invariants.
+ */
+export interface FoldBucket {
+    readonly entries: readonly DispatchEntry[];
+    readonly bucketSize: number;
+    readonly transforms: Float32Array;
+    readonly materialHandle: number;
+    readonly layer: number;
+    readonly sortKey: number;
+}
+/**
+ * Minimal renderable shape consumed by the helper. The real
+ * `RenderableSnapshot` carries many more fields; the helper only reads
+ * `transform.world` (a Float32Array of 16 column-major floats) and
+ * `material.transparent` (the LDR-split-sub-pass fold gate, see PR #502
+ * fix + feat-20260625 R2 fix-up: geometry-pass entities — non-transparent
+ * materials — MUST stay singleton because the sprite-pass dispatch path
+ * that consumes `headBuckets` does not run for them; folding them would
+ * overwrite their mesh-SSBO slot with identity and collapse 3D geometry
+ * to origin).
+ *
+ * Production callers pass `RenderableSnapshot[]` straight through —
+ * `RenderableSnapshot.material.transparent` is `boolean | undefined`
+ * (derived by the extract stage from `passes[0].renderState.blend !==
+ * undefined`, the post-feat-20260626-collapse SSOT; see
+ * `MaterialSnapshot.transparent`), structurally compatible with this
+ * minimal shape. The gate read inside the helper uses `=== true` /
+ * `!== true` so both `false` and `undefined` enter the singleton branch.
+ *
+ * feat-20260625-refactor-sprite-as-transparent-mesh R2 fix-up: gate
+ * migrated from `shadingModel === 'sprite'` (the union member was
+ * removed in M3 / w15) to `transparent === true` (the new SSOT for
+ * "routes through the LDR split sub-pass" — same predicate the
+ * `splitLdrSprite` filter at render-system-record.ts:4826/5612 uses).
+ */
+export interface FoldRenderableLike {
+    readonly transform: {
+        readonly world: Float32Array;
+    };
+    readonly material: {
+        readonly transparent?: boolean | undefined;
+    };
+}
+/**
+ * Linear-scan fold operator (plan-strategy D-1).
+ *
+ * Walks `orderedEntries` (must be transparent-sort-ordered when mode=0;
+ * the helper trusts the input ordering and only checks adjacent equality
+ * — non-consecutive entries with equal keys are NOT merged, preserving
+ * stable-sort semantics).
+ *
+ * @param orderedEntries — DispatchEntry[] in transparent-sort order. Empty
+ *   array yields zero buckets (defensive empty-bucket suppression).
+ * @param mode — current `TransparentSortConfig.mode`. Modes 0 (LAYER_Z)
+ *   and 1 (LAYER_Y) enable fold using the appropriate sort-axis coordinate
+ *   (posZ / posY respectively). Modes 2 and 3 produce singleton buckets
+ *   per entry (D-5 bypass).
+ * @param renderables — parallel snapshot array indexed by
+ *   `DispatchEntry.renderableIndex`. The helper reads `transform.world`
+ *   to (a) extract the sort-axis coordinate for the bucket key (posZ
+ *   world[14] for mode 0, posY world[13] for mode 1), and (b) copy 16
+ *   floats per entry into the assembled transforms buffer. Out-of-range /
+ *   missing renderables defensively contribute a zero mat4 slot.
+ * @returns Array of FoldBucket descriptors in input order.
+ */
+export declare function foldDispatchBuckets(orderedEntries: readonly DispatchEntry[], mode: TransparentSortConfig['mode'], renderables: readonly FoldRenderableLike[]): readonly FoldBucket[];
+/**
+ * Per-validatedOrdered-index fold metadata consumed by the record-stage
+ * dispatch loops. Built from {@link foldDispatchBuckets} output by
+ * {@link buildFoldDispatchPlan}; see plan-strategy §3.2 sequence diagram.
+ *
+ * Field semantics (consumer contract, w4-record-swap):
+ *   - `headBuckets[i]` is non-null when validatedOrdered index `i` is the
+ *     **bucket head** of a non-singleton (bucketSize > 1) fold bucket. The
+ *     dispatch loop overrides @group(3) instances BG to a transient buffer
+ *     holding `bucket.transforms` and emits `drawIndexed(idxCount,
+ *     bucket.bucketSize)` instead of per-entity drawIndexed.
+ *   - `skipIndices.has(i)` is true when index `i` is a non-head member of
+ *     a non-singleton fold bucket; the dispatch loop emits `continue`.
+ *   - Singleton buckets (bucketSize === 1) leave both arrays empty for
+ *     that index — dispatch falls through to the existing per-entity path
+ *     byte-identically (mode-bypass / non-foldable head / fold-disabled).
+ *
+ * Note: the maps are keyed on `validatedOrderedIndex`, NOT
+ * `renderableIndex`. The dispatch loops iterate `validatedOrdered` by
+ * positional index `i`, and that index drives mesh SSBO slot offset
+ * (`i * MESH_PER_ENTITY_STRIDE`), material UBO slot, and per-entity bind
+ * group cache keys, all of which the swap must coordinate with.
+ */
+export interface FoldDispatchPlan {
+    readonly headBuckets: ReadonlyMap<number, FoldBucket>;
+    readonly skipIndices: ReadonlySet<number>;
+    readonly foldedBucketCount: number;
+}
+/**
+ * Build the per-validatedOrdered-index fold metadata from a
+ * {@link foldDispatchBuckets} output.
+ *
+ * @param buckets — output of {@link foldDispatchBuckets}; ordered by
+ *   transparent-sort scan order.
+ * @param renderableIndexToValidatedIndex — map from `DispatchEntry.renderableIndex`
+ *   to the validated-ordered index `i` (the loop counter the dispatch
+ *   loops use). Caller builds this once per frame from `validatedOrdered`.
+ * @returns FoldDispatchPlan keyed by validated-ordered index.
+ *
+ * Empty / all-singleton input yields empty maps + `foldedBucketCount=0`,
+ * which the dispatch loops treat as "no fold this frame" — byte-identical
+ * to pre-feat behavior.
+ */
+export declare function buildFoldDispatchPlan(buckets: readonly FoldBucket[], renderableIndexToValidatedIndex: ReadonlyMap<number, number>): FoldDispatchPlan;
+/**
+ * WebGL2 uniform-fallback per-bucket instance-count ceiling
+ * (feat-20260622-chunk-gpu-instancing-sprite-tilemap M2 / D-2 +
+ * research N-1).
+ *
+ * 128 instances * 64 B/mat4 stride = 8192 B, comfortably below the WebGL2
+ * minimum 16384 B UBO size, leaving headroom for the per-frame material
+ * UBO slice. Locked at the type level via `RhiInstancingExceedsUniformCapDetail.limit`
+ * (literal 128) — a future cap change would be a major evolution, not a
+ * runtime knob.
+ */
+export declare const FOLD_UNIFORM_INSTANCE_CAP = 128;
+/**
+ * Minimal `RhiCapabilities` shape consumed by the cap-fallback helper.
+ *
+ * The real `RhiDevice.caps` carries many feature flags; the helper only
+ * reads `storageBuffer` (the WebGL2 / WebGPU split signal — true on
+ * WebGPU + dawn / wgpu native paths, false on the WebGL2 uniform-only
+ * fallback path). Mirrors the field name on the production `RhiCaps`
+ * type so the dispatch site can pass `runtime.device.caps` straight in.
+ */
+export interface FoldCapsLike {
+    readonly storageBuffer: boolean;
+}
+/**
+ * Decision POD returned by {@link evaluateFoldBucketUniformCap}.
+ *
+ * Fields:
+ *   - `fallback` — `true` when the bucket must NOT fold and the dispatch
+ *     site must route it through the per-entity drawIndexed exit (the
+ *     same exit the mode-gate bypass uses, plan-strategy D-9 "shared
+ *     fallback exit"). `false` when the bucket can fold normally.
+ *   - `error` — the structured RhiError to fire alongside the fallback.
+ *     Always populated when `fallback === true`; always `undefined` when
+ *     `fallback === false` (charter proposition 4: explicit failure on
+ *     the failure path; silent success on the success path).
+ *
+ * Caller contract: when `fallback === true`, fire the error via the
+ * runtime error registry AND draw the bucket's entries individually
+ * (each as a 1-instance drawIndexed). Skipping the fallback while still
+ * firing the error would leave the frame visually wrong (uniform buffer
+ * write would clip at 128 entries).
+ */
+export interface FoldBucketCapDecision {
+    readonly fallback: boolean;
+    readonly error: RhiError | undefined;
+}
+/**
+ * Decide whether a fold bucket fits the WebGL2 uniform-fallback per-bucket
+ * instance-count ceiling, returning the structured RhiError + fallback
+ * intent the dispatch site needs to act on
+ * (feat-20260622-chunk-gpu-instancing-sprite-tilemap M2 / w11 +
+ * plan-strategy D-2 + D-9 + AC-05).
+ *
+ * Decision matrix:
+ *
+ * | caps.storageBuffer | bucketSize  | fallback | error |
+ * |:--|:--|:--|:--|
+ * | `true`             | every       | `false`  | `undefined` (WebGPU has no per-binding instance cap inside the storage buffer's `maxStorageBufferBindingSize`; the byte-cap path emits `'limit-exceeded'` separately) |
+ * | `false`            | `<= 128`    | `false`  | `undefined` (fits inside the WebGL2 minimum 16384 B UBO with headroom) |
+ * | `false`            | `> 128`     | `true`   | `RhiError({ code: 'instancing-exceeds-uniform-cap', detail: { requested, limit: 128, scope } })` |
+ *
+ * Singleton buckets (`bucketSize === 1`) always pass — they are the
+ * mode-gate bypass output and never need the cap check (the cap is
+ * about *folded* bucket arity, not about per-entity per-frame work).
+ *
+ * @param bucket — the FoldBucket whose `bucketSize` is the sole input
+ *   (instance count = bucketSize); other fields are not consulted.
+ * @param caps — the runtime's RHI capability flags
+ *   (`runtime.device.caps`); only `storageBuffer` is read.
+ * @param scope — closed `'sprite' | 'tilemap-chunk'` discriminator the
+ *   dispatch site picks based on the call site (sprite-pass primary
+ *   sprite entry vs tilemap-chunk-derived entry). Surfaced verbatim on
+ *   the error's `.detail.scope` so AI users can branch their recovery
+ *   on which dispatch site overflowed.
+ * @returns a {@link FoldBucketCapDecision} POD; never throws.
+ */
+export declare function evaluateFoldBucketUniformCap(bucket: FoldBucket, caps: FoldCapsLike, scope: 'sprite' | 'tilemap-chunk'): FoldBucketCapDecision;
+/**
+ * Closed metric key for the AC-06 fold counter
+ * (feat-20260622-chunk-gpu-instancing-sprite-tilemap M3 / D-3).
+ *
+ * Semantics — count of instanced `drawIndexed` calls the fold operator
+ * emits this frame; one increment per non-singleton head bucket retained
+ * after the M2 / w11 cap-fallback filter. NOT entity count, NOT pre-
+ * filter bucket count — cap-overrun buckets that the dispatch site
+ * routed through the per-entity fallback exit do not count.
+ *
+ * Naming follows the EngineMetrics dot-namespace convention
+ * (`<feature>.<event>`); `render.instancing.*` covers both sprite and
+ * tilemap-chunk dispatch sites without scope ambiguity (research F-5,
+ * plan-strategy §8.2). The owning host evidence reads
+ * `ownerMetrics.snapshot()['render.instancing.foldedDraws']`.
+ */
+export declare const FOLDED_DRAWS_METRIC_KEY = "render.instancing.foldedDraws";
+/**
+ * Minimal `EngineMetrics` shape consumed by {@link incrementFoldedDrawsMetric}.
+ *
+ * The real `EngineMetrics` carries `snapshot()` + `reset()` too; the
+ * helper only writes, so the consumed surface narrows to a single
+ * method. Lets the unit test inject a `vi.fn()` mock without faking the
+ * read APIs.
+ */
+export interface FoldMetricsLike {
+    increment(name: string): void;
+}
+/**
+ * Bump the AC-06 `render.instancing.foldedDraws` counter once per fold-
+ * eligible head bucket in `plan` (M3 / w13, plan-strategy D-3).
+ *
+ * Single counter-write site for the metric — the record-stage consumer
+ * calls this once per `recordFrame` after the cap-fallback filter
+ * (M2 / w11) so cap-overrun buckets do not contribute (their members
+ * fall through to per-entity drawIndexed, which is not an instanced
+ * draw). `plan.foldedBucketCount` is the SSOT for "how many instanced
+ * drawIndexed will this frame emit"; passing the same plan to this
+ * helper keeps the metric and the actual dispatch in lockstep.
+ *
+ * Mode-bypass plans (D-5: mode != 0 yields singleton-only buckets which
+ * `buildFoldDispatchPlan` filters out) carry `foldedBucketCount === 0`
+ * and produce no increments — per-entity drawIndexed is not folded so
+ * the metric correctly stays at 0.
+ *
+ * @param plan — output of {@link buildFoldDispatchPlan} after possible
+ *   cap-fallback filtering by the record-stage consumer.
+ * @param metrics — the owner-provided EngineMetrics counter; only
+ *   `increment(name)` is called. Empty `plan.foldedBucketCount === 0`
+ *   produces zero calls (no metric churn for fold-disabled frames).
+ */
+export declare function incrementFoldedDrawsMetric(plan: FoldDispatchPlan, metrics: FoldMetricsLike): void;
+//# sourceMappingURL=mesh-ssbo.d.ts.map

package/dist/record/mesh-ssbo.d.ts.map

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