@forgeax/engine-render 0.1.21 → 0.1.24

package/src/__tests__/renderer-recovery-lifecycle.unit.test.ts

@@ -0,0 +1,216 @@
+import { RhiNullCommandEncoder, RhiNullDevice, RhiNullQueue, rhi } from '@forgeax/engine-rhi-null';
+import { ok } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import {
+  acquireDeviceGeneration,
+  probeCandidateGraphExecution,
+  runRecoveryStep,
+} from '../assembly/recovery/recovery-attempt';
+import {
+  createRecoveryContinuation,
+  createRecoveryDeadline,
+  createRendererLifecycle,
+  createSingleFlight,
+  RECOVERY_ADAPTER_DEADLINE_MS,
+  RECOVERY_DEVICE_DEADLINE_MS,
+  RECOVERY_PHASES,
+  RECOVERY_TOTAL_DEADLINE_MS,
+} from '../assembly/renderer-lifecycle';
+
+describe('renderer recovery lifecycle', () => {
+  it('exhausts the public lifecycle states and rejects illegal transitions', () => {
+    const lifecycle = createRendererLifecycle();
+
+    expect(lifecycle.state()).toBe('alive');
+    expect(lifecycle.transition('device-lost')).toBe(true);
+    expect(lifecycle.transition('recovering')).toBe(true);
+    expect(lifecycle.transition('alive')).toBe(true);
+    expect(lifecycle.transition('faulted')).toBe(false);
+    expect(lifecycle.transition('disposed')).toBe(true);
+    expect(lifecycle.transition('alive')).toBe(false);
+    expect(lifecycle.states()).toEqual([
+      'alive',
+      'device-lost',
+      'recovering',
+      'faulted',
+      'disposed',
+    ]);
+  });
+
+  it('shares one recovery promise and one candidate for concurrent callers', async () => {
+    let attempts = 0;
+    let release: (() => void) | undefined;
+    const flight = createSingleFlight(async () => {
+      attempts += 1;
+      await new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      return { candidate: attempts };
+    });
+
+    const first = flight.run();
+    const second = flight.run();
+    expect(first).toBe(second);
+    expect(flight.inFlight()).toBe(first);
+    expect(attempts).toBe(1);
+
+    release?.();
+    await expect(first).resolves.toEqual({ candidate: 1 });
+    expect(flight.inFlight()).toBeUndefined();
+  });
+
+  it('enforces the 20 second attempt and 10 second acquisition budgets', () => {
+    const deadline = createRecoveryDeadline(1000);
+
+    expect(deadline.totalDeadlineMs).toBe(RECOVERY_TOTAL_DEADLINE_MS);
+    expect(deadline.adapterDeadlineMs).toBe(RECOVERY_ADAPTER_DEADLINE_MS);
+    expect(deadline.deviceDeadlineMs).toBe(RECOVERY_DEVICE_DEADLINE_MS);
+    expect(deadline.isValid('acquire-adapter', 10_999)).toBe(true);
+    expect(deadline.isValid('acquire-adapter', 11_000)).toBe(false);
+    expect(deadline.isValid('acquire-device', 11_000)).toBe(false);
+    expect(deadline.isValid('compile-graph', 20_999)).toBe(true);
+    expect(deadline.isValid('compile-graph', 21_000)).toBe(false);
+    expect(RECOVERY_PHASES).toEqual([
+      'quiesce',
+      'acquire-adapter',
+      'acquire-device',
+      'rehydrate',
+      'compile-graph',
+      'publish',
+      'cleanup',
+    ]);
+  });
+
+  it('reports acquisition phases in their execution order', async () => {
+    const phases: string[] = [];
+    const result = await acquireDeviceGeneration(
+      { rhi },
+      {} as HTMLCanvasElement,
+      undefined,
+      undefined,
+      (phase) => phases.push(phase),
+    );
+
+    expect(result.ok).toBe(true);
+    expect(phases).toEqual(['acquire-adapter', 'acquire-device']);
+  });
+
+  it('treats the null graph probe as structural-only and rejects a non-null pixel mismatch', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const nullDevice = (await adapter.requestDevice()).unwrap();
+    const texture = nullDevice
+      .createTexture({
+        label: 'recovery-probe-test.texture',
+        size: { width: 1, height: 1, depthOrArrayLayers: 1 },
+        mipLevelCount: 1,
+        sampleCount: 1,
+        dimension: '2d',
+        format: 'rgba8unorm',
+        usage: 0x11,
+        viewFormats: undefined,
+        textureBindingViewDimension: undefined,
+      })
+      .unwrap();
+    const view = nullDevice.createTextureView(texture, { dimension: '2d' }).unwrap();
+    const nullProbe = await probeCandidateGraphExecution(nullDevice, {
+      texture,
+      view,
+      format: 'rgba8unorm',
+    });
+    expect(nullProbe.ok).toBe(true);
+
+    class PixellessNonNullDevice extends RhiNullDevice {
+      override get caps() {
+        return { ...super.caps, backendKind: 'webgpu' as const };
+      }
+    }
+    const nonNullDevice = new PixellessNonNullDevice(
+      new RhiNullQueue(),
+      (bookkeeper, device) => new RhiNullCommandEncoder(bookkeeper, device),
+    );
+    const nonNullTexture = nonNullDevice
+      .createTexture({
+        label: 'recovery-probe-test.non-null-texture',
+        size: { width: 1, height: 1, depthOrArrayLayers: 1 },
+        mipLevelCount: 1,
+        sampleCount: 1,
+        dimension: '2d',
+        format: 'rgba8unorm',
+        usage: 0x11,
+        viewFormats: undefined,
+        textureBindingViewDimension: undefined,
+      })
+      .unwrap();
+    const nonNullView = nonNullDevice
+      .createTextureView(nonNullTexture, { dimension: '2d' })
+      .unwrap();
+    const nonNullProbe = await probeCandidateGraphExecution(nonNullDevice, {
+      texture: nonNullTexture,
+      view: nonNullView,
+      format: 'rgba8unorm',
+    });
+    expect(nonNullProbe.ok).toBe(false);
+    if (!nonNullProbe.ok) expect(nonNullProbe.error.code).toBe('webgpu-runtime-error');
+  });
+
+  it('invalidates late continuation and cleans the candidate exactly once', () => {
+    let cleanupCount = 0;
+    const continuation = createRecoveryContinuation(createRecoveryDeadline(0), () => {
+      cleanupCount += 1;
+    });
+
+    expect(continuation.isValid('compile-graph', 19_999)).toBe(true);
+    continuation.abandon(20_000);
+    expect(continuation.isValid('compile-graph', 20_000)).toBe(false);
+    continuation.cleanupOnce();
+    continuation.cleanupOnce();
+    expect(cleanupCount).toBe(1);
+  });
+
+  it('invalidates an async step on timeout before a late completion can write', async () => {
+    let cleanupCount = 0;
+    let lateWrites = 0;
+    const startedAt = Date.now();
+    const deadline = {
+      startedAt,
+      totalDeadlineMs: 1,
+      adapterDeadlineMs: 1,
+      deviceDeadlineMs: 1,
+      deadlineAt: startedAt + 1,
+      beginDeviceAcquisition: (_now: number) => undefined,
+      isValid: (
+        _phase:
+          | 'quiesce'
+          | 'acquire-adapter'
+          | 'acquire-device'
+          | 'rehydrate'
+          | 'compile-graph'
+          | 'publish'
+          | 'cleanup',
+        now: number,
+      ) => now < startedAt + 1,
+      elapsed: (now: number) => Math.max(0, now - startedAt),
+    };
+    const continuation = createRecoveryContinuation(deadline, () => {
+      cleanupCount += 1;
+    });
+
+    const outcome = await runRecoveryStep(
+      async (attemptToken) => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        if (attemptToken?.isValid('compile-graph', Date.now())) lateWrites += 1;
+        return ok(undefined);
+      },
+      'compile-graph',
+      deadline,
+      Date.now,
+      continuation,
+    );
+
+    expect(outcome.kind).toBe('timeout');
+    if (outcome.kind === 'timeout') expect(outcome.timeout.cause.code).toBe('webgpu-runtime-error');
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(lateWrites).toBe(0);
+    expect(cleanupCount).toBe(1);
+  });
+});

