@forgeax/engine-assets-runtime 0.0.0-dev.8d955ade1c79

package/dist/registry/load-by-guid.d.ts.map

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

package/dist/registry/load-state.d.ts

@@ -0,0 +1,26 @@
+export type LoadStatus = 'unloaded' | 'provisional' | 'ready' | 'failed';
+export interface LoadRecord {
+    readonly status: LoadStatus;
+    readonly refs: readonly string[];
+    readonly value?: unknown;
+    readonly error?: unknown;
+}
+export declare class LoadStateStore {
+    private readonly records;
+    get(guid: string): LoadRecord | undefined;
+    getReady<T = unknown>(guid: string): T | undefined;
+    /**
+     * Return a provisional value only for the internal SCC back-edge bridge.
+     * Public callers must use getReady so promotion remains the visibility gate.
+     */
+    getProvisional<T = unknown>(guid: string): T | undefined;
+    begin(guid: string, refs: readonly string[]): LoadRecord;
+    resolveAsset(guid: string, value: unknown): void;
+    registerReady(guid: string, value: unknown): void;
+    promoteReady(guid: string): void;
+    fail(guid: string, error: unknown): readonly string[];
+    remove(guid: string): void;
+    clear(): void;
+    private provisionalGroup;
+}
+//# sourceMappingURL=load-state.d.ts.map

package/dist/registry/load-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-state.d.ts","sourceRoot":"","sources":["../../src/registry/load-state.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,aAAa,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEzE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AASD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwC;IAEhE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAIzC,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAKlD;;;OAGG;IACH,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAKxD,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,UAAU;IAYxD,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAUhD,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAMjD,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAkBhC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,SAAS,MAAM,EAAE;IAWrD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI1B,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,gBAAgB;CAYzB"}

package/dist/registry/runtime-projection.d.ts

@@ -0,0 +1,16 @@
+import { type Result } from '@forgeax/engine-rhi';
+import { AssetError, type CatalogProjection } from '@forgeax/engine-types';
+import type { CatalogRecord } from './catalog';
+export interface RuntimeProjection {
+    readonly subject: CatalogProjection['subject'];
+    readonly execution: CatalogProjection['execution'];
+    readonly lifecycle: CatalogProjection['lifecycle'];
+    readonly packageUrl: string;
+}
+/**
+ * Resolve the producer-declared runtime projection. Legacy rows return
+ * undefined so inline/dev assets retain their existing registration path;
+ * rows that publish any projection axis must publish all three axes.
+ */
+export declare function resolveRuntimeProjection(guid: string, record: CatalogRecord): Result<RuntimeProjection | undefined, AssetError>;
+//# sourceMappingURL=runtime-projection.d.ts.map

package/dist/registry/runtime-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-projection.d.ts","sourceRoot":"","sources":["../../src/registry/runtime-projection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAqB,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC9F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC,WAAW,CAAC,CAAC;IACnD,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC,WAAW,CAAC,CAAC;IACnD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAUD;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,GACpB,MAAM,CAAC,iBAAiB,GAAG,SAAS,EAAE,UAAU,CAAC,CAmCnD"}

package/dist/registry/scene-publication-fence.d.ts

