@forgeax/engine-render 0.1.34 → 0.1.36

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__/recovery-candidate-prepare.contract.test.ts

@@ -139,6 +139,11 @@ describe('recovery candidate preparation contract', () => {
     expect(rendererSource).not.toMatch(/\n\s*materialShaderPipelineCache\.(get|set|has)\(/);
   });
 
+  it('forks the validated shader catalog onto a recovery device', () => {
+    expect(rendererSource).toContain('activeCatalog.forkForDevice(getShaderModuleAdapter())');
+    expect(rendererSource).toContain('state === candidateShaderState && activeCatalog !== null');
+  });
+
   it('resolves recovery variants from the candidate device capabilities', () => {
     const start = rendererSource.indexOf('const resolveCachedMaterialShaderVariantSet');
     const end = rendererSource.indexOf('const findMaterialShaderManifestEntry', start);

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

@@ -1,10 +1,14 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import { type RhiDevice, RhiError } from '@forgeax/engine-rhi';
-import type {
-  MaterialShaderManifestEntry,
-  MaterialShaderManifestVariant,
-  ShaderCatalog,
+import {
+  createMaterialProgramArtifactReceipt,
+  type MaterialShaderManifestEntry,
+  type MaterialShaderManifestVariant,
+  type ShaderCatalog,
+  ShaderRegistry,
+  type ShaderRegistryDevice,
 } from '@forgeax/engine-shader';
 import { describe, expect, it, vi } from 'vitest';
 import { deviceOptionsForAdapter } from '../assembly/device-feature-admission';
@@ -128,6 +132,104 @@ fn cloud_direct_solar_factorX() -> f32 {
     });
   });
 
+  it('selects the replacement device capability variant after a metadata-only fork', async () => {
+    const uniformReceipt = createMaterialProgramArtifactReceipt({
+      schema: [],
+      directEntry: 'vs_uniform',
+      sceneIndexEntry: 'vs_scene_uniform',
+      vertexInputs: [],
+      layoutIdentity: 'uniform',
+    });
+    const storageReceipt = createMaterialProgramArtifactReceipt({
+      schema: [],
+      directEntry: 'vs_storage',
+      sceneIndexEntry: 'vs_scene_storage',
+      vertexInputs: [],
+      layoutIdentity: 'storage',
+    });
+    const entry: MaterialShaderManifestEntry = {
+      identifier: 'game::variant',
+      sourcePath: 'variant.wgsl',
+      composedWgsl: 'fallback',
+      paramSchema: '[]',
+      uvSetCount: 3,
+      variants: [
+        {
+          definesKey: 'STORAGE_BUFFER_AVAILABLE=false',
+          defines: { STORAGE_BUFFER_AVAILABLE: false },
+          composedWgsl: 'uniform-variant',
+          receipt: uniformReceipt,
+        },
+        {
+          definesKey: '',
+          defines: { STORAGE_BUFFER_AVAILABLE: true },
+          composedWgsl: 'storage-variant',
+          receipt: storageReceipt,
+        },
+      ],
+    };
+    const manifestUrl = URL.createObjectURL(
+      new Blob([JSON.stringify({ entries: [], materialShaders: [entry] })]),
+    );
+    const registryDevice = (): ShaderRegistryDevice => ({
+      createShaderModule: () => ({ ok: true, value: {} as never }),
+    });
+    const device = (storageBuffer: boolean): RhiDevice =>
+      ({
+        caps: {
+          backendKind: 'webgpu',
+          storageBuffer,
+          rgba16floatRenderable: true,
+          samplerAliasing: true,
+        },
+        limits: {
+          maxStorageBuffersPerShaderStage: storageBuffer ? 8 : 0,
+          maxSampledTexturesPerShaderStage: 32,
+          maxTextureArrayLayers: 64,
+          maxUniformBuffersPerShaderStage: 4,
+        },
+      }) as unknown as RhiDevice;
+
+    try {
+      const active = new ShaderRegistry({ device: registryDevice(), manifestUrl });
+      const activeAssets = new AssetRegistry(active);
+      await prepareMaterialShaders(device(false), () => active, activeAssets, new Map());
+      active.installMaterialArtifact('game::custom', {
+        source: 'custom-variant',
+        paramSchema: [],
+        receipt: uniformReceipt,
+      });
+      const activeArtifact = active.findMaterialArtifact('game::variant');
+      expect(activeArtifact.ok).toBe(true);
+      if (!activeArtifact.ok) return;
+      expect(activeArtifact.value.source).toBe('uniform-variant');
+      expect(activeArtifact.value.receipt).toEqual(uniformReceipt);
+
+      URL.revokeObjectURL(manifestUrl);
+      const candidate = active.forkForDevice(registryDevice());
+      const candidateAssets = new AssetRegistry(candidate);
+      const uvSetCounts = new Map<string, number>();
+      await prepareMaterialShaders(device(true), () => candidate, candidateAssets, uvSetCounts);
+      const candidateArtifact = candidate.findMaterialArtifact('game::variant');
+      expect(candidateArtifact.ok).toBe(true);
+      if (!candidateArtifact.ok) return;
+      expect(candidateArtifact.value.source).toBe('storage-variant');
+      expect(candidateArtifact.value.receipt).toEqual(storageReceipt);
+      expect(uvSetCounts.get('game::variant')).toBe(3);
+      expect(candidate.findMaterialArtifact('game::custom').ok).toBe(false);
+
+      const customArtifact = active.findMaterialArtifact('game::custom');
+      expect(customArtifact.ok).toBe(true);
+      if (!customArtifact.ok) return;
+      candidate.installMaterialArtifact('game::custom', customArtifact.value);
+      const candidateCustom = candidate.findMaterialArtifact('game::custom');
+      expect(candidateCustom.ok && candidateCustom.value.source).toBe('custom-variant');
+      expect(activeArtifact.value.source).toBe('uniform-variant');
+    } finally {
+      URL.revokeObjectURL(manifestUrl);
+    }
+  });
+
   it('requests the extended-lighting sampled-texture limit when the adapter supports it', () => {
     const features = new Set<GPUFeatureName>();
     expect(
@@ -137,7 +239,7 @@ fn cloud_direct_solar_factorX() -> f32 {
       } as never),
     ).toEqual({
       requiredFeatures: [],
-      requiredLimits: { maxSampledTexturesPerShaderStage: 22 },
+      requiredLimits: { maxSampledTexturesPerShaderStage: 23 },
     });
     expect(
       deviceOptionsForAdapter({

package/src/__tests__/runtime-material-program.integration.test.ts

@@ -0,0 +1,79 @@
+import { AssetRegistry, HANDLE_CUBE, RuntimeMaterialValue } from '@forgeax/engine-assets-runtime';
+import { World } from '@forgeax/engine-ecs';
+import { Transform } from '@forgeax/engine-scene';
+import { ShaderRegistry } from '@forgeax/engine-shader';
+import type { MaterialAsset } from '@forgeax/engine-types';
+import { expect, it } from 'vitest';
+import {
+  MATERIAL_CONTEXT,
+  materialRecordFixture,
+} from '../../../assets-runtime/src/__tests__/fixtures/material-publication';
+import { MeshFilter, MeshRenderer } from '../components';
+import { extractFrames, resolveMaterialSnapshot } from '../render-system-extract';
+
+it('keeps cooked Forward and ShadowCaster programs when World values change or a catalogue entry is replaced', () => {
+  const assets = new AssetRegistry(new ShaderRegistry({ manifestUrl: undefined }));
+  const world = new World();
+  const record = materialRecordFixture({
+    parameters: [{ name: 'roughness', type: 'f32' }],
+    values: { roughness: 0.8 },
+    passes: [
+      { name: 'Forward', program: { module: 'game::material' } },
+      { name: 'ShadowCaster', program: { module: 'game::shadow' } },
+    ],
+  });
+  const base: MaterialAsset = { kind: 'material', ...record.resolved };
+  assets.catalog(record.guid, base).unwrap();
+  if (!record.sourceClosure || !record.parameterContract)
+    throw new Error('Missing cooked metadata');
+  assets.recordMaterialReadiness(record.guid, {
+    status: 'Ready',
+    guid: record.guid,
+    materialGuid: record.guid,
+    publicationGeneration: record.publicationGeneration,
+    specializationKey: record.specializationKey,
+    artifactDigest: record.artifactDigest,
+    sourceClosure: record.sourceClosure,
+    parameterContract: record.parameterContract,
+    record,
+    programs: record.programs,
+  });
+  const handle = world.internSharedRef('MaterialAsset', base);
+  world
+    .spawn(
+      { component: Transform, data: {} },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
+      { component: MeshRenderer, data: { materials: [handle] } },
+    )
+    .unwrap();
+  world.update(0).unwrap();
+  const frameRead = () =>
+    extractFrames([world], 0, assets, undefined, undefined, {
+      materialContext: MATERIAL_CONTEXT,
+      cull: 'none',
+    }).renderables[0]?.materials[0];
+  const read = () =>
+    resolveMaterialSnapshot(handle, world, assets, undefined, undefined, MATERIAL_CONTEXT);
+  const before = read();
+  expect(frameRead()?.materialProgramKeys).toEqual(before.materialProgramKeys);
+  expect(Object.keys(before.materialProgramKeys ?? {})).toEqual(['Forward', 'ShadowCaster']);
+  const content = world
+    .spawn({
+      component: RuntimeMaterialValue,
+      data: {
+        asset: handle,
+        parameter: 'roughness',
+        kind: 0,
+        value: [0.25],
+      },
+    })
+    .unwrap();
+  expect(read().roughness).toBe(0.25);
+  expect(frameRead()?.materialProgramKeys).toEqual(before.materialProgramKeys);
+  expect(read().materialProgramKeys).toEqual(before.materialProgramKeys);
+  assets.catalog(record.guid, { ...base, values: { roughness: 0.6 } }).unwrap();
+  expect(read().materialProgramKeys).toEqual(before.materialProgramKeys);
+  world.despawn(content).unwrap();
+  expect(read().roughness).toBeCloseTo(0.8);
+  expect(read().materialProgramKeys).toEqual(before.materialProgramKeys);
+});

package/src/__tests__/vertex-layouts-ssot.unit.test.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_VERTEX_ATTRIBUTE_MAP, deriveVertexBufferLayout } from '@forgeax/engine-geometry';
+import { deriveVertexBufferLayout } from '@forgeax/engine-geometry';
 import { describe, expect, it } from 'vitest';
 import {
   BILLBOARD_MATERIAL_INSTANCE_VERTEX_BUFFERS,
@@ -17,11 +17,31 @@ const FLOAT32_COMPONENT_COUNT = {
 describe('prepared feature vertex layout SSOT', () => {
   it('derives the mesh vertex stream from geometry layout ownership', () => {
     const [expected] = toGpuVertexBufferLayouts(
-      deriveVertexBufferLayout(DEFAULT_VERTEX_ATTRIBUTE_MAP),
+      deriveVertexBufferLayout({
+        position: new Float32Array(),
+        normal: new Float32Array(),
+        uv: new Float32Array(),
+        tangent: new Float32Array(),
+        uv1: new Float32Array(),
+        color: new Float32Array(),
+      }),
     );
     const [actual] = MESH_GEOMETRY_MATERIAL_INSTANCE_VERTEX_BUFFERS;
 
-    expect(actual).toEqual({ ...expected, stepMode: 'vertex' });
+    if (expected === undefined) throw new Error('Missing geometry descriptor');
+    expect(actual).toEqual({
+      ...expected,
+      stepMode: 'vertex',
+      attributes: expected.attributes.map((attribute) => ({
+        ...attribute,
+        shaderLocation:
+          attribute.shaderLocation === 6
+            ? 15
+            : attribute.shaderLocation === 13
+              ? 14
+              : attribute.shaderLocation,
+      })),
+    });
   });
 
   it.each([

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,

package/src/assembly/render-target-host.ts

@@ -79,6 +79,11 @@ interface ReadbackRecord {
 export interface RenderTargetHost {
   /** The logical owner for every target lifecycle operation. */
   readonly owner: 'renderer';
+  /** Logical descriptions for the source publication boundary; no physical state escapes. */
+  descriptions(): readonly {
+    readonly target: RenderTarget;
+    readonly descriptor: RenderTargetDescriptor;
+  }[];
   createRenderTarget(descriptor: RenderTargetDescriptor): RenderResult<RenderTarget, RenderError>;
   resizeRenderTarget(
     target: RenderTarget,
@@ -231,53 +236,51 @@ function makePhysical(
   const faceViews: TextureView[] = [];
   const depthTextures: Texture[] = [];
   const depthViews: TextureView[] = [];
-  if (descriptor.shape === 'cube') {
-    for (let face = 0; face < layers; face += 1) {
-      const depth = device.createTexture({
-        label: `render-target.${generation}.depth.${face}`,
-        size: {
-          width: descriptor.width,
-          height: descriptor.height,
-          depthOrArrayLayers: descriptor.sampleCount === 4 ? 1 : layers,
-        },
-        mipLevelCount: 1,
-        sampleCount: descriptor.sampleCount,
-        dimension: '2d',
-        format: 'depth24plus-stencil8',
-        usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
-        viewFormats: undefined,
-        textureBindingViewDimension: undefined,
-      });
-      if (!depth.ok)
-        return {
-          ok: false,
-          error: new RenderTargetOperationFailedError({
-            operation: 'create',
-            stage: 'allocation',
-            generation,
-            cause: depth.error,
-            recovery: 'retry',
-          }),
-        };
-      const depthView = device.createTextureView(depth.value, {
-        dimension: '2d',
-        baseArrayLayer: descriptor.sampleCount === 4 ? 0 : face,
-        arrayLayerCount: 1,
-      });
-      if (!depthView.ok)
-        return {
-          ok: false,
-          error: new RenderTargetOperationFailedError({
-            operation: 'create',
-            stage: 'allocation',
-            generation,
-            cause: depthView.error,
-            recovery: 'retry',
-          }),
-        };
-      depthTextures.push(depth.value);
-      depthViews.push(depthView.value);
-    }
+  for (let face = 0; face < layers; face += 1) {
+    const depth = device.createTexture({
+      label: `render-target.${generation}.depth.${face}`,
+      size: {
+        width: descriptor.width,
+        height: descriptor.height,
+        depthOrArrayLayers: descriptor.sampleCount === 4 ? 1 : layers,
+      },
+      mipLevelCount: 1,
+      sampleCount: descriptor.sampleCount,
+      dimension: '2d',
+      format: 'depth24plus-stencil8',
+      usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
+      viewFormats: undefined,
+      textureBindingViewDimension: undefined,
+    });
+    if (!depth.ok)
+      return {
+        ok: false,
+        error: new RenderTargetOperationFailedError({
+          operation: 'create',
+          stage: 'allocation',
+          generation,
+          cause: depth.error,
+          recovery: 'retry',
+        }),
+      };
+    const depthView = device.createTextureView(depth.value, {
+      dimension: '2d',
+      baseArrayLayer: descriptor.sampleCount === 4 ? 0 : face,
+      arrayLayerCount: 1,
+    });
+    if (!depthView.ok)
+      return {
+        ok: false,
+        error: new RenderTargetOperationFailedError({
+          operation: 'create',
+          stage: 'allocation',
+          generation,
+          cause: depthView.error,
+          recovery: 'retry',
+        }),
+      };
+    depthTextures.push(depth.value);
+    depthViews.push(depthView.value);
   }
   if (descriptor.sampleCount === 4) {
     for (let face = 0; face < layers; face += 1) {
@@ -405,6 +408,13 @@ export function createRenderTargetHost(options: RenderTargetHostOptions = {}): R
 
   return Object.freeze({
     owner: 'renderer' as const,
+    descriptions() {
+      return [...targets].map((target) => {
+        const state = owner.inspect(target);
+        if (!state.ok) throw state.error;
+        return { target, descriptor: state.value.candidate?.descriptor ?? state.value.descriptor };
+      });
+    },
     createRenderTarget(
       descriptor: RenderTargetDescriptor,
     ): RenderResult<RenderTarget, RenderError> {

package/src/assembly/renderer-facade.ts

@@ -1,3 +1,4 @@
+import { RenderPublicationError } from '../publication/contract';
 // Public renderer facade and profile validation.
 // This module narrows the lifetime-heavy host implementation to the stable
 // lease/receipt contract and owns the profile/error projection helpers.
@@ -64,7 +65,8 @@ export function exposeRenderer(renderer: RendererHostImplementation): Renderer {
           cause: structuredRendererCause(cause, 'renderer-event'),
         });
   const drawError = (cause: RhiError | RenderError): RenderError => {
-    if (cause instanceof MotionBlurValidationError) return cause;
+    if (cause instanceof MotionBlurValidationError || cause instanceof RenderPublicationError)
+      return cause;
     if (cause instanceof RendererOperationError) return cause;
     if (cause instanceof RendererContractFailureError) {
       return new RendererOperationError('device-operation-failed', {

package/src/assembly/webgpu-ready.ts

@@ -1439,7 +1439,7 @@ export async function buildReadyWebGPU(
   // instances) and the 4-slot pipeline layout in one call, throwing on each
   // device.createBindGroupLayout / device.createPipelineLayout failure.
   // material BGL now carries 24 entries (canonical material 0..14 + Skylight
-  // 15..21 + transmission 22..23); authored physical maps append after the
+  // 15..20 + transmission 21..22); authored physical maps append after the
   // engine-owned injections. The pipeline layout itself stays at 4 slots, no
   // @group(4) allocated (D-5 round-4 fix for the round-2 maxBindGroups=4
   // BLOCKER). The standalone unlit BGL is the 15-entry user region exposed by