package/src/__tests__/renderer-target-history-recovery.integration.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest';
+import { TaaHistoryStore } from '../temporal/taa-history-store';
+
+type RecoveryReceipt = {
+  readonly deviceGeneration: number;
+  readonly completed: boolean;
+};
+
+type RecoverableHistory = TaaHistoryStore & {
+  recoverForGeneration(deviceGeneration: number): void;
+};
+
+function recover(store: TaaHistoryStore, deviceGeneration: number): void {
+  (store as RecoverableHistory).recoverForGeneration(deviceGeneration);
+}
+
+function commit(store: TaaHistoryStore, receipt: RecoveryReceipt): void {
+  const attempt = store.begin('device-generation');
+  attempt.commit(receipt as never);
+}
+
+describe('M4 / m4_t2 — target history recovery keeps logical token', () => {
+  it('publishes uninitialized replacement storage with neutral fallback', () => {
+    const store = new TaaHistoryStore();
+    const token = (
+      store.inspect() as typeof store.inspect extends () => infer T ? T : never & { token: string }
+    ).token;
+
+    recover(store, 8);
+
+    expect(store.inspect()).toMatchObject({
+      token,
+      deviceGeneration: 8,
+      content: 'uninitialized',
+      fallback: 'neutral-texture',
+      valid: false,
+      requestVersion: 0,
+    });
+  });
+
+  it('raises history only for a matching completed receipt', () => {
+    const store = new TaaHistoryStore();
+    recover(store, 8);
+    const before = store.inspect();
+
+    commit(store, { deviceGeneration: 7, completed: true });
+    expect(store.inspect()).toMatchObject({
+      token: before.token,
+      deviceGeneration: 8,
+      content: 'uninitialized',
+      valid: false,
+      requestVersion: 0,
+    });
+
+    commit(store, { deviceGeneration: 8, completed: false });
+    expect(store.inspect().valid).toBe(false);
+
+    commit(store, { deviceGeneration: 8, completed: true });
+    expect(store.inspect()).toMatchObject({
+      token: before.token,
+      deviceGeneration: 8,
+      content: 'active',
+      valid: true,
+      requestVersion: 1,
+    });
+  });
+
+  it('does not invent once or on-demand requests during replacement', () => {
+    const store = new TaaHistoryStore();
+    recover(store, 9);
+    const inspection = store.inspect() as typeof store.inspect extends () => infer T
+      ? T
+      : never & {
+          requestVersion: number;
+        };
+
+    expect(inspection.requestVersion).toBe(0);
+    expect(inspection.content).toBe('uninitialized');
+  });
+});