@@ -0,0 +1,38 @@
+import { type Result } from '@forgeax/engine-rhi';
+import type { AssetPublicationEnvelope, CatalogEntry, ScenePublicationFence as EngineScenePublicationFence } from '@forgeax/engine-types';
+export declare const SCENE_PUBLICATION_FENCE_SCHEMA: "scene-publication-fence/1";
+export declare const SCENE_PUBLICATION_RECOVERY_ACTIONS: readonly ["continue-last-known-good", "retry-rebuild", "fresh-reopen"];
+export type ScenePublicationFence = EngineScenePublicationFence;
+export type ScenePublicationFencePhase = 'publication' | 'catalog' | 'observation' | 'instantiate';
+export interface ScenePublicationFenceError {
+    readonly code: 'asset-generation-fence-mismatch';
+    readonly phase: ScenePublicationFencePhase;
+    readonly hint: string;
+    readonly sourcePath?: string;
+    readonly sourceRevision?: string;
+    readonly expected?: ScenePublicationFence;
+    readonly actual?: ScenePublicationFence;
+    readonly currentGeneration?: number;
+    readonly lastKnownGood?: ScenePublicationFence;
+    readonly retryable: boolean;
+    readonly recoveryActions: readonly string[];
+}
+export interface ScenePublicationObservation {
+    readonly fence: ScenePublicationFence;
+    readonly outputs: readonly string[];
+}
+/** Convert one complete Engine publication into the serializable Scene fence. */
+export declare function createScenePublicationFence(publication: AssetPublicationEnvelope): Result<ScenePublicationFence, ScenePublicationFenceError>;
+/** Parse the persisted fence without guessing legacy generation or identity. */
+export declare function parseScenePublicationFence(value: unknown): Result<ScenePublicationFence, ScenePublicationFenceError>;
+/** Compare all fence fields; no single generation or GUID may stand in for it. */
+export declare function compareScenePublicationFences(expected: ScenePublicationFence, actual: ScenePublicationFence, lastKnownGood?: ScenePublicationFence): Result<ScenePublicationFence, ScenePublicationFenceError>;
+/** Derive a fence only when every Catalog row for the source publication is present and aligned. */
+export declare function scenePublicationFenceFromCatalog(entries: readonly CatalogEntry[], outputGuid: string): Result<ScenePublicationFence, ScenePublicationFenceError>;
+export declare function observeScenePublication(input: {
+    readonly publication: AssetPublicationEnvelope;
+    readonly waitForOutput: (guid: string) => Promise<void>;
+    readonly timeoutMs?: number;
+    readonly lastKnownGood?: ScenePublicationFence;
+}): Promise<Result<ScenePublicationObservation, ScenePublicationFenceError>>;
+//# sourceMappingURL=scene-publication-fence.d.ts.map

package/dist/registry/scene-publication-fence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-publication-fence.d.ts","sourceRoot":"","sources":["../../src/registry/scene-publication-fence.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EACV,wBAAwB,EACxB,YAAY,EACZ,qBAAqB,IAAI,2BAA2B,EACrD,MAAM,uBAAuB,CAAC;AAE/B,eAAO,MAAM,8BAA8B,EAAG,2BAAoC,CAAC;AACnF,eAAO,MAAM,kCAAkC,wEAIpC,CAAC;AAEZ,MAAM,MAAM,qBAAqB,GAAG,2BAA2B,CAAC;AAEhE,MAAM,MAAM,0BAA0B,GAAG,aAAa,GAAG,SAAS,GAAG,aAAa,GAAG,aAAa,CAAC;AAEnG,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,iCAAiC,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,0BAA0B,CAAC;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,qBAAqB,CAAC;IACxC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,aAAa,CAAC,EAAE,qBAAqB,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAkDD,iFAAiF;AACjF,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,wBAAwB,GACpC,MAAM,CAAC,qBAAqB,EAAE,0BAA0B,CAAC,CA4C3D;AAED,gFAAgF;AAChF,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,MAAM,CAAC,qBAAqB,EAAE,0BAA0B,CAAC,CA0B3D;AAED,kFAAkF;AAClF,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,EAAE,qBAAqB,EAC7B,aAAa,CAAC,EAAE,qBAAqB,GACpC,MAAM,CAAC,qBAAqB,EAAE,0BAA0B,CAAC,CAW3D;AAED,oGAAoG;AACpG,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,qBAAqB,EAAE,0BAA0B,CAAC,CAyB3D;AAED,wBAAsB,uBAAuB,CAAC,KAAK,EAAE;IACnD,QAAQ,CAAC,WAAW,EAAE,wBAAwB,CAAC;IAC/C,QAAQ,CAAC,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,qBAAqB,CAAC;CAChD,GAAG,OAAO,CAAC,MAAM,CAAC,2BAA2B,EAAE,0BAA0B,CAAC,CAAC,CAoC3E"}

package/dist/registry/validate-material.d.ts

