@forgeax/engine-assets-runtime 0.1.4 → 0.1.7

package/dist/decode-image-bytes.d.ts

@@ -0,0 +1,57 @@
+import type { ImageError, Result, TextureAsset } from '@forgeax/engine-types';
+/**
+ * Decode a PNG / JPEG byte stream into a `TextureAsset` POD.
+ *
+ * Runtime SDK entry for AI users who hold image bytes (fetched over the
+ * network, embedded as base64, produced by an out-of-tree decoder, etc.) and
+ * want to feed them into `world.allocSharedRef('TextureAsset', pod)` +
+ * `GpuResourceStore.ensureResident` without the disk-side importer / build
+ * pipeline in the loop (charter P1 progressive disclosure: one-step "bytes
+ * in, POD out").
+ *
+ * v1 supports the two universally-decodable mime types: `image/png` and
+ * `image/jpeg`. Failure surfaces are all structured via the closed
+ * `ImageError` union (`.code` / `.expected` / `.hint` / `.detail`); the
+ * function never throws for expected failures (AGENTS.md Error model +
+ * charter P3 explicit failure).
+ *
+ * Error codes possible (subset of the closed `ImageErrorCode` union):
+ * - `image-format-unsupported` -- mime not in the v1 whitelist (`detail.actualMime`)
+ * - `image-decode-failed` -- decoder rejected the bytes, or the environment
+ *   lacks `createImageBitmap` (`detail.reason`)
+ *
+ * @param bytes - Encoded image byte stream (`Uint8Array` or `ArrayBuffer`).
+ * @param mime - Byte-stream mime type. v1 whitelist: `'image/png' | 'image/jpeg'`.
+ * @param opts - Optional decode overrides:
+ *   - `colorSpace`: `'srgb'` (default) or `'linear'`. Derives POD `format`:
+ *     `srgb -> 'rgba8unorm-srgb'`, `linear -> 'rgba8unorm'`.
+ *   - `mipmap`: `true` (default) or `false`. When true, `mipLevelCount` is
+ *     computed via `numMipLevels({ width, height })`; when false, forced 1.
+ * @returns `ok(TextureAsset)` on success; `err(ImageError)` on failure.
+ *
+ * @example
+ * ```ts
+ * import { decodeImageBytes } from '@forgeax/engine-assets-runtime';
+ *
+ * const bytes = new Uint8Array(await (await fetch(url)).arrayBuffer());
+ * const result = await decodeImageBytes(bytes, 'image/png');
+ * if (!result.ok) {
+ *   // The ImageError code and detail are one correlated discriminated union.
+ *   switch (result.error.code) {
+ *     case 'image-format-unsupported':
+ *       console.error('bad mime:', result.error.detail.actualMime);
+ *       break;
+ *     case 'image-decode-failed':
+ *       console.error('decode reason:', result.error.detail.reason);
+ *       break;
+ *   }
+ *   return;
+ * }
+ * const handle = world.allocSharedRef('TextureAsset', result.value);
+ * ```
+ */
+export declare function decodeImageBytes(bytes: Uint8Array | ArrayBuffer, mime: string, opts?: {
+    colorSpace?: 'srgb' | 'linear';
+    mipmap?: boolean;
+}): Promise<Result<TextureAsset, ImageError>>;
+//# sourceMappingURL=decode-image-bytes.d.ts.map

package/dist/decode-image-bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-image-bytes.d.ts","sourceRoot":"","sources":["../src/decode-image-bytes.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAa9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,GAAG,WAAW,EAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9D,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC,CAkC3C"}

package/dist/dynamic-texture-store.d.ts