package/src/__tests__/shader-manifest-fixture.ts

@@ -58,22 +58,19 @@ const standardPbrVariants = (() => {
   const variants = [];
   for (const cluster of [false, true]) {
     for (const storage of [false, true]) {
-      for (const transmission of [false, true]) {
-        for (const vertexColor of [false, true]) {
-          const defines = {
-            CLUSTER_FORWARD_AVAILABLE: cluster,
-            STORAGE_BUFFER_AVAILABLE: storage,
-            TRANSMISSION_AVAILABLE: transmission,
-            VERTEX_COLOR_AVAILABLE: vertexColor,
-          };
-          const sortedDefines = Object.entries(defines).sort(([left], [right]) =>
-            left < right ? -1 : left > right ? 1 : 0,
-          );
-          const definesKey = sortedDefines.every(([, value]) => value)
-            ? ''
-            : sortedDefines.map(([key, value]) => `${key}=${value}`).join('+');
-          variants.push({ definesKey, defines, composedWgsl: pbrWgsl });
-        }
+      for (const vertexColor of [false, true]) {
+        const defines = {
+          CLUSTER_FORWARD_AVAILABLE: cluster,
+          STORAGE_BUFFER_AVAILABLE: storage,
+          VERTEX_COLOR_AVAILABLE: vertexColor,
+        };
+        const sortedDefines = Object.entries(defines).sort(([left], [right]) =>
+          left < right ? -1 : left > right ? 1 : 0,
+        );
+        const definesKey = sortedDefines.every(([, value]) => value)
+          ? ''
+          : sortedDefines.map(([key, value]) => `${key}=${value}`).join('+');
+        variants.push({ definesKey, defines, composedWgsl: pbrWgsl });
       }
     }
   }

package/src/__tests__/shader-stage-surface.unit.test.ts

@@ -20,7 +20,7 @@ const fragmentConsumerSources = [
   pbrPipelineSource,
   iblPipelineCacheSource,
   readFileSync(new URL('../ibl/skylight-bind-group.ts', import.meta.url), 'utf8'),
-  readFileSync(new URL('../assembly/factory.ts', import.meta.url), 'utf8'),
+  readFileSync(new URL('../assembly/webgpu-renderer.ts', import.meta.url), 'utf8'),
 ];
 
 describe('shader stage owner', () => {

package/src/__tests__/skin-motion-regression.unit.test.ts

@@ -53,6 +53,17 @@ describe('custom skinned mesh motion consumer contract', () => {
         composedWgsl: '@group(2) @binding(1) var<storage> palette: array<u32>;',
         paramSchema: '[]',
         variants: [
+          {
+            definesKey:
+              'CLUSTER_FORWARD_AVAILABLE=false+PROBE_BLEND_AVAILABLE=true+STORAGE_BUFFER_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false',
+            defines: {
+              CLUSTER_FORWARD_AVAILABLE: false,
+              PROBE_BLEND_AVAILABLE: true,
+              STORAGE_BUFFER_AVAILABLE: true,
+              VERTEX_COLOR_AVAILABLE: false,
+            },
+            composedWgsl: 'probe-urp',
+          },
           {
             definesKey:
               'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false',
@@ -63,6 +74,17 @@ describe('custom skinned mesh motion consumer contract', () => {
             },
             composedWgsl: '@group(2) @binding(1) var<storage> palette: array<u32>;',
           },
+          {
+            definesKey:
+              'CLUSTER_FORWARD_AVAILABLE=true+PROBE_BLEND_AVAILABLE=true+STORAGE_BUFFER_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false',
+            defines: {
+              CLUSTER_FORWARD_AVAILABLE: true,
+              PROBE_BLEND_AVAILABLE: true,
+              STORAGE_BUFFER_AVAILABLE: true,
+              VERTEX_COLOR_AVAILABLE: false,
+            },
+            composedWgsl: 'probe-hdrp',
+          },
           {
             definesKey:
               'CLUSTER_FORWARD_AVAILABLE=true+STORAGE_BUFFER_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false',

package/src/__tests__/skinned-shadow-caster.test.ts

@@ -122,10 +122,10 @@ describe('skinned shadow caster', () => {
       'const projectorAvailable = pipelineState.projectorAvailable !== false;',
     );
     expect(recordSource).toContain(
-      '...(projectorAvailable\n          ? [pipelineState.defaultWhiteTextureView, pipelineState.defaultSampler]',
+      '...(extendedLighting\n          ? extendedLightingCacheKeys\n          : projectorAvailable\n            ? [pipelineState.defaultWhiteTextureView, pipelineState.defaultSampler]',
     );
     expect(recordSource).toContain(
-      '...(projectorAvailable\n              ? [\n                  {\n                    binding: 11,',
+      '...(!extendedLighting && projectorAvailable\n              ? [\n                  {\n                    binding: 11,',
     );
     expect(recordSource).toContain('binding: 12');
   });

package/src/__tests__/spot-modifier-projection.unit.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+import {
+  prepareCookieProjection,
+  projectCookieUv,
+  projectIesCoordinates,
+  spotModifierProduct,
+} from '../prepare/extended-lighting/spot-modifiers';
+
+describe('Spot modifier projection', () => {
+  it('keeps the shared multiplication order and unit identities', () => {
+    expect(
+      spotModifierProduct({ brdf: 2, range: 0.8, cone: 0.5, ies: 0.25, cookie: 0.4, shadow: 0.75 }),
+    ).toBe(2 * 0.8 * 0.5 * 0.25 * 0.4 * 0.75);
+    expect(spotModifierProduct({ brdf: 1, range: 1, cone: 1, shadow: 1 })).toBe(1);
+  });
+
+  it('projects roll and non-square cookie dimensions into stable coordinates', () => {
+    const coords = projectIesCoordinates([0, 0, -1], 90);
+    expect(coords).toMatchObject({ azimuth: expect.any(Number), elevation: expect.any(Number) });
+    expect(projectCookieUv([0, 0, -1], 90, 2)).toMatchObject({
+      u: expect.any(Number),
+      v: expect.any(Number),
+    });
+  });
+
+  it('returns black behind the light and outside the projected cone', () => {
+    expect(projectIesCoordinates([0, 0, 1], 0)).toBeUndefined();
+    expect(projectCookieUv([0, 2, -1], 0, 1)).toBeUndefined();
+  });
+
+  it('projects non-square sRGB RGBA data once into linear fixed-size slices', () => {
+    const asset = {
+      kind: 'texture' as const,
+      shape: { viewDimension: '2d' as const, extent: { width: 2, height: 1 } },
+      format: 'rgba8unorm-srgb' as const,
+      colorSpace: 'srgb' as const,
+      mipmap: false,
+      mips: { kind: 'none' as const },
+      data: new Uint8Array([128, 0, 0, 128, 0, 255, 0, 255]),
+    };
+    const projection = prepareCookieProjection(asset);
+
+    expect(projection).toBeDefined();
+    expect(projection?.data.byteLength).toBe(256 * 256 * 4);
+    expect(projection?.aspect).toBe(2);
+    expect(projection?.matrix[0]).toBeCloseTo(0.5, 6);
+    expect(projection?.matrix[5]).toBe(1);
+    // The first source texel is sampled near its center. 128 sRGB is not
+    // copied as 128 linear; it is converted to roughly 55 linear bytes.
+    expect(projection?.data[0]).toBeLessThan(70);
+    expect(projection?.data[1]).toBe(0);
+    expect(projection?.data[3]).toBe(128);
+    const right = 256 * 4 - 4;
+    expect(projection?.data[right + 1]).toBeGreaterThan(240);
+    expect(projection).toBe(prepareCookieProjection(asset));
+  });
+
+  it('rejects a non-RGBA8 source instead of silently binding raw bytes', () => {
+    const asset = {
+      kind: 'texture' as const,
+      shape: { viewDimension: '2d' as const, extent: { width: 1, height: 1 } },
+      format: 'rgba16float' as const,
+      colorSpace: 'linear' as const,
+      mipmap: false,
+      mips: { kind: 'none' as const },
+      data: new Uint8Array(8),
+    };
+    expect(prepareCookieProjection(asset)).toBeUndefined();
+  });
+});

package/src/__tests__/ssr-admission-matrix.integration.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, it } from 'vitest';
+import {
+  admitSsrM0,
+  projectSsrDependencies,
+  SSR_FORMAT_STAGES,
+  type SsrAdmissionIdentity,
+  type SsrFormatReceipt,
+  type SsrReflectionFallbackReceipt,
+} from '../ssr/admission';
+
+const identity: SsrAdmissionIdentity = {
+  sourceHead: 'head',
+  sourceTree: 'tree',
+  lockSha256: 'lock',
+  buildSha256: 'build',
+};
+
+const reflectionFallback = {
+  identity,
+  source: 'probe' as const,
+  sourceGeneration: 4,
+  projectionGeneration: 4,
+  deviceGeneration: 2,
+  state: 'active' as const,
+  candidateVisible: false as const,
+  coverage: 1,
+  brdfSignature: 'standard-pbr-ibl-v1',
+} satisfies SsrReflectionFallbackReceipt;
+
+const format = {
+  identity,
+  profile: 'r32float-mip-sampled-storage' as const,
+  verdict: 'admitted' as const,
+  evidence: 'real' as const,
+  stages: SSR_FORMAT_STAGES.map((stage) => ({
+    stage,
+    verdict: 'admitted' as const,
+    evidence: 'real' as const,
+  })),
+  deviceGeneration: 2,
+  sampleType: 'unfilterable-float' as const,
+  usages: ['texture-binding', 'storage-binding', 'copy-src'] as const,
+  readback: { byteLength: 4, values: [1] },
+  probeExecutions: 1,
+} satisfies SsrFormatReceipt;
+
+const temporal = {
+  identity,
+  successfulSubmit: true as const,
+  generation: 4,
+};
+
+describe('SSR M0 admission matrix', () => {
+  it('keeps an unrequested unbound renderer on the ordinary zero-work path', () => {
+    const result = projectSsrDependencies({
+      requested: false,
+      identity: undefined,
+      reflectionFallback: undefined,
+      format: undefined,
+      temporal: undefined,
+    });
+    expect(result.status).toBe('fallback-only');
+    expect(result.failure?.code).toBe('ssr-not-requested');
+    expect(result.work.temporalDemand).toBe(0);
+  });
+
+  it('keeps unrequested SSR at fallback-only with exact zero work', () => {
+    const result = admitSsrM0({ requested: false, identity });
+    expect(result.status).toBe('fallback-only');
+    expect(result.work).toEqual({
+      attachmentCount: 0,
+      passCount: 0,
+      bindingCount: 0,
+      resourceCount: 0,
+      historyCount: 0,
+      temporalDemand: 0,
+    });
+  });
+
+  it.each([
+    ['producer', { format, temporal }, 'rebuild'],
+    ['format', { reflectionFallback, temporal }, 'retry'],
+    ['temporal', { reflectionFallback, format }, 'retry'],
+  ] as const)('blocks when the %s receipt is absent', (_, receipts, action) => {
+    const result = admitSsrM0({ requested: true, identity, ...receipts });
+    expect(result.status).toBe('fallback-only');
+    expect(result.work.temporalDemand).toBe(0);
+    expect(result.failure?.detail.action).toBe(action);
+  });
+
+  it('publishes a typed owner recovery action on every blocked path', () => {
+    const notRequested = admitSsrM0({ requested: false, identity });
+    expect(notRequested.failure?.detail.action).toBe('retry');
+
+    const mismatched = admitSsrM0({
+      requested: true,
+      identity,
+      reflectionFallback: {
+        ...reflectionFallback,
+        identity: { ...identity, sourceHead: 'old-head' },
+      },
+      format,
+      temporal,
+    });
+    expect(mismatched.failure?.detail).toMatchObject({
+      owner: 'producer',
+      action: 'rebuild',
+      identityField: 'sourceHead',
+    });
+
+    const stale = admitSsrM0({
+      requested: true,
+      identity,
+      reflectionFallback,
+      format,
+      temporal,
+      previousGeneration: reflectionFallback.projectionGeneration + 1,
+    });
+    expect(stale.failure?.detail.action).toBe('retry');
+  });
+
+  it('rejects malformed coverage or extent without creating SSR work', () => {
+    const malformed = admitSsrM0({
+      requested: true,
+      identity,
+      reflectionFallback: {
+        ...reflectionFallback,
+        coverage: 2,
+        extent: [0, 1, 1],
+      },
+      format,
+      temporal,
+    });
+    expect(malformed.status).toBe('fallback-only');
+    expect(malformed.failure?.code).toBe('ssr-reflection-fallback-unavailable');
+    expect(malformed.work).toEqual({
+      attachmentCount: 0,
+      passCount: 0,
+      bindingCount: 0,
+      resourceCount: 0,
+      historyCount: 0,
+      temporalDemand: 0,
+    });
+  });
+
+  it('blocks structural-only format evidence and every identity mismatch', () => {
+    const structuralOnly = {
+      ...format,
+      verdict: 'structural-only' as const,
+    };
+    const blocked = admitSsrM0({
+      requested: true,
+      identity,
+      reflectionFallback,
+      format: structuralOnly,
+      temporal,
+    });
+    expect(blocked.status).toBe('fallback-only');
+
+    const structuralReceipt = {
+      ...format,
+      evidence: 'structural' as const,
+    };
+    const structuralBlocked = admitSsrM0({
+      requested: true,
+      identity,
+      reflectionFallback,
+      format: structuralReceipt,
+      temporal,
+    });
+    expect(structuralBlocked.status).toBe('fallback-only');
+
+    for (const field of Object.keys(identity) as (keyof SsrAdmissionIdentity)[]) {
+      const mismatched = admitSsrM0({
+        requested: true,
+        identity,
+        reflectionFallback: {
+          ...reflectionFallback,
+          identity: { ...identity, [field]: `old-${field}` },
+        },
+        format,
+        temporal,
+      });
+      expect(mismatched.status, field).toBe('fallback-only');
+    }
+  });
+
+  it('admits only three matching receipts and reports nonzero work', () => {
+    const result = admitSsrM0({
+      requested: true,
+      identity,
+      reflectionFallback,
+      format,
+      temporal,
+    });
+    expect(result.status).toBe('admitted');
+    expect(result.work).toEqual({
+      attachmentCount: 1,
+      passCount: 1,
+      bindingCount: 1,
+      resourceCount: 1,
+      historyCount: 0,
+      temporalDemand: 0,
+    });
+  });
+});