@@ -0,0 +1,77 @@
+import type { CookedMaterialRecord } from '@forgeax/engine-pack';
+import { AssetError, type MaterialAsset, type MaterialError } from '@forgeax/engine-types';
+import type { AssetRegistry } from '../asset-registry';
+/**
+ * Validate a MaterialAsset's passes[] against the ShaderRegistry's
+ * paramSchema (union semantics: all declared params across all passes
+ * must be satisfiable from values).
+ *
+ * - Empty / undefined passes[] → error
+ * - Each pass's shader must exist in ShaderRegistry
+ * - Union of all pass paramSchemas: params without `default` must
+ *   appear in values with matching type
+ * - Extra keys in values are silently ignored (D-5)
+ *
+ * @returns AssetError on failure, null on success
+ */
+export declare function validateMaterialPasses(registry: AssetRegistry, asset: MaterialAsset): AssetError | null;
+export interface MaterialEffectiveRootIdentity {
+    readonly guid: string;
+    readonly layoutIdentity: string;
+}
+export declare function validateMaterialCookIdentity(record: Pick<CookedMaterialRecord, 'guid' | 'receipt'>, root: MaterialEffectiveRootIdentity): MaterialError | null;
+/**
+ * Sprite 9-slice values fail-fast validation
+ * (feat-20260527-sprite-nineslice M2 / w8, plan-strategy §D-1 + AC-08).
+ *
+ * Fires when:
+ *  - asset.kind === 'material'
+ *  - first pass shader === 'forgeax::sprite'
+ *  - values.slices is present
+ *
+ * Six fail-fast branches (1:1 with w4 test):
+ *   (1) any component is negative
+ *   (2) slices.x + slices.z >= region.zw[0]   (X-axis overlap)
+ *   (3) slices.y + slices.w >= region.zw[1]   (Y-axis overlap)
+ *   (4) any component is NaN
+ *   (5) any component is Infinity
+ *   (6) length !== 4
+ *
+ * Reuses the existing 'asset-invalid-value' member of the closed
+ * `AssetErrorCode` 13-member union (no new code added per
+ * AGENTS.md §Error model). The `.expected` literal mirrors the AI-User
+ * Charter §3 string; `.hint` inlines the offending sum + the relevant
+ * `region.zw` numeral so AI users can copy-paste the prompt straight
+ * back into the IDE for self-recovery (plan-strategy §R-4).
+ *
+ * @returns AssetError on failure, null on success.
+ */
+export declare function validateSpriteSlices(_registry: AssetRegistry, asset: MaterialAsset): AssetError | null;
+export declare function validateParamType(_registry: AssetRegistry, _name: string, type: string, value: unknown): boolean;
+/**
+ * feat-20260527-sprite-nineslice M4 / w18 (D-9): register-time soft-warn
+ * for sliceMode=1 (tile) bound to a sampler whose addressMode is not
+ * 'repeat'. Bumps `nineslice.tile-needs-repeat-sampler` once per offending
+ * catalogue call. Never throws -- the counter is the sole AI-user-facing
+ * signal (charter P3 machine-readable; AC-08 closed, never extends
+ * AssetErrorCode).
+ *
+ * feat-20260614 M8 (D-19): `values.sampler` is now an embedded GUID
+ * string (dash-form), resolved against the catalogue rather than a handle.
+ */
+export declare function detectTileNeedsRepeatSampler(registry: AssetRegistry, asset: MaterialAsset): void;
+/**
+ * feat-20260613-material-paramschema-driven-binding M4 / w23 (D-5 graceful):
+ * Return the texture-field name set for the given material-shader id,
+ * derived from the registered shader's paramSchema via `derive(paramSchema)
+ * .textureFieldNames`. Returns `undefined` when the shader is not yet
+ * registered (cross-worktree shader-late-register, plan R-4).
+ *
+ * Used by `extractFrame` to know which values fields the shader
+ * declares as texture handles; the extract layer validates handle-vs-
+ * scalar typing and drops misclassified slots so the record stage's
+ * MISSING_TEXTURE_HANDLE fallback can take over (white default texture)
+ * rather than letting a stray handle reach `device.createBindGroup`.
+ */
+export declare function materialShaderTextureFieldNames(registry: AssetRegistry, shaderId: string): ReadonlySet<string> | undefined;
+//# sourceMappingURL=validate-material.d.ts.map

