@forgeax/engine-render 0.1.4 → 0.1.7

package/dist/render-system-fold.d.ts

@@ -1,266 +0,0 @@
-import { RhiError } from '@forgeax/engine-rhi';
-import type { DispatchEntry } from './render-system-extract';
-import { type TransparentSortConfig } from './systems/transparent-sort-config';
-/**
- * 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 any 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`             | any         | `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). AI users observe via
- * `renderer.metrics.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 any
- *   cap-fallback filtering by the record-stage consumer.
- * @param metrics — the per-Renderer 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=render-system-fold.d.ts.map

package/dist/render-system-fold.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"render-system-fold.d.ts","sourceRoot":"","sources":["../src/render-system-fold.ts"],"names":[],"mappings":"AA+CA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,mCAAmC,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;KAAE,CAAC;IACrD,QAAQ,CAAC,QAAQ,EAAE;QAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KAAE,CAAC;CACnE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,SAAS,aAAa,EAAE,EACxC,IAAI,EAAE,qBAAqB,CAAC,MAAM,CAAC,EACnC,WAAW,EAAE,SAAS,kBAAkB,EAAE,GACzC,SAAS,UAAU,EAAE,CA8GvB;AA+CD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACtD,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,+BAA+B,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3D,gBAAgB,CAqBlB;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,QAAQ,GAAG,eAAe,GAChC,qBAAqB,CAgBvB;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,uBAAuB,kCAAkC,CAAC;AAEvE;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAIjG"}

package/dist/renderer/asset-service.d.ts

@@ -1,10 +0,0 @@
-import type { CookedMaterialRecord } from '@forgeax/engine-pack';
-import { type MaterialArtifactConflictError, MaterialArtifactRegistry } from '@forgeax/engine-shader';
-import { type Result } from '@forgeax/engine-types';
-export interface MaterialAssetService {
-    publish(record: CookedMaterialRecord): Result<CookedMaterialRecord, MaterialArtifactConflictError>;
-    inspect(key: string): ReturnType<MaterialArtifactRegistry['inspect']>;
-}
-/** Render owns the CPU material artifact handoff; no GPU cache is introduced. */
-export declare function createMaterialAssetService(): MaterialAssetService;
-//# sourceMappingURL=asset-service.d.ts.map

package/dist/renderer/asset-service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-service.d.ts","sourceRoot":"","sources":["../../src/renderer/asset-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EACL,KAAK,6BAA6B,EAClC,wBAAwB,EAGzB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,WAAW,oBAAoB;IACnC,OAAO,CACL,MAAM,EAAE,oBAAoB,GAC3B,MAAM,CAAC,oBAAoB,EAAE,6BAA6B,CAAC,CAAC;IAC/D,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;CACvE;AAED,iFAAiF;AACjF,wBAAgB,0BAA0B,IAAI,oBAAoB,CAcjE"}

package/dist/renderer/backend-selection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backend-selection.d.ts","sourceRoot":"","sources":["../../src/renderer/backend-selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,gBAAgB,EAChB,SAAS,EACT,QAAQ,EACR,WAAW,EACX,YAAY,EACb,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IACnF,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,WAAW,GAAG;QAC1B,QAAQ,CAAC,oBAAoB,EAAE,CAC7B,MAAM,EAAE,iBAAiB,GAAG,eAAe,KACxC,MAAM,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC;KACzC,CAAC;IACF,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAC5B,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,KAC/C,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC7C,QAAQ,CAAC,6BAA6B,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK;QAC3D,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;QACnB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;KAC1B,CAAC;IACF,gBAAgB;IAChB,QAAQ,CAAC,sBAAsB,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,GAAG,SAAS,CAAC;IAC7E,QAAQ,CAAC,eAAe,CAAC,EAAE,yBAAyB,CAAC;CACtD;AAUD,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,cAAc,CAgCxE;AASD,wBAAsB,eAAe,CACnC,OAAO,EAAE,eAAe,GAAG,SAAS,GACnC,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC,CAgC3C"}

package/dist/renderer/environment-classify.d.ts

@@ -1,6 +0,0 @@
-export declare function classifyEnvErrorReason(base: string, primary: {
-    code?: unknown;
-    name?: unknown;
-} | undefined): string;
-export declare function composeEnvErrorHint(webgpuError: unknown, wgpuError: unknown): string | undefined;
-//# sourceMappingURL=environment-classify.d.ts.map

package/dist/renderer/environment-classify.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"environment-classify.d.ts","sourceRoot":"","sources":["../../src/renderer/environment-classify.ts"],"names":[],"mappings":"AAQA,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,GACtD,MAAM,CAQR;AACD,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAShG"}

package/dist/renderer/environment-error.d.ts