@@ -0,0 +1,89 @@
+import type { Result, RhiDevice, RhiError, Texture, TextureView } from '@forgeax/engine-rhi';
+import type { Handle } from '@forgeax/engine-types';
+/**
+ * The host-owned external image the engine copies a video frame from
+ * (HTMLVideoElement / VideoFrame / ImageBitmap / canvas). Mirrors the `source`
+ * member of the WebGPU `GPUCopyExternalImageSourceInfo` the RHI
+ * `copyExternalImageToTexture` consumes; aliased here so the store does not pull
+ * the whole webgpu descriptor type into its surface.
+ */
+export type CopyExternalImageSource = GPUCopyExternalImageSourceInfo['source'];
+/** rgba8unorm-srgb: a video frame decodes to sRGB; sampling returns linear. */
+declare const VIDEO_TEXTURE_FORMAT: "rgba8unorm-srgb";
+/**
+ * The minimal RHI device surface DynamicTextureStore needs. Declared structurally
+ * (not the full RhiDevice) so unit tests drive it with a small mock and the store
+ * stays decoupled from the rest of the device surface (Pipeline Isolation).
+ */
+export interface DynamicTextureDevice {
+    createTexture(desc: {
+        readonly size: {
+            readonly width: number;
+            readonly height: number;
+            readonly depthOrArrayLayers: number;
+        };
+        readonly format: typeof VIDEO_TEXTURE_FORMAT;
+        readonly usage: number;
+        readonly label?: string;
+    }): Result<Texture, RhiError>;
+    createTextureView(texture: Texture, desc: Record<string, never>): Result<TextureView, RhiError>;
+    destroyTexture(texture: Texture): Result<void, RhiError>;
+    readonly queue: {
+        copyExternalImageToTexture(source: {
+            readonly source: CopyExternalImageSource;
+            readonly flipY?: boolean;
+        }, destination: {
+            readonly texture: Texture;
+        }, copySize: {
+            readonly width: number;
+            readonly height: number;
+            readonly depthOrArrayLayers: number;
+        }): Result<void, RhiError>;
+    };
+}
+/** Adapt the opaque RHI device to the store's intentionally small upload seam. */
+export declare function adaptDynamicTextureDevice(device: RhiDevice): DynamicTextureDevice;
+/**
+ * Transient per-frame texture store for video sources. Independent of
+ * GpuResourceStore: it neither imports nor reaches into the static residency
+ * cache (AC-08 / D-3).
+ */
+export declare class DynamicTextureStore {
+    private device;
+    private readonly entries;
+    /**
+     * Wire the GPU device the store uploads through. Called once after the
+     * renderer captures its device (mirrors GpuResourceStore.configureGpuDevice).
+     * A replacement device invalidates every cached texture: the handles in the
+     * map belong to the old device and cannot be reused after renderer recovery.
+     */
+    configureGpuDevice(device: DynamicTextureDevice): void;
+    /**
+     * Upload one video frame for `clip` from the host-owned source image
+     * (HTMLVideoElement / VideoFrame / ImageBitmap), (re)allocating the transient
+     * texture when its size changes, and return the current-frame view to bind.
+     *
+     * Returns `undefined` (not an error) when the device is not yet wired or the
+     * source has no decodable dimensions yet (metadata pending) — the caller binds
+     * the default view that frame. A structured RhiError surfaces only when a wired
+     * device rejects the allocation or the copy (charter P3).
+     */
+    uploadFrame(clip: Handle<'VideoAsset', 'shared'>, source: CopyExternalImageSource, width: number, height: number): Result<TextureView, RhiError> | undefined;
+    /**
+     * The current-frame view for a clip, if one has been uploaded this session,
+     * else undefined. The record stage reads this when assembling the bind group
+     * (a frame that has not uploaded yet falls back to the default view).
+     */
+    getView(clip: Handle<'VideoAsset', 'shared'>): TextureView | undefined;
+    /** Destroy every transient texture + drop the map (renderer teardown). */
+    destroyAll(): void;
+    /**
+     * Get the entry for `id`, (re)allocating its texture + view when absent or
+     * when the source dimensions changed. A same-size re-upload reuses the
+     * existing texture (allocate-once for a steady clip; the per-frame cost is the
+     * copyExternalImageToTexture write, not a texture create).
+     */
+    private ensureEntry;
+}
+export {};
+//# sourceMappingURL=dynamic-texture-store.d.ts.map

package/dist/dynamic-texture-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-texture-store.d.ts","sourceRoot":"","sources":["../src/dynamic-texture-store.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAE7F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,GAAG,8BAA8B,CAAC,QAAQ,CAAC,CAAC;AAY/E,+EAA+E;AAC/E,QAAA,MAAM,oBAAoB,EAAG,iBAA0B,CAAC;AAExD;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,aAAa,CAAC,IAAI,EAAE;QAClB,QAAQ,CAAC,IAAI,EAAE;YACb,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;YACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;YACxB,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;SACrC,CAAC;QACF,QAAQ,CAAC,MAAM,EAAE,OAAO,oBAAoB,CAAC;QAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;KACzB,GAAG,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC9B,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;IAChG,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IACzD,QAAQ,CAAC,KAAK,EAAE;QACd,0BAA0B,CACxB,MAAM,EAAE;YAAE,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;YAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;SAAE,EAC9E,WAAW,EAAE;YAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;SAAE,EAC1C,QAAQ,EAAE;YACR,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;YACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;YACxB,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;SACrC,GACA,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;KAC3B,CAAC;CACH;AAED,kFAAkF;AAClF,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,GAAG,oBAAoB,CAiCjF;AASD;;;;GAIG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAA+C;IAC7D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;IAE7D;;;;;OAKG;IACH,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,GAAG,IAAI;IAOtD;;;;;;;;;OASG;IACH,WAAW,CACT,IAAI,EAAE,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,EACpC,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG,SAAS;IAmB5C;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG,WAAW,GAAG,SAAS;IAItE,0EAA0E;IAC1E,UAAU,IAAI,IAAI;IAQlB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;CA4BpB"}