package/dist/registry/validate-material.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-material.d.ts","sourceRoot":"","sources":["../../src/registry/validate-material.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EACL,UAAU,EAEV,KAAK,aAAa,EAClB,KAAK,aAAa,EAEnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,aAAa,GACnB,UAAU,GAAG,IAAI,CAoFnB;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC,EACtD,IAAI,EAAE,6BAA6B,GAClC,aAAa,GAAG,IAAI,CAiBtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,aAAa,GACnB,UAAU,GAAG,IAAI,CA8GnB;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,GACb,OAAO,CAgCT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,IAAI,CA8BhG;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,aAAa,EACvB,QAAQ,EAAE,MAAM,GACf,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,CAIjC"}

package/dist/resolve-asset-handle.d.ts

@@ -0,0 +1,43 @@
+import type { SharedRefStaleError, UniqueRefStaleError, World } from '@forgeax/engine-ecs';
+import type { AssetGuid } from '@forgeax/engine-pack/guid';
+import { type Result } from '@forgeax/engine-rhi';
+import type { Asset, AssetError as AssetErrorType, Handle, MaterialAsset, MaterialError, MaterialPass } from '@forgeax/engine-types';
+/**
+ * Resolve a handle to its asset payload with two-tier slot-range dispatch.
+ *
+ *   slot <  BUILTIN_BASE -> BuiltinAssetRegistry.resolve(handle) (process-static)
+ *   slot >= BUILTIN_BASE -> world.sharedRefs.resolve(handle)     (user-tier RC)
+ *
+ * Callers must specify the expected asset type explicitly:
+ * `resolveAssetHandle<MeshAsset>(world, handle)`. The type parameter is an
+ * assertion -- the runtime dispatch returns the correct payload based on slot
+ * range; the type parameter mirrors the caller's expectation.
+ *
+ * @param world - The World owning the per-World SharedRefStore (user-tier).
+ * @param handle - The branded handle to resolve.
+ * @returns `Result.ok(payload)` on hit, `Result.err(AssetError)` on miss.
+ */
+export declare function resolveAssetHandle<T extends Asset>(world: World, handle: Handle<string, 'shared'>): Result<T, AssetErrorType | SharedRefStaleError | UniqueRefStaleError>;
+/**
+ * Walk a MaterialAsset parent chain to produce the inherited passes +
+ * shallow-merged values (W-1..W-7 semantics). feat-20260614 M8 (D-19):
+ * the starting material is resolved from a column `handle` via
+ * {@link resolveAssetHandle} (builtin / user-tier world.sharedRefs); each
+ * ancestor `material.parent` is an embedded GUID (AssetGuid) resolved through
+ * the AssetRegistry catalogue ({@link AssetRegistry.lookup}). The registry
+ * holds no handles -- it is the GUID->payload SSOT for parent resolution.
+ *
+ * Zero-cache (AC-04): every call builds the same table-shaped input and delegates
+ * inheritance semantics to the MaterialAsset resolver in `@forgeax/engine-types`.
+ * Compiler and runtime therefore share root-contract ownership and child-value
+ * override semantics instead of maintaining two subtly different walks.
+ */
+export declare function walkMaterialPassesOverSharedRefs(world: World, handle: Handle<'MaterialAsset', 'shared'>, registry: {
+    lookup(guid: AssetGuid | string): Asset | undefined;
+}): Result<{
+    passes: MaterialPass[];
+    parameters: MaterialAsset['parameters'];
+    values: NonNullable<MaterialAsset['values']>;
+    colorSpace: MaterialAsset['colorSpace'];
+}, AssetErrorType | MaterialError | SharedRefStaleError | UniqueRefStaleError>;
+//# sourceMappingURL=resolve-asset-handle.d.ts.map

package/dist/resolve-asset-handle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-asset-handle.d.ts","sourceRoot":"","sources":["../src/resolve-asset-handle.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC3F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EACV,KAAK,EACL,UAAU,IAAI,cAAc,EAC5B,MAAM,EACN,aAAa,EACb,aAAa,EACb,YAAY,EACb,MAAM,uBAAuB,CAAC;AAW/B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,KAAK,EAChD,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAC/B,MAAM,CAAC,CAAC,EAAE,cAAc,GAAG,mBAAmB,GAAG,mBAAmB,CAAC,CAiCvE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,CAAC,eAAe,EAAE,QAAQ,CAAC,EACzC,QAAQ,EAAE;IAAE,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,CAAA;CAAE,GAChE,MAAM,CACP;IACE,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,UAAU,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IACxC,MAAM,EAAE,WAAW,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC7C,UAAU,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;CACzC,EACD,cAAc,GAAG,aAAa,GAAG,mBAAmB,GAAG,mBAAmB,CAC3E,CA+BA"}