@@ -1,13 +0,0 @@
-import type { RhiError } from '@forgeax/engine-rhi';
-export interface EngineEnvironmentErrorDetail {
-    readonly webgpuError?: RhiError | Error | undefined;
-    readonly wgpuError?: RhiError | Error | undefined;
-}
-export declare class EngineEnvironmentError extends Error {
-    readonly reason: string;
-    readonly webgpuError?: RhiError | Error | undefined;
-    readonly wgpuError?: RhiError | Error | undefined;
-    readonly detail: EngineEnvironmentErrorDetail;
-    constructor(reason: string, detail?: EngineEnvironmentErrorDetail);
-}
-//# sourceMappingURL=environment-error.d.ts.map

package/dist/renderer/environment-error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"environment-error.d.ts","sourceRoot":"","sources":["../../src/renderer/environment-error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;CACnD;AACD,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;IAClD,QAAQ,CAAC,MAAM,EAAE,4BAA4B,CAAC;gBAClC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,4BAAiC;CAQtE"}

package/dist/renderer/material/pipeline-projection.d.ts

@@ -1,91 +0,0 @@
-import type { MaterialRuntimeArtifact } from '@forgeax/engine-shader';
-import { type MaterialErrorFor, type MaterialValue } from '@forgeax/engine-types';
-import { type MaterialDrawDiagnostic } from '../../errors/render.js';
-import type { MaterialRenderProjection } from './assembly.js';
-export interface MaterialRenderReady {
-    readonly status: 'Ready';
-    readonly guid: string;
-    readonly materialGuid: string;
-    readonly publicationGeneration: number;
-    readonly specializationKey: string;
-    readonly artifactDigest: string;
-    readonly sourceClosure: readonly string[];
-    readonly parameterContract: unknown;
-    readonly record: unknown;
-    readonly artifact: MaterialRuntimeArtifact;
-}
-export interface MaterialRenderError {
-    readonly status: 'Error';
-    readonly error: {
-        readonly code: string;
-        readonly expected: string;
-        readonly hint: string;
-        readonly retryable: boolean;
-        readonly recoveryActions: readonly string[];
-        readonly detail: {
-            readonly guid: string;
-            readonly specializationKey: string;
-            readonly publicationGeneration?: number;
-            readonly actual?: string;
-        };
-    };
-}
-export type MaterialReadiness = MaterialRenderReady | MaterialRenderError;
-export type MaterialDrawRoute<TPipeline> = {
-    readonly kind: 'draw';
-    readonly pipeline: TPipeline;
-} | {
-    readonly kind: 'skip';
-    readonly diagnostic?: MaterialDrawDiagnostic;
-};
-export type MaterialReadinessRoute = {
-    readonly kind: 'draw';
-    readonly readiness: MaterialRenderReady;
-} | {
-    readonly kind: 'skip';
-    readonly diagnostic?: MaterialDrawDiagnostic;
-};
-export interface MaterialPipelineProjection {
-    readonly specializationKey: string;
-    readonly artifactHash: string;
-    readonly layoutIdentity: string;
-    readonly passes: MaterialRenderProjection['passes'];
-}
-export interface MaterialPipelineReady extends MaterialPipelineProjection {
-    readonly kind: 'ready';
-    readonly artifact: MaterialRuntimeArtifact;
-}
-export interface MaterialPipelineMiss {
-    readonly kind: 'error';
-    readonly error: {
-        readonly code: MaterialErrorFor<'material-specialization-not-cooked'>['code'];
-        readonly expected: MaterialErrorFor<'material-specialization-not-cooked'>['expected'];
-        readonly hint: MaterialErrorFor<'material-specialization-not-cooked'>['hint'];
-        readonly detail: MaterialErrorFor<'material-specialization-not-cooked'>['detail'];
-        readonly message: MaterialErrorFor<'material-specialization-not-cooked'>['message'];
-    };
-}
-export declare function projectMaterialPipeline(projection: MaterialRenderProjection): MaterialPipelineProjection;
-export declare function updateMaterialRuntimeValues(projection: MaterialRenderProjection, values: Readonly<Record<string, MaterialValue | null>>): MaterialRenderProjection;
-export declare function routeMaterialPipeline(args: {
-    readonly projection: MaterialRenderProjection;
-    readonly lookupArtifact: (key: string) => MaterialRuntimeArtifact | undefined;
-}): MaterialPipelineReady | MaterialPipelineMiss;
-/**
- * Route one draw from the canonical MaterialReady result.
- *
- * A failed readiness result never reaches the pipeline builder. The caller
- * owns one Set for the render lifetime so repeated frames and re-entry share
- * the same material identity dedupe boundary.
- */
-export declare function routeMaterialDraw<TPipeline>(args: {
-    readonly readiness: MaterialReadiness;
-    readonly buildPipeline: (ready: MaterialRenderReady) => TPipeline;
-    readonly reportedDiagnosticKeys: Set<string>;
-}): MaterialDrawRoute<TPipeline>;
-/** Route the production record decision before pipeline selection or draw. */
-export declare function routeMaterialReadiness(args: {
-    readonly readiness: MaterialReadiness;
-    readonly reportedDiagnosticKeys: Set<string>;
-}): MaterialReadinessRoute;
-//# sourceMappingURL=pipeline-projection.d.ts.map

package/dist/renderer/material/pipeline-projection.d.ts.map

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