package/dist/errors/asset.d.ts

@@ -0,0 +1,201 @@
+import type { MeshBinHeaderV4 } from '@forgeax/engine-pack';
+import { AssetError, type AssetMeshBinContractFacts, type AssetMeshBinContractViolationReason } from '@forgeax/engine-types';
+export declare class MeshBinAssetError extends AssetError {
+    readonly subject: "mesh-bin";
+    readonly sourceKey: string;
+    readonly actual: string;
+    readonly recovery = "re-cook the source with its Meta sidecar through the build-time importer";
+    constructor(args: {
+        readonly sourceKey: string;
+        readonly expected: string;
+        readonly actual: string;
+        readonly header?: Partial<MeshBinHeaderV4> & {
+            readonly byteLength?: number;
+        };
+        readonly reason?: AssetMeshBinContractViolationReason;
+        readonly expectedFacts?: AssetMeshBinContractFacts;
+        readonly actualFacts?: AssetMeshBinContractFacts;
+    });
+}
+/**
+ * Detail for `RuntimeErrorCode 'material-resolved-empty-passes'`.
+ *
+ * Emitted at material parent chain walk time when the resolved passes list
+ * is empty. Two reasons: `'missing-parent'` (a parent handle is not
+ * registered) and `'no-pass-in-chain'` (the entire parent chain has no
+ * pass declarations). AI users switch on `.detail.reason` to surface the
+ * right recovery guidance.
+ *
+ * plan-strategy D-2/D-3: empty-passes is a runtime-layer error
+ * (RuntimeErrorCode, not AssetErrorCode).
+ */
+export interface MaterialResolvedEmptyPassesDetail {
+    /** GUID of the material whose resolve produced empty passes. */
+    readonly materialGuid: string;
+    /** Root cause of the empty passes: missing parent vs entire chain has no passes. */
+    readonly reason: 'missing-parent' | 'no-pass-in-chain';
+    /** The raw numeric handle id of the unregistered parent. Only populated when reason='missing-parent'. */
+    readonly missingParentHandle?: number;
+}
+/**
+ * Structured error for material parent chain resolve yielding zero passes.
+ *
+ * Emitted by `AssetRegistry.passesOf` when the parent chain walk produces
+ * an empty passes list (AC-09, D-3 two-reason). Four-field surface:
+ *   - `.code = 'material-resolved-empty-passes'` (closed RuntimeErrorCode)
+ *   - `.expected` — expected-state description
+ *   - `.hint` — actionable recovery guidance (differs per reason)
+ *   - `.detail = { materialGuid, reason, missingParentHandle? }`
+ */
+export declare class MaterialResolvedEmptyPassesError extends Error {
+    readonly code: "material-resolved-empty-passes";
+    readonly expected: string;
+    readonly hint: string;
+    readonly detail: MaterialResolvedEmptyPassesDetail;
+    constructor(materialGuid: string, reason: 'missing-parent' | 'no-pass-in-chain', missingParentHandle?: number);
+}
+/**
+ * Detail for `RuntimeErrorCode 'mesh-ssbo-capacity-exceeded'`.
+ *
+ * Fired by `growMeshSsbo` (createRenderer.ts grow factory) when, after
+ * attempting pow2 doubling, the resulting `slotCount` still cannot
+ * accommodate the requested `requested` slot count under the device's
+ * `maxStorageBufferBindingSize` ceiling. This is a defensive fallback —
+ * the primary path for "request past device limit" is
+ * `mesh-ssbo-ceiling-reached`. The two codes share the same detail shape so
+ * AI users handle both arms identically; the discriminant identifies which
+ * branch fired so diagnostics can distinguish the primary vs defensive
+ * surface (research §F6.c).
+ *
+ *   - `requested` — slot count requested by the caller (entity count for the frame)
+ *   - `capacity`  — current `slotCount` in the grow controller's state
+ *   - `ceiling`   — `device.limits.maxStorageBufferBindingSize` in BYTES (not slots)
+ */
+export interface MeshSsboCapacityExceededDetail {
+    readonly requested: number;
+    readonly capacity: number;
+    readonly ceiling: number;
+}
+/**
+ * Structured error for the post-grow defensive fallback when mesh-SSBO
+ * capacity cannot accommodate the requested slot count.
+ *
+ * Emitted by `growMeshSsbo` in `createRenderer.ts` (D-5: fire, never
+ * throw). Four-field surface aligned with `SkinPaletteOverflowError`:
+ *   - `.code = 'mesh-ssbo-capacity-exceeded'`
+ *   - `.expected` — capacity >= requested
+ *   - `.hint` — reduce per-frame entity count or split work across frames
+ *   - `.detail = { requested, capacity, ceiling }`
+ */
+export declare class MeshSsboCapacityExceededError extends Error {
+    readonly code: "mesh-ssbo-capacity-exceeded";
+    readonly expected: string;
+    readonly hint: string;
+    readonly detail: MeshSsboCapacityExceededDetail;
+    constructor(requested: number, capacity: number, ceiling: number);
+}
+/**
+ * Detail for `RuntimeErrorCode 'mesh-ssbo-ceiling-reached'`.
+ *
+ * Fired by `growMeshSsbo` when the requested slot count would exceed the
+ * device's `maxStorageBufferBindingSize` (the only ceiling per D-1; engine
+ * carries no private capacity constant). Same detail shape as
+ * `MeshSsboCapacityExceededDetail`.
+ *
+ *   - `requested` — slot count requested by the caller
+ *   - `capacity`  — current `slotCount` in the grow controller's state
+ *   - `ceiling`   — `device.limits.maxStorageBufferBindingSize` in BYTES
+ */
+export interface MeshSsboCeilingReachedDetail {
+    readonly requested: number;
+    readonly capacity: number;
+    readonly ceiling: number;
+}
+/**
+ * Structured error for mesh-SSBO grow refused because the request exceeds
+ * `device.limits.maxStorageBufferBindingSize`.
+ *
+ * Emitted by `growMeshSsbo` (D-5: fire, never throw). The frame renders a
+ * degraded subset (truncated to pre-grow capacity) per plan-strategy D-2 —
+ * no black frame. Four-field surface aligned with `SkinPaletteOverflowError`:
+ *   - `.code = 'mesh-ssbo-ceiling-reached'`
+ *   - `.expected` — requested * stride <= device.limits.maxStorageBufferBindingSize
+ *   - `.hint` — reduce per-frame entity count or pick a higher-tier adapter
+ *   - `.detail = { requested, capacity, ceiling }`
+ */
+export declare class MeshSsboCeilingReachedError extends Error {
+    readonly code: "mesh-ssbo-ceiling-reached";
+    readonly expected: string;
+    readonly hint: string;
+    readonly detail: MeshSsboCeilingReachedDetail;
+    constructor(requested: number, capacity: number, ceiling: number);
+}
+/**
+ * Detail for `RuntimeErrorCode 'scene-collect-entity-ref-out-of-closure'`.
+ *
+ * Emitted during rootsToSceneAsset when an entity field references a target
+ * outside the collected forest closure.
+ */
+export interface SceneCollectEntityRefOutOfClosureDetail {
+    readonly entity: number;
+    readonly field: string;
+    readonly target: number;
+}
+/**
+ * Structured error for entity ref pointing outside the forest closure.
+ *
+ * Emitted during rootsToSceneAsset collect; fail-fast per charter P3.
+ *   - `.code = 'scene-collect-entity-ref-out-of-closure'`
+ *   - `.expected` — all entity refs resolve within the closure
+ *   - `.hint` — Expand roots to include the target entity, or remove the reference.
+ *   - `.detail = { entity, field, target }`
+ */
+export declare class SceneCollectEntityRefOutOfClosureError extends Error {
+    readonly code: "scene-collect-entity-ref-out-of-closure";
+    readonly expected: string;
+    readonly hint: string;
+    readonly detail: SceneCollectEntityRefOutOfClosureDetail;
+    constructor(entity: number, field: string, target: number);
+}
+/**
+ * Detail for `RuntimeErrorCode 'scene-collect-asset-guid-unresolved'`.
+ *
+ * Emitted at two points with different context on hand:
+ *   - collect (handle→GUID): the shared handle is known → `.handle` is set.
+ *   - serialize (GUID→refs): the GUID string is known but absent from the
+ *     refs index → `.guid` is set. (`.handle` is meaningless there.)
+ * Exactly one of `handle` / `guid` is present per instance.
+ */
+export interface SceneCollectAssetGuidUnresolvedDetail {
+    readonly field: string;
+    readonly handle?: number;
+    readonly guid?: string;
+}
+/**
+ * Structured error for a shared asset reference whose GUID cannot be resolved.
+ *
+ * Emitted during rootsToSceneAsset collect (handle) or
+ * serializeSceneAssetToPack (guid); fail-fast per charter P3.
+ *   - `.code = 'scene-collect-asset-guid-unresolved'`
+ *   - `.expected` — every shared asset reference has a catalogued GUID
+ *   - `.hint` — Register the asset in AssetRegistry before collecting.
+ *   - `.detail = { field, handle }` (collect) or `{ field, guid }` (serialize)
+ */
+export declare class SceneCollectAssetGuidUnresolvedError extends Error {
+    readonly code: "scene-collect-asset-guid-unresolved";
+    readonly expected: string;
+    readonly hint: string;
+    readonly detail: SceneCollectAssetGuidUnresolvedDetail;
+    constructor(field: string, ref: number | string);
+}
+/**
+ * Closed union of asset-cluster error codes. AI users perform exhaustive
+ * `switch (err.code)` without default; TS guards completeness.
+ */
+export type AssetRuntimeErrorCode = AssetRuntimeError['code'];
+/**
+ * Closed union of the asset-cluster structured error classes, each carrying
+ * an `AssetRuntimeErrorCode` discriminant on `.code`.
+ */
+export type AssetRuntimeError = MaterialResolvedEmptyPassesError | MeshSsboCapacityExceededError | MeshSsboCeilingReachedError | SceneCollectEntityRefOutOfClosureError | SceneCollectAssetGuidUnresolvedError;
+//# sourceMappingURL=asset.d.ts.map