package/dist/resolve-tileset-runtime.d.ts

@@ -0,0 +1,23 @@
+import type { World } from '@forgeax/engine-ecs';
+import type { Asset, Handle, Result, TextureAsset } from '@forgeax/engine-types';
+export type TilesetRuntimeErrorCode = 'tileset-atlas-not-found' | 'tileset-atlas-stale' | 'tileset-atlas-kind-mismatch';
+export interface TilesetRuntimeError {
+    readonly code: TilesetRuntimeErrorCode;
+    readonly expected: string;
+    readonly hint: string;
+    readonly detail: {
+        readonly guid: string;
+        readonly actualKind?: string;
+    };
+}
+export interface ResolvedTilesetRuntime {
+    readonly guid: string;
+    readonly payload: TextureAsset;
+    readonly handle: Handle<'TextureAsset', 'shared'>;
+}
+export type TilesetAtlasLookup = Asset | {
+    readonly code: 'stale';
+} | undefined;
+/** Project one durable atlas GUID into the current World at the tilemap owner. */
+export declare function resolveTilesetRuntime(world: World, guid: string, lookup: (guid: string) => TilesetAtlasLookup): Result<ResolvedTilesetRuntime, TilesetRuntimeError>;
+//# sourceMappingURL=resolve-tileset-runtime.d.ts.map

package/dist/resolve-tileset-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-tileset-runtime.d.ts","sourceRoot":"","sources":["../src/resolve-tileset-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGjF,MAAM,MAAM,uBAAuB,GAC/B,yBAAyB,GACzB,qBAAqB,GACrB,6BAA6B,CAAC;AAElC,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE;QACf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;KAC9B,CAAC;CACH;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;CACnD;AAED,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CAAC;AAEhF,kFAAkF;AAClF,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,kBAAkB,GAC3C,MAAM,CAAC,sBAAsB,EAAE,mBAAmB,CAAC,CAuCrD"}

package/dist/scene-handle-fields.d.ts

