@forgeax/engine-render 0.1.34 → 0.1.35

package/dist/scene/render-source.d.ts

@@ -0,0 +1,42 @@
+import type { Component, EntityHandle, Query, World } from '@forgeax/engine-ecs';
+import { GlobalTransform } from '@forgeax/engine-scene';
+export type GlobalTransformChangeQuery = Query<readonly [typeof GlobalTransform]>;
+export declare const RENDERABLE_SOURCE_COMPONENTS: readonly [Component<"ChildOf", {
+    parent: "entity";
+}>, Component<"MeshFilter", {
+    readonly assetHandle: "shared<MeshAsset>";
+}>, Component<"MeshRenderer", {
+    readonly materials: "array<shared<MaterialAsset>>";
+}>, Component<"Instances", {
+    readonly transforms: "array<f32>";
+}>, Component<"SpriteInstances", {
+    readonly transforms: "array<f32>";
+    readonly regions: "array<f32>";
+}>, Component<"SpriteRegionOverride", {
+    readonly region: "array<f32, 4>";
+}>, Component<"Skin", {
+    readonly skeleton: "shared<SkeletonAsset>";
+    readonly joints: "array<entity>";
+}>, Component<"Layer", {
+    readonly value: "i32";
+}>, Component<"Visibility", {
+    readonly state: "enum";
+}>, Component<"MorphWeights", {
+    readonly weights: "array<f32>";
+}>, Component<"Points", {
+    readonly sizePx: "f32";
+    readonly shape: "enum";
+}>, Component<"Lines", {
+    readonly widthPx: "f32";
+}>, Component<"SortKey", {
+    readonly value: "f32";
+}>];
+export declare function createGlobalTransformChangeQuery(world: World): GlobalTransformChangeQuery;
+export declare function createRenderSourceState(world: World, additional?: readonly Component[]): {
+    projection: import("@forgeax/engine-ecs/projection").StateProjection;
+    entities: Map<number, EntityHandle>;
+    contentHandles: Map<number, readonly number[]>;
+    batch: import("@forgeax/engine-ecs/projection").StateProjectionBatch;
+};
+export declare function isRenderableMember(world: World, entity: number): boolean;
+//# sourceMappingURL=render-source.d.ts.map

package/dist/scene/render-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-source.d.ts","sourceRoot":"","sources":["../../src/scene/render-source.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjF,OAAO,EAAW,eAAe,EAA2B,MAAM,uBAAuB,CAAC;AAc1F,MAAM,MAAM,0BAA0B,GAAG,KAAK,CAAC,SAAS,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC;AAKlF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAc/B,CAAC;AACX,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,KAAK,GAAG,0BAA0B,CAQzF;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,GAAE,SAAS,SAAS,EAAO;;;;;EAkC1F;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAMxE"}

package/dist/scene/source-systems.d.ts

@@ -0,0 +1,6 @@
+import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { type World } from '@forgeax/engine-ecs';
+import type { GpuResidencyCache } from '../device/gpu-residency';
+/** Derived authoring stays beside World; only completed mesh data reaches the Renderer. */
+export declare function registerRenderSourceSystems(world: World, assets: AssetRegistry, meshes: Pick<GpuResidencyCache, 'updateMesh'>): () => void;
+//# sourceMappingURL=source-systems.d.ts.map

package/dist/scene/source-systems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-systems.d.ts","sourceRoot":"","sources":["../../src/scene/source-systems.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAU,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAKjE,2FAA2F;AAC3F,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,GAC5C,MAAM,IAAI,CAmBZ"}