package/dist/errors/asset.d.ts.map

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

package/dist/handles.d.ts

@@ -0,0 +1,143 @@
+import type { Handle } from '@forgeax/engine-types';
+/**
+ * Builtin unit-cube mesh handle (8 vertices + 36 indices, pos+normal
+ * interleaved). Pair with `MeshFilter` to spawn a cube entity.
+ *
+ * @remarks Typed as `Handle<'MeshAsset', 'shared'>` — feat-20260517
+ * unifies the engine-types and engine-ecs Handle brand SSOT into a single
+ * `Handle<T extends string, M extends 'unique'|'shared'>` declaration
+ * (research Finding 4 import-path-decoupled identity), and constructs the
+ * value via the brand-creation factory `toShared<'MeshAsset'>(N)` so
+ * the caller-side `as unknown as` cast is eliminated (AC-05). The
+ * `'shared'` mode signals the AssetRegistry owns the lifecycle — the
+ * ECS does not release the slot on despawn / removeComponent / set.
+ * Runtime value is a small u32 (1).
+ */
+export declare const HANDLE_CUBE: Handle<'MeshAsset', 'shared'>;
+/**
+ * Builtin triangle mesh handle (3 vertices). Pair with `MeshFilter`.
+ *
+ * @remarks Typed as `Handle<'MeshAsset', 'shared'>` (same narrow brand
+ * as HANDLE_CUBE; constructed via the `toShared<'MeshAsset'>(N)`
+ * factory per AC-05).
+ */
+export declare const HANDLE_TRIANGLE: Handle<'MeshAsset', 'shared'>;
+/**
+ * Builtin unit-quad mesh handle — 4 vertices, 6 indices, 2 triangles on
+ * the XY plane facing +Z. Pair with `MeshFilter` to spawn a sprite quad
+ * (feat-20260520-2d-sprite-layer-mvp / M-1 / w06).
+ *
+ * @derives Same-shape sibling of {@link HANDLE_CUBE} / {@link HANDLE_TRIANGLE}
+ *   per requirements §2.1.C: built via the `toShared<'MeshAsset'>(N)`
+ *   brand-creation factory; reserved-id 3 fills the namespace hole between
+ *   HANDLE_TRIANGLE=2 and FIRST_USER_HANDLE=1024 (no `BUILTIN_HANDLE_`
+ *   prefix per Q2 naming decision — discoverable next to existing
+ *   builtins in IDE autocomplete; charter F1 single-entry indexability).
+ *
+ * @reuses {@link createPlaneGeometry}(1, 1) — the procedural plane factory
+ *   already produces 8-floats-per-vertex interleaved (position + normal +
+ *   uv) and is then expanded to the runtime 12-floats layout (adds
+ *   tangent vec4) by {@link meshFromInterleaved}. This funnels HANDLE_QUAD
+ *   onto the exact same vertex pipeline branch as BUILTIN_CUBE /
+ *   BUILTIN_TRIANGLE and the procedural geometry factories — zero new
+ *   layout discriminator (plan-strategy §3 RT4 + D-9 + charter P4
+ *   consistent abstraction).
+ *
+ * @reuses `PROCEDURAL_FLOATS_PER_VERTEX` = 12 from
+ *   `@forgeax/engine-geometry` (the single layout SSOT; the procedural
+ *   `createPlaneGeometry` factory already returns 12F via
+ *   `meshFromInterleaved`).
+ */
+export declare const HANDLE_QUAD: Handle<'MeshAsset', 'shared'>;
+/**
+ * Id=4 reserved builtin; occupies the next available slot under
+ * FIRST_USER_HANDLE=1024. BUILTIN_SPHERE is synthesised from
+ * `createSphereGeometry(1, 16, 12)` through the same
+ * `meshFromInterleaved` path as BUILTIN_QUAD, so the runtime
+ * 12-float stride is byte-identical to procedural output — zero
+ * new layout discriminator (charter P4 consistent abstraction).
+ */
+export declare const HANDLE_SPHERE: Handle<'MeshAsset', 'shared'>;
+/**
+ * Builtin cylinder mesh handle — procedural open cylinder (unit-height,
+ * radius=0.5, 16 radial segments, no caps). Pair with `MeshFilter`.
+ *
+ * @derives Same-shape sibling of {@link HANDLE_SPHERE}: synthesised from
+ *   `createCylinderGeometry(0.5, 0.5, 1, 16, 1)` through the same
+ *   `meshFromInterleaved` path as BUILTIN_SPHERE, so the runtime
+ *   12-float stride is byte-identical to all other built-in meshes —
+ *   zero new layout discriminator (charter P4 consistent abstraction).
+ *
+ * @remarks Id=6 follows {@link HANDLE_NINESLICE_QUAD}=5 in the builtin slot
+ *   sequence (FIRST_USER_HANDLE=1024 untouched).
+ *   feat-20260701-editor-world-container-doc-ecs-collapse M0 / AC-16:
+ *   GUID = deriveBuiltin('HANDLE_CYLINDER') UUIDv5
+ *   (plan-strategy §2 D-6 + §5.6 builtin-guid-ssot gate)
+ */
+export declare const HANDLE_CYLINDER: Handle<'MeshAsset', 'shared'>;
+/**
+ * Builtin 9-slice quad mesh handle — 4×4 grid (16 vertices, 9 sub-quads,
+ * 54 indices) on the XY plane facing +Z. Pair with `MeshFilter` and a
+ * `MaterialAsset` whose first pass shader is `'forgeax::sprite'` and whose
+ * `values.slices` is non-zero to render a 9-sliced UI panel
+ * (feat-20260527-sprite-nineslice / M2 / w9).
+ *
+ * @derives Same-shape sibling of {@link HANDLE_QUAD}: synthesised from
+ *   `createPlaneGeometry(1, 1, 3, 3)` which subdivides the unit quad into
+ *   3×3 sub-quads (9 cells). The 16 grid points and 54 indices feed
+ *   {@link meshFromInterleaved} so the runtime 12-float vertex stride is
+ *   byte-identical to all other built-in / procedural meshes — zero new
+ *   layout discriminator (charter P4 consistent abstraction).
+ *
+ * @remarks Id=5 follows {@link HANDLE_SPHERE}=4 in the builtin slot
+ *   sequence (FIRST_USER_HANDLE=1024 untouched). The vertex shader uses
+ *   `vertex_index % 4` / `vertex_index / 4` to recover (i, j) grid
+ *   coordinates and four anchor vec4s to map each grid cell to the right
+ *   region of the source texture; only required when the sprite material
+ *   declares non-zero `slices`. For the legacy zero-slice sprite path use
+ *   {@link HANDLE_QUAD}.
+ *
+ * @reuses `PROCEDURAL_FLOATS_PER_VERTEX` = 12 from
+ *   `@forgeax/engine-geometry` (sprite-pipeline binding table / vertex layout
+ *   untouched). plan-strategy §D-2 NOTE clarifies
+ *   the id=5 vs original-plan id=4 drift: HANDLE_SPHERE took id=4 in
+ *   feat-20260529-fxaa-sphere-builtin before this feat landed.
+ */
+export declare const HANDLE_NINESLICE_QUAD: Handle<'MeshAsset', 'shared'>;
+/**
+ * Stable GUIDs for the builtin meshes — the dash-form of
+ * `deriveBuiltin('HANDLE_<NAME>')` (UUIDv5, ForgeaX namespace) in
+ * `@forgeax/engine-pack`. They are inlined here (not imported) because the
+ * pack derivation runs under top-level `await` (async SubtleCrypto) and
+ * dragging that into the AssetRegistry constructor — a synchronous hot path
+ * consumed engine-wide — would make the whole runtime module graph async.
+ *
+ * The single source of truth remains `deriveBuiltin`: a cross-package
+ * guard test (`builtin-guid-ssot.test.ts`) asserts each literal equals the
+ * derived value, so any drift in the derivation reds the suite. This pairs
+ * the previously-disconnected dual truths (the u32 `HANDLE_*` constants and
+ * the pack GUID strings) into one bidirectionally-resolvable table, so
+ * `guidOf(HANDLE_CUBE)` no longer returns `undefined`
+ * (docs/feedbacks/2026-06-03 §6.2 Tier 0).
+ */
+export declare const BUILTIN_MESH_GUIDS: ReadonlyArray<readonly [Handle<'MeshAsset', 'shared'>, string]>;
+/** Resolve the stable producer GUID for one process-static builtin mesh handle. */
+export declare function builtinMeshGuid(handle: Handle<string, 'shared'>): string | undefined;
+/**
+ * Field names known to carry handle<> schema-vocab references (plan-strategy
+ * D-4).  parseScenePayload uses this allowlist to replace integer values
+ * with GUID strings from refs[] only for handle fields — a Transform.pos lane of 0,
+ * ChildOf.parent=0 and similar non-handle integers are left untouched.
+ *
+ * When a new handle<> field is added to a runtime component, its field name
+ * MUST be added here so parseScenePayload correctly resolves it.
+ */
+export declare const HANDLE_FIELD_NAMES: ReadonlySet<string>;
+/**
+ * Field names known to carry `array<handle<X>>` schema-vocab references
+ * (feat-20260608 M2 / w7: MeshRenderer.materials). Each element is a refs
+ * index that resolves to a GUID string. Coexists with HANDLE_FIELD_NAMES;
+ * a field name lives in exactly one set.
+ */
+export declare const HANDLE_ARRAY_FIELD_NAMES: ReadonlySet<string>;
+//# sourceMappingURL=handles.d.ts.map