@@ -0,0 +1,88 @@
+import type { Component } from '@forgeax/engine-ecs';
+import type { MountOverride } from '@forgeax/engine-types';
+/**
+ * A single handle-field reference extracted from a SceneAsset entity.
+ *
+ * `entityLocalId` is the `node.localId`; `componentName` and `fieldName`
+ * identify the schema field whose `fieldType` starts with `shared\<` or
+ * `array\<shared\<`. `guidString` is the raw GUID string value from the
+ * entity's component data (NOT a parsed `AssetGuid` — callers parse or
+ * resolve as needed).
+ *
+ * `arrayIndex` is `undefined` for plain `handle<T>` fields; for
+ * `array<handle<T>>` fields it is the 0-based index into the array.
+ */
+export interface SceneHandleFieldEntry {
+    readonly entityLocalId: number;
+    readonly componentName: string;
+    readonly fieldName: string;
+    readonly guidString: string;
+    /** 0-based index for `array<handle<T>>` elements; `undefined` for plain `handle<T>` fields. */
+    readonly arrayIndex?: number;
+}
+/**
+ * Shape of a single entity passed to {@link extractSceneEntityHandleGuids}.
+ *
+ * Compatible with both `SceneEntity` (from `@forgeax/engine-types`, where
+ * `components` is `Partial<ComponentValuesMap>`) and test-side plain objects.
+ */
+interface SceneEntityLike {
+    readonly localId: number;
+    readonly components: Record<string, Record<string, unknown>>;
+}
+/**
+ * Walk every `SceneEntityLike` in `entities` and extract all GUID strings
+ * bound to schema fields with `handle<...>` or `array<handle<...>>` fieldType.
+ *
+ * Unknown component names (absent from the supplied World-local catalog) are
+ * silently skipped — the ecs layer's `additionalProperties` check will catch
+ * unknowns at spawn time if appropriate.
+ *
+ * Values that are already numbers (resolved Handles) or non-strings are
+ * skipped (they are not GUID refs).
+ *
+ * @internal Shared by {@link AssetRegistry._resolveSceneGuids} and
+ * `buildSceneChildContext` as the entity-walk fallback used when the structured
+ * `envelope.refs` edges are unavailable or carry no per-entity detail.
+ */
+export declare function extractSceneEntityHandleGuids(components: ReadonlyMap<string, Component>, entities: ReadonlyArray<SceneEntityLike>): SceneHandleFieldEntry[];
+/**
+ * One handle-field GUID reference extracted from a {@link MountOverride}'s value
+ * (feat-20260713 M3 / w12). Mirrors {@link SceneHandleFieldEntry} but keys on the
+ * override's array index (there is no entity `localId` — an override targets a
+ * mount member by its own `localId`, resolved by the ecs apply loop, not here).
+ *
+ * `fieldName` is the schema field the GUID binds to: the override's own `field`
+ * for the patch form, or a key of the component-add value map for the add form.
+ */
+export interface MountOverrideHandleFieldEntry {
+    /** 0-based index into the `overrides[]` array passed to the extractor. */
+    readonly overrideIndex: number;
+    readonly componentName: string;
+    readonly fieldName: string;
+    readonly guidString: string;
+    /** 0-based index for `array<shared<T>>` elements; `undefined` for scalar `shared<T>`. */
+    readonly arrayIndex?: number;
+}
+/**
+ * Walk `overrides` and extract every GUID string bound to a `shared<...>` /
+ * `array<shared<...>>` schema field inside each override's value (feat-20260713
+ * M3 / w12, plan-strategy D-2). This is the apply-side counterpart to
+ * {@link extractSceneEntityHandleGuids}: it feeds `resolveMountsRec`'s
+ * GUID→handle down-drill so a `mounts[].overrides[].value` carrying a raw GUID
+ * (e.g. an `AnimationPlayer.clips` clip GUID) resolves to a live handle before
+ * the ecs apply loop, which only ever sees numeric handles (D-2: the GUID domain
+ * stays sealed in assets-runtime).
+ *
+ * The `{comp, field?, value}` discriminant is normalized to `(fieldName, value)`
+ * pairs: the patch form (`field` present) yields one pair; the component-add form
+ * (`field` absent, `value` is a per-field map) yields one pair per value key.
+ * Field type is judged from the supplied catalog token schema, the same
+ * schema SSOT the entity walk uses. Unknown components / non-shared fields /
+ * non-string (already-resolved number) values are skipped (D-8 number pass-through).
+ *
+ * @internal Shared identification core; resolution lives in `resolveMountsRec`.
+ */
+export declare function extractMountOverrideHandleGuids(components: ReadonlyMap<string, Component>, overrides: ReadonlyArray<MountOverride>): MountOverrideHandleFieldEntry[];
+export {};
+//# sourceMappingURL=scene-handle-fields.d.ts.map

package/dist/scene-handle-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-handle-fields.d.ts","sourceRoot":"","sources":["../src/scene-handle-fields.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,+FAA+F;IAC/F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,UAAU,eAAe;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC9D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1C,QAAQ,EAAE,aAAa,CAAC,eAAe,CAAC,GACvC,qBAAqB,EAAE,CAmCzB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,6BAA6B;IAC5C,0EAA0E;IAC1E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,yFAAyF;IACzF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1C,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC,GACtC,6BAA6B,EAAE,CAwBjC"}

package/dist/scene-payload.d.ts

@@ -0,0 +1,15 @@
+import type { SceneAsset } from '@forgeax/engine-types';
+/**
+ * Structured error returned by parseScenePayload when a refs index is
+ * out of bounds (F-2 / AC-02).
+ */
+interface ParseSceneError {
+    readonly localId: number;
+    readonly component: string;
+    readonly field: string;
+    readonly index: number;
+    readonly refsLength: number;
+}
+export declare function parseScenePayload(payload: Record<string, unknown>, refs?: string[]): SceneAsset | ParseSceneError | undefined;
+export {};
+//# sourceMappingURL=scene-payload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scene-payload.d.ts","sourceRoot":"","sources":["../src/scene-payload.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,UAAU,EAGX,MAAM,uBAAuB,CAAC;AAG/B;;;GAGG;AACH,UAAU,eAAe;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAsBD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,IAAI,CAAC,EAAE,MAAM,EAAE,GACd,UAAU,GAAG,eAAe,GAAG,SAAS,CAoG1C"}