package/dist/systems/skin-palette-allocator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skin-palette-allocator.d.ts","sourceRoot":"","sources":["../../src/systems/skin-palette-allocator.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,KAAK,EAAU,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAO7D,OAAO,KAAK,EAEV,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAuB9B,MAAM,WAAW,oBAAoB;IACnC,mFAAmF;IACnF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,+EAA+E;IAC/E,uBAAuB,CAAC,KAAK,EAAE;QAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;KAChC,GAAG,kBAAkB,CAAC;IACvB;;;;OAIG;IACH,uBAAuB,CACrB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,SAAS,YAAY,EAAE,EAC7B,WAAW,EAAE,SAAS,IAAI,EAAE,GAC3B,SAAS,MAAM,EAAE,CAAC;IACrB,+EAA+E;IAC/E,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IACnE,0EAA0E;IAC1E,UAAU,IAAI,IAAI,CAAC;IACnB,sEAAsE;IACtE,QAAQ,IAAI,IAAI,CAAC;IACjB,uEAAuE;IACvE,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C;;;;;;;;;;OAUG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACpD;;;;;;;;OAQG;IACH,iBAAiB,CACf,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,SAAS,YAAY,EAAE,EAC7B,WAAW,EAAE,SAAS,IAAI,EAAE,GAC3B,IAAI,CAAC;IACR,mEAAmE;IACnE,2BAA2B,CACzB,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,SAAS,YAAY,EAAE,EAC7B,WAAW,EAAE,SAAS,IAAI,EAAE,GAC3B,IAAI,CAAC;IACR;;;;OAIG;IACH,aAAa,IAAI,IAAI,CAAC;IACtB,wEAAwE;IACxE,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,cAAc,EAAE,MAAM,EACtB,gBAAgB,UAAO,GACtB,oBAAoB,CAyiBtB"}
+{"version":3,"file":"skin-palette-allocator.d.ts","sourceRoot":"","sources":["../../src/systems/skin-palette-allocator.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,KAAK,EAAU,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAO7D,OAAO,KAAK,EAEV,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAuB9B,MAAM,WAAW,oBAAoB;IACnC,mFAAmF;IACnF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,+EAA+E;IAC/E,uBAAuB,CAAC,KAAK,EAAE;QAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;KAChC,GAAG,kBAAkB,CAAC;IACvB;;;;OAIG;IACH,uBAAuB,CACrB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,SAAS,YAAY,EAAE,EAC7B,WAAW,EAAE,SAAS,IAAI,EAAE,GAC3B,SAAS,MAAM,EAAE,CAAC;IACrB,+EAA+E;IAC/E,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IACnE,0EAA0E;IAC1E,UAAU,IAAI,IAAI,CAAC;IACnB,sEAAsE;IACtE,QAAQ,IAAI,IAAI,CAAC;IACjB,uEAAuE;IACvE,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C;;;;;;;;;;OAUG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACpD;;;;;;;;OAQG;IACH,iBAAiB,CACf,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,SAAS,YAAY,EAAE,EAC7B,WAAW,EAAE,SAAS,IAAI,EAAE,GAC3B,IAAI,CAAC;IACR,mEAAmE;IACnE,2BAA2B,CACzB,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,SAAS,YAAY,EAAE,EAC7B,WAAW,EAAE,SAAS,IAAI,EAAE,GAC3B,IAAI,CAAC;IACR;;;;OAIG;IACH,aAAa,IAAI,IAAI,CAAC;IACtB,wEAAwE;IACxE,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,cAAc,EAAE,MAAM,EACtB,gBAAgB,UAAO,GACtB,oBAAoB,CA0iBtB"}

package/dist/systems/skin-palette-types.d.ts

@@ -1,3 +1,4 @@
+import type { Mat4 } from '@forgeax/engine-math';
 import type { Buffer } from '@forgeax/engine-rhi';
 /**
  * Per-draw palette slice metadata shared by the extract producer and the
@@ -26,4 +27,13 @@ export interface SkinPaletteReceipt extends SkinPaletteSlice {
     readonly uploadBytes: number;
     readonly retiredByteOffset?: number;
 }
+/** Frozen source facts; GPU addresses are assigned only by the consuming Renderer. */
+export interface SkinPose {
+    readonly identity: string;
+    readonly generation: number;
+    readonly jointCount: number;
+    readonly bounds?: Float32Array;
+    readonly inverseBindMatrices: readonly Float32Array[];
+    readonly jointWorlds: readonly Mat4[];
+}
 //# sourceMappingURL=skin-palette-types.d.ts.map

package/dist/systems/skin-palette-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skin-palette-types.d.ts","sourceRoot":"","sources":["../../src/systems/skin-palette-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,kBAAmB,SAAQ,gBAAgB;IAC1D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACvD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACrC"}
+{"version":3,"file":"skin-palette-types.d.ts","sourceRoot":"","sources":["../../src/systems/skin-palette-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,kBAAmB,SAAQ,gBAAgB;IAC1D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACvD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACrC;AAED,sFAAsF;AACtF,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,mBAAmB,EAAE,SAAS,YAAY,EAAE,CAAC;IACtD,QAAQ,CAAC,WAAW,EAAE,SAAS,IAAI,EAAE,CAAC;CACvC"}

package/dist/systems/transparent-dispatch.d.ts

@@ -1,9 +1,9 @@
-import type { World } from '@forgeax/engine-ecs';
+import type { RenderResourceScope } from '../publication/resource-scope';
 import type { CameraSnapshot } from '../render-contract';
 import type { DispatchEntry, RenderableSnapshot } from '../render-system-extract';
 /**
  * Reorder only the transparent queue while preserving every opaque slot.
  * Equal depth/layer values use material identity as a fold-friendly tie break.
  */
-export declare function sortTransparentDispatch(dispatch: DispatchEntry[], world: World, cameras: readonly CameraSnapshot[], renderables: readonly RenderableSnapshot[]): DispatchEntry[];
+export declare function sortTransparentDispatch(dispatch: DispatchEntry[], world: RenderResourceScope, cameras: readonly CameraSnapshot[], renderables: readonly RenderableSnapshot[]): DispatchEntry[];
 //# sourceMappingURL=transparent-dispatch.d.ts.map

package/dist/systems/transparent-dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transparent-dispatch.d.ts","sourceRoot":"","sources":["../../src/systems/transparent-dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AASlF;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,aAAa,EAAE,EACzB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,WAAW,EAAE,SAAS,kBAAkB,EAAE,GACzC,aAAa,EAAE,CAoEjB"}
+{"version":3,"file":"transparent-dispatch.d.ts","sourceRoot":"","sources":["../../src/systems/transparent-dispatch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AASlF;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,aAAa,EAAE,EACzB,KAAK,EAAE,mBAAmB,EAC1B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,WAAW,EAAE,SAAS,kBAAkB,EAAE,GACzC,aAAa,EAAE,CAoEjB"}

package/dist/systems/transparent-sort-config.d.ts

@@ -1,3 +1,4 @@
+import type { RenderResourceScope } from '../publication/resource-scope';
 import type { World } from '@forgeax/engine-ecs';
 import { ResourceInvalidValueError } from '@forgeax/engine-ecs/projection';
 import { type Result } from '@forgeax/engine-types';
@@ -69,7 +70,7 @@ export declare const TransparentSort: Readonly<{
  *   const cfg = getTransparentSortConfig(world);
  *   // cfg.mode === 1, cfg.yzAlpha === 1.0 (yzAlpha ignored by mode=1).
  */
-export declare function getTransparentSortConfig(world: World): TransparentSortConfig;
+export declare function getTransparentSortConfig(world: RenderResourceScope): TransparentSortConfig;
 /**
  * Write the world's `TransparentSortConfig` resource, validating `mode`.
  *

package/dist/systems/transparent-sort-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transparent-sort-config.d.ts","sourceRoot":"","sources":["../../src/systems/transparent-sort-config.ts"],"names":[],"mappings":"AA0DA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAM7D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,gEAAgE;AAChE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C;AAED,+DAA+D;AAC/D,eAAO,MAAM,2BAA2B,EAAG,uBAAgC,CAAC;AAE5E,oDAAoD;AACpD,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAE/C,mFAAmF;AACnF,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAE/C,wFAAwF;AACxF,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,kFAAkF;AAClF,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,uEAAuE;AACvE,eAAO,MAAM,eAAe;;;;;;EAMjB,CAAC;AA8BZ;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,qBAAqB,CAK5E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,qBAAqB,GACzB,MAAM,CAAC,IAAI,EAAE,yBAAyB,CAAC,CAczC"}
+{"version":3,"file":"transparent-sort-config.d.ts","sourceRoot":"","sources":["../../src/systems/transparent-sort-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AA2DzE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAM7D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,gEAAgE;AAChE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C;AAED,+DAA+D;AAC/D,eAAO,MAAM,2BAA2B,EAAG,uBAAgC,CAAC;AAE5E,oDAAoD;AACpD,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAE/C,mFAAmF;AACnF,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAE/C,wFAAwF;AACxF,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,kFAAkF;AAClF,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,uEAAuE;AACvE,eAAO,MAAM,eAAe;;;;;;EAMjB,CAAC;AA8BZ;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,mBAAmB,GAAG,qBAAqB,CAM1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,qBAAqB,GACzB,MAAM,CAAC,IAAI,EAAE,yBAAyB,CAAC,CAczC"}

package/dist/temporal/index.mjs

@@ -1,9 +1,8 @@
-export { addStandardSceneDataPass, addTaaResolvePass, aggregateTemporalDemand, createStandardSceneDataTarget, describeTemporalDemand, standardTemporalLaneAdmission, standardTemporalPostOrder } from '../chunk-MKDIT2EM.mjs';
-import '../chunk-RXZ3RGOU.mjs';
-export { SCENE_DATA_TEMPORAL_V1_DESCRIPTOR, SCENE_DATA_TEMPORAL_V1_SCHEMA, createSceneDataCatalog, isSceneDataTarget, registerSceneDataTarget, sceneDataError, sceneDataTargetAsAttachment, sceneDataTargetOwner, sceneDataTokenMismatch } from '../chunk-OCDLEI6I.mjs';
-import '../chunk-BLXGONR2.mjs';
-export { TEMPORAL_JITTER_SAMPLE_COUNT, TEMPORAL_TAAU_DEPENDENCY_STATUS, TemporalFrameCoordinator, projectTemporalView, snapshotSubmittedTemporalView, temporalJitterSample, temporalViewId } from '../chunk-HEB564WF.mjs';
-export { classifySceneDataCoverage, createTemporalCoverage, scanSceneDataCoverage } from '../chunk-SHFUFJ5N.mjs';
-import '../chunk-WEX45HKH.mjs';
+export { addStandardSceneDataPass, addTaaResolvePass, aggregateTemporalDemand, createStandardSceneDataTarget, describeTemporalDemand, standardTemporalLaneAdmission, standardTemporalPostOrder } from '../chunk-LNIUIKQ7.mjs';
+export { SCENE_DATA_TEMPORAL_V1_DESCRIPTOR, SCENE_DATA_TEMPORAL_V1_SCHEMA, createSceneDataCatalog, isSceneDataTarget, registerSceneDataTarget, sceneDataError, sceneDataTargetAsAttachment, sceneDataTargetOwner, sceneDataTokenMismatch } from '../chunk-SGPUJW3F.mjs';
+import '../chunk-XSFB7XXQ.mjs';
+export { TEMPORAL_JITTER_SAMPLE_COUNT, TEMPORAL_TAAU_DEPENDENCY_STATUS, TemporalFrameCoordinator, projectTemporalView, snapshotSubmittedTemporalView, temporalJitterSample, temporalViewId } from '../chunk-LM5IE7GF.mjs';
+export { classifySceneDataCoverage, createTemporalCoverage, scanSceneDataCoverage } from '../chunk-RIPAEGI6.mjs';
+import '../chunk-MXTWKZO4.mjs';
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-render",
-  "version": "0.1.34",
+  "version": "0.1.35",
   "description": "Canonical ECS render schemas and renderer boundary.",
   "private": false,
   "type": "module",
@@ -37,28 +37,28 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@forgeax/engine-assets-runtime": "0.1.34",
-    "@forgeax/engine-audio-webaudio": "0.1.34",
-    "@forgeax/engine-codec": "0.1.34",
-    "@forgeax/engine-ecs": "0.1.34",
-    "@forgeax/engine-geometry": "0.1.34",
-    "@forgeax/engine-graphics-extras": "0.1.34",
-    "@forgeax/engine-math": "0.1.34",
-    "@forgeax/engine-pack": "0.1.34",
-    "@forgeax/engine-plugin": "0.1.34",
-    "@forgeax/engine-profiler": "0.1.34",
-    "@forgeax/engine-render-graph": "0.1.34",
-    "@forgeax/engine-rhi": "0.1.34",
-    "@forgeax/engine-scene": "0.1.34",
-    "@forgeax/engine-shader": "0.1.34",
-    "@forgeax/engine-skinning": "0.1.34",
-    "@forgeax/engine-types": "0.1.34"
+    "@forgeax/engine-assets-runtime": "0.1.35",
+    "@forgeax/engine-audio-webaudio": "0.1.35",
+    "@forgeax/engine-codec": "0.1.35",
+    "@forgeax/engine-ecs": "0.1.35",
+    "@forgeax/engine-geometry": "0.1.35",
+    "@forgeax/engine-graphics-extras": "0.1.35",
+    "@forgeax/engine-math": "0.1.35",
+    "@forgeax/engine-pack": "0.1.35",
+    "@forgeax/engine-plugin": "0.1.35",
+    "@forgeax/engine-profiler": "0.1.35",
+    "@forgeax/engine-render-graph": "0.1.35",
+    "@forgeax/engine-rhi": "0.1.35",
+    "@forgeax/engine-scene": "0.1.35",
+    "@forgeax/engine-shader": "0.1.35",
+    "@forgeax/engine-skinning": "0.1.35",
+    "@forgeax/engine-types": "0.1.35"
   },
   "devDependencies": {
-    "@forgeax/engine-rhi-debug": "0.1.34",
-    "@forgeax/engine-rhi-null": "0.1.34",
-    "@forgeax/engine-rhi-webgpu": "0.1.34",
-    "@forgeax/engine-vite-plugin-shader": "0.1.34",
+    "@forgeax/engine-rhi-debug": "0.1.35",
+    "@forgeax/engine-rhi-null": "0.1.35",
+    "@forgeax/engine-rhi-webgpu": "0.1.35",
+    "@forgeax/engine-vite-plugin-shader": "0.1.35",
     "@webgpu/types": "^0.1.71"
   },
   "forgeax": {

package/src/__tests__/auto-exposure-transaction.integration.test.ts

@@ -1,5 +1,4 @@
-import { readFileSync } from 'node:fs';
-import { Time, World } from '@forgeax/engine-ecs';
+import { World } from '@forgeax/engine-ecs';
 import { describe, expect, it } from 'vitest';
 import {
   executeAutoExposureFrameTransaction,
@@ -10,10 +9,9 @@ import {
   commitAutoExposureSubmission,
   createAutoExposureState,
 } from '../pipeline/standard-output/auto-exposure/state';
+import { renderTime } from '../publication/resource-scope';
 import { canonicalizeWorldComposition } from '../render-system-projections';
 
-const renderSystemSource = readFileSync(new URL('../render-system.ts', import.meta.url), 'utf8');
-
 function candidate(): AutoExposureCandidate {
   return { ev: 1.25, generation: 4, deviceEpoch: 2, frameId: 9 };
 }
@@ -90,10 +88,7 @@ describe('auto exposure frame transaction', () => {
     const resolvedCameraWorld = composition.worlds[composition.owners.cameraOwner];
 
     expect(resolvedCameraWorld).toBe(cameraWorld);
-    expect(resolvedCameraWorld?.getResource(Time).delta).toBeCloseTo(1 / 30);
-    expect(renderSystemSource).toContain(
-      'const cameraWorld = compositionWorlds[cameraOwner] as World;',
-    );
-    expect(renderSystemSource).not.toContain('const cameraWorld = worlds[cameraOwner] as World;');
+    if (resolvedCameraWorld === undefined) throw new Error('Camera owner is missing');
+    expect(renderTime(resolvedCameraWorld).delta).toBeCloseTo(1 / 30);
   });
 });

package/src/__tests__/device-feature-admission.unit.test.ts

@@ -43,8 +43,9 @@ describe('shared device feature admission', () => {
   });
 
   it.each([
-    [48, 22],
-    [22, 22],
+    [48, 23],
+    [23, 23],
+    [22, 21],
     [21, 21],
     [20, 18],
     [18, 18],

package/src/__tests__/gpu-driven-pbr.dawn.test.ts

@@ -641,10 +641,9 @@ describe('GPU-driven production PBR Dawn regression', () => {
       { binding: 47, resource: { kind: 'textureView' as const, value: materialCubeView } },
       { binding: 18, resource: { kind: 'sampler' as const, value: baseColorSampler } },
       { binding: 19, resource: { kind: 'textureView' as const, value: baseColorView } },
-      { binding: 20, resource: { kind: 'sampler' as const, value: baseColorSampler } },
-      { binding: 21, resource: { kind: 'buffer' as const, value: { buffer: viewUniform } } },
-      { binding: 22, resource: { kind: 'sampler' as const, value: baseColorSampler } },
-      { binding: 23, resource: { kind: 'textureView' as const, value: baseColorView } },
+      { binding: 20, resource: { kind: 'buffer' as const, value: { buffer: viewUniform } } },
+      { binding: 21, resource: { kind: 'sampler' as const, value: baseColorSampler } },
+      { binding: 22, resource: { kind: 'textureView' as const, value: baseColorView } },
       {
         binding: 46,
         resource: {

package/src/__tests__/ktx2-basis-gpu-consumer.dawn.test.ts

@@ -560,7 +560,10 @@ describe.skipIf(!pkgBuilt)('KTX2/Basis real GPU texture consumer matrix', () =>
     store.configureGpuDevice(
       device as never,
       undefined,
-      (world, pod) => ok(world.allocSharedRef('EquirectAsset', pod)),
+      (source, pod) => {
+        if ('resolveAsset' in source) throw new Error('This fixture only allocates World assets');
+        return ok(source.allocSharedRef('EquirectAsset', pod));
+      },
       device.caps,
     );
     const rows: GpuCell[] = [];

package/src/__tests__/main-pass-material-medium-selection.unit.test.ts

@@ -63,7 +63,6 @@ function dependencies(
       skylightPrefilterView: resource(),
       prefilterSampler: resource(),
       brdfLutView: resource(),
-      brdfLutSampler: resource(),
       intensityBuffer: resource(),
     },
     materialBgShared: new Map(),

package/src/__tests__/materials-standard-contract.unit.test.ts

@@ -139,7 +139,6 @@ describe('Materials.standard clearcoat public contract', () => {
         prefilterView: view,
         prefilterSampler: sampler,
         brdfLutView: view,
-        brdfLutSampler: sampler,
         intensityBuffer: {} as Buffer,
       },
       undefined,

package/src/__tests__/physical-clearcoat.integration.test.ts

@@ -76,26 +76,26 @@ describe('Standard clearcoat root contract', () => {
     );
 
     // The canonical seven texture pairs occupy bindings 1..14. IBL remains
-    // at 15..21 and transmission at 22..23; authored physical maps append at
+    // at 15..20 and transmission at 21..22; authored physical maps append at
     // their canonical fixed slots (26, 27, 30, 31), followed by the
     // scene-index row at binding 46. Compacting the authored root here shifts WGSL IBL bindings and
     // causes Dawn to reject the pipeline before any pixels are submitted.
-    expect(descriptor.entries).toHaveLength(30);
+    expect(descriptor.entries).toHaveLength(29);
     expect(descriptor.entries.slice(0, 15).map((entry) => entry.binding)).toEqual(
       Array.from({ length: 15 }, (_, binding) => binding),
     );
     expect(descriptor.entries[15]?.texture).toMatchObject({ viewDimension: 'cube' });
     expect(descriptor.entries[17]?.texture).toMatchObject({ viewDimension: 'cube' });
-    expect(descriptor.entries[22]?.sampler).toMatchObject({ type: 'filtering' });
-    expect(descriptor.entries[23]?.texture).toMatchObject({ viewDimension: '2d' });
-    expect(descriptor.entries.slice(24, 28).map((entry) => entry.binding)).toEqual([
+    expect(descriptor.entries[21]?.sampler).toMatchObject({ type: 'filtering' });
+    expect(descriptor.entries[22]?.texture).toMatchObject({ viewDimension: '2d' });
+    expect(descriptor.entries.slice(23, 27).map((entry) => entry.binding)).toEqual([
       26, 27, 30, 31,
     ]);
-    expect(descriptor.entries[29]).toMatchObject({
+    expect(descriptor.entries[28]).toMatchObject({
       binding: 47,
       texture: { sampleType: 'float', viewDimension: 'cube' },
     });
-    expect(descriptor.entries[28]).toMatchObject({
+    expect(descriptor.entries[27]).toMatchObject({
       binding: 46,
       visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
       buffer: { type: 'read-only-storage', hasDynamicOffset: false },
@@ -122,7 +122,7 @@ describe('Standard clearcoat root contract', () => {
     // PBR layouts keep the producer-owned scene-material row at binding 46,
     // even when an authored schema has no numeric parameters.
     expect(descriptor.entries.map((entry) => entry.binding)).toEqual([
-      ...Array.from({ length: 10 }, (_, binding) => binding),
+      ...Array.from({ length: 9 }, (_, binding) => binding),
       46,
       47,
     ]);
@@ -144,43 +144,43 @@ describe('Standard clearcoat root contract', () => {
     );
 
     expect(descriptor.entries.map((entry) => entry.binding)).toEqual([
-      ...Array.from({ length: 16 }, (_, binding) => binding),
+      ...Array.from({ length: 15 }, (_, binding) => binding),
       46,
     ]);
-    expect(descriptor.entries[10]).toMatchObject({
+    expect(descriptor.entries[9]).toMatchObject({
       sampler: { type: 'non-filtering' },
     });
-    expect(descriptor.entries[11]).toMatchObject({
+    expect(descriptor.entries[10]).toMatchObject({
       texture: { sampleType: 'unfilterable-float', viewDimension: '2d' },
     });
-    expect(descriptor.entries[12]).toMatchObject({
+    expect(descriptor.entries[11]).toMatchObject({
       sampler: { type: 'filtering' },
     });
-    expect(descriptor.entries[13]).toMatchObject({
+    expect(descriptor.entries[12]).toMatchObject({
       texture: { sampleType: 'float', viewDimension: '2d' },
     });
-    expect(descriptor.entries[14]).toMatchObject({
+    expect(descriptor.entries[13]).toMatchObject({
       sampler: { type: 'non-filtering' },
     });
-    expect(descriptor.entries[15]).toMatchObject({
+    expect(descriptor.entries[14]).toMatchObject({
       texture: { sampleType: 'unfilterable-float', viewDimension: '2d' },
     });
 
     // The medium is a project material artifact with an explicit empty
     // paramSchema. Its per-shader user region is therefore the reserved UBO
-    // at binding 0, followed by IBL 1..7, transmission 8..9, and Surface
-    // resources 10..15. Keep this source assertion next to the descriptor
+    // at binding 0, followed by IBL 1..6, transmission 7..8, and Surface
+    // resources 9..14. Keep this source assertion next to the descriptor
     // assertion so a future injection-order change cannot leave a compiled
     // WGSL binding map out of sync with the runtime BGL.
     const source = readFileSync(
       resolve(import.meta.dirname, '../../../shader/src/single-layer-medium.wgsl'),
       'utf8',
     );
-    expect(source).toContain('@group(1) @binding(10) var surfaceRawDepthSampler');
-    expect(source).toContain('@group(1) @binding(11) var surfaceRawDepthTexture');
-    expect(source).toContain('@group(1) @binding(12) var surfaceNearestLayerSampler');
-    expect(source).toContain('@group(1) @binding(13) var surfaceNearestLayerTexture');
-    expect(source).toContain('@group(1) @binding(14) var surfaceNearestDepthSampler');
-    expect(source).toContain('@group(1) @binding(15) var surfaceNearestDepthTexture');
+    expect(source).toContain('@group(1) @binding(9) var surfaceRawDepthSampler');
+    expect(source).toContain('@group(1) @binding(10) var surfaceRawDepthTexture');
+    expect(source).toContain('@group(1) @binding(11) var surfaceNearestLayerSampler');
+    expect(source).toContain('@group(1) @binding(12) var surfaceNearestLayerTexture');
+    expect(source).toContain('@group(1) @binding(13) var surfaceNearestDepthSampler');
+    expect(source).toContain('@group(1) @binding(14) var surfaceNearestDepthTexture');
   });
 });

package/src/__tests__/physical-material-budget.unit.test.ts

@@ -0,0 +1,40 @@
+import { STANDARD_MATERIAL_PARAM_SCHEMA } from '@forgeax/engine-types';
+import { expect, it } from 'vitest';
+import { STANDARD_PHYSICAL_REQUIRED_SAMPLED_TEXTURES } from '../assembly/device-feature-admission';
+import { buildBindGroupLayoutDescriptor, buildPbrViewBglEntries } from '../pbr-pipeline';
+import type { PipelineSpec } from '../pipeline-spec';
+
+it('fits the physical carrier and extended-lighting view within the admitted device budget', () => {
+  const textureFields = new Set([
+    'baseColorTexture',
+    'metallicRoughnessTexture',
+    'normalTexture',
+    'emissiveTexture',
+    'occlusionTexture',
+    'clearcoatTexture',
+    'clearcoatRoughnessTexture',
+    'clearcoatNormalTexture',
+    'transmissionTexture',
+    'thicknessTexture',
+  ]);
+  const spec: PipelineSpec = {
+    shader: { id: 'budget::physical', passKind: 'forward', variantSet: undefined },
+    attachments: { colorFormats: [], depthFormat: undefined, sampleCount: 1 },
+    geometry: { topology: 'triangle-list', vertexLayout: {} },
+    renderState: undefined,
+  };
+  const entries = [
+    ...buildPbrViewBglEntries({ storageBuffer: true, extendedLighting: true }),
+    ...buildBindGroupLayoutDescriptor(spec, {
+      kind: 'pbr-material-merged',
+      materialParamSchema: STANDARD_MATERIAL_PARAM_SCHEMA.filter(
+        (field) => field.type !== 'texture2d' || textureFields.has(field.name),
+      ),
+      caps: { storageBuffer: true, transmissionBackdrop: true },
+    }).entries,
+  ].filter((entry) => (entry.visibility & 2) !== 0);
+  expect(entries.filter((entry) => entry.sampler !== undefined).length).toBeLessThanOrEqual(16);
+  expect(entries.filter((entry) => entry.texture !== undefined).length).toBeLessThanOrEqual(
+    STANDARD_PHYSICAL_REQUIRED_SAMPLED_TEXTURES,
+  );
+});

package/src/__tests__/render-error-code-owner.test-d.ts

@@ -15,6 +15,7 @@ import type {
 } from '../index';
 
 const expectedCodes = [
+  'render-publication-invalid',
   'auto-exposure-invalid-parameter',
   'auto-exposure-capability-unavailable',
   'auto-exposure-stale-generation',

package/src/__tests__/renderer-factory-material-contract.unit.test.ts

@@ -137,7 +137,7 @@ fn cloud_direct_solar_factorX() -> f32 {
       } as never),
     ).toEqual({
       requiredFeatures: [],
-      requiredLimits: { maxSampledTexturesPerShaderStage: 22 },
+      requiredLimits: { maxSampledTexturesPerShaderStage: 23 },
     });
     expect(
       deviceOptionsForAdapter({

package/src/assembly/device-feature-admission.ts

@@ -21,12 +21,12 @@ export function transmissionBackdropAvailable(limit: number | undefined): boolea
 }
 /**
  * The complete Standard physical root can declare all optional texture slots.
- * Its material group therefore needs one more sampled-texture entry than the
+ * Its material group therefore needs two more sampled-texture entries than the
  * extended-lighting topology alone. Request this ceiling when the adapter can
  * provide it; lower-capability devices remain fail-closed at material
  * pipeline admission instead of receiving an invalid WebGPU layout.
  */
-export const STANDARD_PHYSICAL_REQUIRED_SAMPLED_TEXTURES = 22;
+export const STANDARD_PHYSICAL_REQUIRED_SAMPLED_TEXTURES = 23;
 
 export interface DeviceFeatureAdmissionOptions {
   readonly gpuPassTiming?: object | undefined;

package/src/assembly/host-contract.ts

@@ -14,6 +14,7 @@ import type { ObservationUnavailableError, RenderError } from '../errors/render'
 import type { RenderFeature, RenderFeatureDiagnostics } from '../features/types';
 import type { GpuDrivenProductionInspection, LodOcclusionInspection } from '../inspection-types';
 import type { MeshMaterialBindingObservation } from '../mesh-material-bindings';
+import type { PublishedRenderFrameInput } from '../publication/contract';
 import type { FrameObservation, FrameObservationOptions } from '../record/frame';
 import type { CurrentGraphTarget, GraphTargetCaptureRequest } from '../record/frame-snapshot';
 import type {
@@ -120,7 +121,9 @@ export interface RendererHostImplementation {
     readonly lodOcclusion: LodOcclusionInspection | undefined;
     readonly gpuDriven: GpuDrivenProductionInspection;
   };
-  drawFrame(request: RenderFrameInput): RenderResult<FrameReceipt, RhiError | RenderError>;
+  drawFrame(
+    request: RenderFrameInput | PublishedRenderFrameInput,
+  ): RenderResult<FrameReceipt, RhiError | RenderError>;
   /** Arm one upcoming frame for receipt-bound color observations. */
   requestObservation?: (
     domains: readonly import('../render-contract').FrameObservationDomain[],
@@ -154,7 +157,7 @@ export interface RendererLegacyHostAdapter {
   attachScene(world: World): RenderResult<void, RhiError>;
   detachScene(world: World): void;
   draw(
-    worldsOrRequest: readonly World[] | RenderFrameInput,
+    worldsOrRequest: readonly World[] | RenderFrameInput | PublishedRenderFrameInput,
     options?: DrawOwnerOptions,
   ): RenderResult<void | FrameReceipt, RhiError | RenderError>;
   observeCurrentFrame(

package/src/assembly/recovery/renderer-recover.ts

@@ -10,6 +10,7 @@ import type {
 import { err, ok, type Result, RhiError } from '@forgeax/engine-rhi';
 import type { MaterialShaderManifestEntry, ShaderCatalog } from '@forgeax/engine-shader';
 import type { Handle, ParamSchemaEntry } from '@forgeax/engine-types';
+import { AssetError } from '@forgeax/engine-types';
 import { DeviceScope } from '../../device/device-scope';
 import { GpuResidencyCache } from '../../device/gpu-residency';
 import { RecoverError, type RecoverFailure } from '../../errors/recover';
@@ -399,6 +400,14 @@ export function createRendererRecovery(deps: RendererRecoveryDependencies): Rend
       device,
       adaptMipmapShaderModuleFactory(internals.pack.createShaderModule),
       (world, pod) => {
+        if ('resolveAsset' in world)
+          return err(
+            new AssetError({
+              code: 'asset-not-found',
+              expected: 'source-owned environment asset allocation',
+              hint: 'publish the environment asset from its source owner before GPU preparation',
+            }),
+          );
         const handle: Handle<'EquirectAsset', 'shared'> = world.allocSharedRef(
           'EquirectAsset',
           pod,