package/dist/handles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handles.d.ts","sourceRoot":"","sources":["../src/handles.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAKpD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,QAAQ,CAA4B,CAAC;AAEnF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,WAAW,EAAE,QAAQ,CAA4B,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,QAAQ,CAA4B,CAAC;AAEnF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,WAAW,EAAE,QAAQ,CAA4B,CAAC;AAErF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,WAAW,EAAE,QAAQ,CAA4B,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,WAAW,EAAE,QAAQ,CAA4B,CAAC;AAE7F;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,CAU9F,CAAC;AAEF,mFAAmF;AACnF,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,MAAM,GAAG,SAAS,CAGpF;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAcjD,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAA0B,CAAC"}

package/dist/image-error.d.ts

@@ -0,0 +1,6 @@
+import type { ImageErrorDetailFor, ImageErrorFor } from '@forgeax/engine-types';
+type UnsupportedMimeImageError = ImageErrorFor<'image-format-unsupported'>;
+type UnsupportedMimeImageErrorDetail = ImageErrorDetailFor<'image-format-unsupported'>;
+export declare function makeImageError(detail: UnsupportedMimeImageErrorDetail): UnsupportedMimeImageError;
+export {};
+//# sourceMappingURL=image-error.d.ts.map

package/dist/image-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-error.d.ts","sourceRoot":"","sources":["../src/image-error.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAUhF,KAAK,yBAAyB,GAAG,aAAa,CAAC,0BAA0B,CAAC,CAAC;AAC3E,KAAK,+BAA+B,GAAG,mBAAmB,CAAC,0BAA0B,CAAC,CAAC;AA2BvF,wBAAgB,cAAc,CAAC,MAAM,EAAE,+BAA+B,GAAG,yBAAyB,CAEjG"}