package/dist/wire-default-loaders.d.ts

@@ -0,0 +1,29 @@
+import type { Loader } from '@forgeax/engine-types';
+import { LoaderRegistry } from './loader-registry';
+/**
+ * Wire the engine's default loader set (16 ordinary kinds plus UI) plus any
+ * `extraLoaders` onto `registry` in
+ * one call. Returns the same `registry` for chaining (so `wireDefaultLoaders(new
+ * LoaderRegistry())` is a one-expression wired registry). The `extraLoaders` are
+ * appended after the defaults and must use kinds outside the ordinary set.
+ *
+ * @example
+ * ```ts
+ * import { LoaderRegistry, wireDefaultLoaders } from '@forgeax/engine-assets-runtime';
+ * const loaders = wireDefaultLoaders(new LoaderRegistry());
+ * // loaders.get('mesh') / .get('texture') / .get('font') / .get('video') are
+ * // non-undefined; all ordinary Asset kinds share this same owner table.
+ * ```
+ */
+export declare function wireDefaultLoaders(registry: LoaderRegistry, extraLoaders?: readonly Loader[]): LoaderRegistry;
+/**
+ * Convenience factory: a fresh `LoaderRegistry` pre-wired with the default
+ * loader set (plus any `extraLoaders`). The production assembly point
+ * (`createRenderer`) and tests pass the result into `new LoaderRegistry()` (D-7
+ * constructor-injection; loaders always wired at construction -- used by
+ * `AssetRegistry` internally via `createDefaultLoaderRegistry(extraLoaders)` and
+ * by host code / tests independently) -- no setter / no illegal intermediate
+ * state).
+ */
+export declare function createDefaultLoaderRegistry(extraLoaders?: readonly Loader[]): LoaderRegistry;
+//# sourceMappingURL=wire-default-loaders.d.ts.map

package/dist/wire-default-loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire-default-loaders.d.ts","sourceRoot":"","sources":["../src/wire-default-loaders.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAanD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,cAAc,EACxB,YAAY,GAAE,SAAS,MAAM,EAAO,GACnC,cAAc,CAahB;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,GAAE,SAAS,MAAM,EAAO,GAAG,cAAc,CAEhG"}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@forgeax/engine-assets-runtime",
+  "version": "0.0.0-dev.8d955ade1c79",
+  "private": false,
+  "type": "module",
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "description": "Asset registry, loader registry, GUID resolution, and default loader wiring for forgeax-engine (Tier 2.1 -- extracted from @forgeax/engine-runtime).",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@forgeax/engine-codec": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-ecs": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-geometry": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-graphics-extras": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-image": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-pack": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-plugin": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-rhi": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-scene": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-shader": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-types": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-ui": "0.0.0-dev.8d955ade1c79",
+    "@webgpu/types": "^0.1.71"
+  },
+  "devDependencies": {
+    "@forgeax/engine-skinning": "0.0.0-dev.8d955ade1c79",
+    "@webgpu/types": "^0.1.71"
+  },
+  "forgeax": {
+    "metrics": {
+      "bundle-size": {
+        "enabled": true,
+        "path": "dist/index.mjs",
+        "compression": "gzip"
+      },
+      "fps": {
+        "enabled": false,
+        "reason": "asset registry / loader library, no runtime canvas; fps reported by hello-* apps that consume it"
+      },
+      "bench": {
+        "enabled": false,
+        "reason": "asset catalogue + load pipeline run at asset-load time, not per-frame; no CI micro-benchmark warranted"
+      },
+      "gate": {
+        "enabled": false,
+        "reason": "no package-level binary gate; smoke gate covered by hello-* / learn-render apps that load assets by GUID"
+      },
+      "spike-report": {
+        "enabled": false,
+        "reason": "not a spike package; asset cluster extracted from runtime in feat-20260705-runtime-tier2-decomposition"
+      }
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run"
+  }
+}

package/src/__tests__/aabb.unit.test.ts

@@ -0,0 +1,97 @@
+// @forgeax/engine-assets-runtime -- withMeshAabb / computeAABB coverage
+// (fix issue #709: assets-runtime src entered the coverage pool via the
+// package's own tests importing `../` relative paths -> src; before this the
+// module was only exercised through the compiled dist by runtime-project
+// tests, which are excluded from the coverage denominator).
+
+import type { MeshAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { withMeshAabb } from '../aabb';
+
+const EMPTY_BOX = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+
+function meshWith(position: Float32Array | ArrayBuffer | undefined): MeshAsset {
+  return {
+    kind: 'mesh',
+    vertices: new Float32Array(0),
+    attributes: position === undefined ? {} : { position },
+    submeshes: [
+      { indexOffset: 0, indexCount: 0, vertexCount: 0, topology: 'triangle-list', materialSlot: 0 },
+    ],
+    materialSlots: [{ slotName: 'Default' }],
+  } as MeshAsset;
+}
+
+describe('withMeshAabb', () => {
+  it('computes [min, max] over every (x, y, z) triple of the position attribute', () => {
+    const position = Float32Array.of(
+      -1,
+      -2,
+      -3, //
+      4,
+      5,
+      6, //
+      0,
+      0,
+      0,
+    );
+    const out = withMeshAabb(meshWith(position));
+    expect(Array.from(out.aabb as Float32Array)).toEqual([-1, -2, -3, 4, 5, 6]);
+  });
+
+  it('handles a single-vertex mesh (min === max === that vertex)', () => {
+    const out = withMeshAabb(meshWith(Float32Array.of(7, 8, 9)));
+    expect(Array.from(out.aabb as Float32Array)).toEqual([7, 8, 9, 7, 8, 9]);
+  });
+
+  it('re-wraps an ArrayBuffer position buffer as Float32Array', () => {
+    const buf = Float32Array.of(1, 1, 1, 2, 3, 4).buffer;
+    const out = withMeshAabb(meshWith(buf));
+    expect(Array.from(out.aabb as Float32Array)).toEqual([1, 1, 1, 2, 3, 4]);
+  });
+
+  it('returns the inverted-infinity empty box when position is absent', () => {
+    const out = withMeshAabb(meshWith(undefined));
+    expect(Array.from(out.aabb as Float32Array)).toEqual(EMPTY_BOX);
+  });
+
+  it('returns the empty box when position has fewer than 3 floats', () => {
+    const out = withMeshAabb(meshWith(Float32Array.of(1, 2)));
+    expect(Array.from(out.aabb as Float32Array)).toEqual(EMPTY_BOX);
+  });
+
+  it('returns the empty box for a Uint16Array position (treated as absent)', () => {
+    const mesh = {
+      kind: 'mesh',
+      vertices: new Float32Array(0),
+      attributes: { position: Uint16Array.of(1, 2, 3) },
+      submeshes: [{ indexOffset: 0, indexCount: 0, vertexCount: 0, topology: 'triangle-list' }],
+    } as unknown as MeshAsset;
+    const out = withMeshAabb(mesh);
+    expect(Array.from(out.aabb as Float32Array)).toEqual(EMPTY_BOX);
+  });
+
+  it('preserves a packed AABB when the binary path omits position attributes', () => {
+    const mesh = {
+      ...meshWith(undefined),
+      aabb: Float32Array.of(-2, 0, -1, 3, 4, 5),
+    };
+    const out = withMeshAabb(mesh);
+    expect(Array.from(out.aabb as Float32Array)).toEqual([-2, 0, -1, 3, 4, 5]);
+  });
+
+  it('mutates the mesh in place when it is extensible (returns same reference)', () => {
+    const mesh = meshWith(Float32Array.of(0, 0, 0, 1, 1, 1));
+    const out = withMeshAabb(mesh);
+    expect(out).toBe(mesh);
+    expect(mesh.aabb).toBeInstanceOf(Float32Array);
+  });
+
+  it('returns a shallow copy carrying the aabb when the mesh is frozen', () => {
+    const mesh = Object.freeze(meshWith(Float32Array.of(0, 0, 0, 2, 2, 2)));
+    const out = withMeshAabb(mesh);
+    expect(out).not.toBe(mesh);
+    expect(Array.from(out.aabb as Float32Array)).toEqual([0, 0, 0, 2, 2, 2]);
+    expect(mesh.aabb).toBeUndefined();
+  });
+});