package/dist/index.d.ts

@@ -1,5 +1,34 @@
-export type { AssetDecoder, AssetDecoderInput, AssetDecoderLease, AssetKind, AssetLoadError, AssetPublicationTuple, CatalogEntry, PackV2, Result, } from '@forgeax/engine-types';
+export type { AnimationClip, AnimationGraph, AudioClipAsset, EquirectAsset, FontAsset, MaterialAsset, ParticleEffectAsset, RenderPipelineAsset, SamplerAsset, SceneAsset, SkeletonAsset, SkinAsset, TextureAsset, TilesetAsset, VideoAsset, } from '@forgeax/engine-types';
 export { defineAssetKind } from './asset-kind.js';
-export { type CatalogListener, type CatalogSource, createCatalogSource } from './catalog-source.js';
-export { type AssetLoadOptions, type AssetRegistry, type AssetRegistryOptions, type AssetRegistrySnapshot, type AssetRegistrySnapshotCounters, createAssetRegistry, } from './internal/load-asset.js';
+export type { Asset, CatalogReconcileError, CatalogReconcileResult, MeshAsset, } from './asset-registry';
+export { AssetRegistry } from './asset-registry';
+export { BUILTIN_BASE, BUILTIN_CUBE, BUILTIN_CYLINDER, BUILTIN_NINESLICE_QUAD, BUILTIN_QUAD, BUILTIN_SPHERE, BUILTIN_TRIANGLE, BuiltinAssetRegistry, } from './builtin-asset-registry';
+export { type CatalogListener, type CatalogSource, createCatalogSource } from './catalog-source';
+export { decodeImageBytes } from './decode-image-bytes';
+export { adaptDynamicTextureDevice, type DynamicTextureDevice, DynamicTextureStore, } from './dynamic-texture-store';
+export type { AssetRuntimeError, AssetRuntimeErrorCode, MaterialResolvedEmptyPassesDetail, SceneCollectAssetGuidUnresolvedDetail, SceneCollectEntityRefOutOfClosureDetail, } from './errors/asset';
+export { MaterialResolvedEmptyPassesError, MeshBinAssetError, MeshSsboCapacityExceededError, MeshSsboCeilingReachedError, SceneCollectAssetGuidUnresolvedError, SceneCollectEntityRefOutOfClosureError, } from './errors/asset';
+export { builtinMeshGuid, HANDLE_CUBE, HANDLE_CYLINDER, HANDLE_NINESLICE_QUAD, HANDLE_QUAD, HANDLE_SPHERE, HANDLE_TRIANGLE, } from './handles';
+export { type AssetRegistry as RuntimeAssetRegistry, type AssetRegistryResolver, createAssetRegistry, getAssetRegistryResolver, } from './internal/load-asset.js';
+export { LoaderRegistry } from './loader-registry';
+export { animationClipLoader, animationGraphLoader, audioLoader, INLINE_PACK_LOADERS, materialLoader, meshLoader, particleEffectLoader, renderPipelineLoader, sceneLoader, skeletonLoader, skinLoader, tilesetLoader, } from './loaders/inline-pack';
+export { type UnpackedMeshBin, unpackMeshBinV4, } from './loaders/mesh-bin';
+export { equirectLoader, fontLoader, PACK_ARTIFACT_LOADERS, renderPipelineLoader as renderPipelineArtifactLoader, textureLoader, tilesetLoader as tilesetArtifactLoader, } from './loaders/pack-artifact';
+export { MaterialGenerationCache } from './material/generation-cache';
+export { inspectMaterialRuntime, type MaterialRuntimeInfo } from './material/inspection';
+export { createMaterialLoader, type MaterialLoadError, type MaterialLoadErrorCode, type MaterialLoadErrorDetail, type MaterialLoaderOptions, type MaterialLoadRequest, type MaterialPublication, type MaterialReady, } from './material/loader';
+export { installMaterialReadyShaders, materialParametersToParamSchema, runtimeMaterialShaderId, } from './material/runtime-shader';
+export { blitMipmapsSync, getOrCreateMipmapPipeline, type MipmapBlitDevice, type MipmapShaderModuleFactory, mipmapCacheSize, numMipLevels, } from './mipmap-generator';
+export { type TilesetValidateOptions, validateTilesetPayload } from './payload-validate';
+export { assetLoaderPlugin, assetsPlugin, packLoaderPlugin } from './plugin';
+export { createRuntimeAssetEvidenceAdapter, type RuntimeEvidenceSource, } from './registry/asset-evidence';
+export { CatalogReplica, type CatalogReplicaSnapshot } from './registry/catalog-state';
+export type { PostSpawnHook, SkinJointResolver } from './registry/instantiate';
+export { buildSceneChildContext } from './registry/instantiate';
+export { loadMaterialReadyByGuid } from './registry/load-by-guid';
+export { compareScenePublicationFences, createScenePublicationFence, observeScenePublication, parseScenePublicationFence, SCENE_PUBLICATION_FENCE_SCHEMA, SCENE_PUBLICATION_RECOVERY_ACTIONS, type ScenePublicationFence, type ScenePublicationFenceError, type ScenePublicationFencePhase, type ScenePublicationObservation, scenePublicationFenceFromCatalog, } from './registry/scene-publication-fence';
+export { resolveAssetHandle, walkMaterialPassesOverSharedRefs } from './resolve-asset-handle';
+export { type ResolvedTilesetRuntime, resolveTilesetRuntime, type TilesetAtlasLookup, type TilesetRuntimeError, type TilesetRuntimeErrorCode, } from './resolve-tileset-runtime';
+export { parseScenePayload } from './scene-payload';
+export { createDefaultLoaderRegistry, wireDefaultLoaders } from './wire-default-loaders';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,EACjB,SAAS,EACT,cAAc,EACd,qBAAqB,EACrB,YAAY,EACZ,MAAM,EACN,MAAM,GACP,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,aAAa,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AACpG,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EAClC,mBAAmB,GACpB,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}