@forgeax/engine-shader 0.1.6 → 0.1.19

package/src/__tests__/default-standard-pbr-transmission.unit.test.ts

@@ -0,0 +1,181 @@
+import { ok, type ShaderModule } from '@forgeax/engine-rhi';
+import { describe, expect, it } from 'vitest';
+import { findVariantByKey, ShaderRegistry, type ShaderRegistryDevice } from '../index.js';
+
+type EngineShaderManifest = Awaited<
+  ReturnType<typeof import('@forgeax/engine-vite-plugin-shader').buildEngineShaderManifest>
+>;
+
+function dataUrl(payload: unknown): string {
+  return `data:application/json,${encodeURIComponent(JSON.stringify(payload))}`;
+}
+
+function device(): ShaderRegistryDevice {
+  return {
+    createShaderModule(): ReturnType<ShaderRegistryDevice['createShaderModule']> {
+      return ok({} as ShaderModule);
+    },
+  };
+}
+
+async function engineManifest(): Promise<EngineShaderManifest> {
+  const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
+  return buildEngineShaderManifest();
+}
+
+describe('default Standard PBR transmission manifest contract', () => {
+  it('publishes both TRANSMISSION_AVAILABLE variants from the cooked producer', {
+    timeout: 20_000,
+  }, async () => {
+    const manifest = await engineManifest();
+    const standard = manifest.materialShaders.find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+
+    expect(standard).toBeDefined();
+    if (standard === undefined) return;
+    const transmissionVariants = standard.variants.filter(
+      (variant) => 'TRANSMISSION_AVAILABLE' in variant.defines,
+    );
+    expect(transmissionVariants).toHaveLength(16);
+    expect(new Set(transmissionVariants.map((variant) => variant.definesKey)).size).toBe(16);
+    expect(new Set(transmissionVariants.map((variant) => variant.composedWgsl)).size).toBe(16);
+    for (const storageBufferAvailable of [false, true]) {
+      for (const transmissionAvailable of [false, true]) {
+        const expectedKey = [
+          'CLUSTER_FORWARD_AVAILABLE=false',
+          `STORAGE_BUFFER_AVAILABLE=${storageBufferAvailable}`,
+          `TRANSMISSION_AVAILABLE=${transmissionAvailable}`,
+          'VERTEX_COLOR_AVAILABLE=false',
+        ].join('+');
+        expect(transmissionVariants).toContainEqual(
+          expect.objectContaining({
+            definesKey: expectedKey,
+            defines: expect.objectContaining({
+              CLUSTER_FORWARD_AVAILABLE: false,
+              STORAGE_BUFFER_AVAILABLE: storageBufferAvailable,
+              TRANSMISSION_AVAILABLE: transmissionAvailable,
+              VERTEX_COLOR_AVAILABLE: false,
+            }),
+          }),
+        );
+      }
+    }
+  });
+
+  it('omits transmission-only texture bindings from the fallback variant', {
+    timeout: 20_000,
+  }, async () => {
+    const manifest = await engineManifest();
+    const standard = manifest.materialShaders.find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    expect(standard).toBeDefined();
+    if (standard === undefined) return;
+
+    const fallback = standard.variants.find(
+      (variant) =>
+        variant.defines.CLUSTER_FORWARD_AVAILABLE === false &&
+        variant.defines.STORAGE_BUFFER_AVAILABLE === true &&
+        variant.defines.TRANSMISSION_AVAILABLE === false &&
+        variant.defines.VERTEX_COLOR_AVAILABLE === false,
+    );
+    const transmission = standard.variants.find(
+      (variant) =>
+        variant.defines.CLUSTER_FORWARD_AVAILABLE === false &&
+        variant.defines.STORAGE_BUFFER_AVAILABLE === true &&
+        variant.defines.TRANSMISSION_AVAILABLE === true &&
+        variant.defines.VERTEX_COLOR_AVAILABLE === false,
+    );
+    expect(fallback?.composedWgsl).not.toContain('@binding(13)');
+    expect(fallback?.composedWgsl).not.toContain('@binding(24)');
+    expect(transmission?.composedWgsl).toContain('@binding(13)');
+    expect(transmission?.composedWgsl).toContain('@binding(24)');
+  });
+
+  it('registers one Standard row and resolves a declared variant by exact key', {
+    timeout: 20_000,
+  }, async () => {
+    const manifest = await engineManifest();
+    const standard = manifest.materialShaders.find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    expect(standard).toBeDefined();
+    if (standard === undefined) return;
+
+    const registry = new ShaderRegistry({
+      device: device(),
+      manifestUrl: dataUrl({ entries: [], materialShaders: [standard] }),
+    });
+    const loaded = await registry.loadManifest();
+    expect(loaded.ok).toBe(true);
+    const rows = Array.from(registry.materialShaderManifestEntries()).filter(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    expect(rows).toHaveLength(1);
+    const registered = rows[0];
+    expect(registered).toBeDefined();
+    if (registered === undefined) return;
+
+    const transmission = registered.variants.find(
+      (variant) => variant.defines.TRANSMISSION_AVAILABLE === true,
+    );
+    expect(transmission).toBeDefined();
+    if (transmission === undefined) return;
+    expect(findVariantByKey(registered, transmission.definesKey)).toBe(transmission);
+    expect(
+      findVariantByKey(registered, `${transmission.definesKey}+UNDECLARED=true`),
+    ).toBeUndefined();
+  });
+
+  it('rejects a manifest with a missing transmission variant before prewarm', async () => {
+    const missingVariant = {
+      identifier: 'forgeax::default-standard-pbr',
+      sourcePath: 'default-standard-pbr.wgsl',
+      composedWgsl: 'standard-default',
+      paramSchema: '[]',
+      variants: [
+        {
+          definesKey: 'TRANSMISSION_AVAILABLE=false',
+          defines: { TRANSMISSION_AVAILABLE: false },
+          composedWgsl: 'standard-no-transmission',
+        },
+      ],
+    };
+    const registry = new ShaderRegistry({
+      device: device(),
+      manifestUrl: dataUrl({ entries: [], materialShaders: [missingVariant] }),
+    });
+
+    const loaded = await registry.loadManifest();
+    expect(loaded.ok).toBe(false);
+  });
+
+  it('rejects duplicate variant keys instead of allowing ambiguous prewarm', async () => {
+    const duplicateVariant = {
+      identifier: 'forgeax::default-standard-pbr',
+      sourcePath: 'default-standard-pbr.wgsl',
+      composedWgsl: 'standard-default',
+      paramSchema: '[]',
+      variants: [
+        {
+          definesKey: 'TRANSMISSION_AVAILABLE=true',
+          defines: { TRANSMISSION_AVAILABLE: true },
+          composedWgsl: 'standard-transmission-a',
+        },
+        {
+          definesKey: 'TRANSMISSION_AVAILABLE=true',
+          defines: { TRANSMISSION_AVAILABLE: true },
+          composedWgsl: 'standard-transmission-b',
+        },
+      ],
+    };
+    const registry = new ShaderRegistry({
+      device: device(),
+      manifestUrl: dataUrl({ entries: [], materialShaders: [duplicateVariant] }),
+    });
+
+    const loaded = await registry.loadManifest();
+    expect(loaded.ok).toBe(false);
+  });
+});

package/src/__tests__/lighting-punctual.unit.test.ts

@@ -59,7 +59,7 @@ describe('direct punctual lighting shader contract', () => {
     const source = await readFile(pbrShaderPath, 'utf8');
 
     expect(source).toContain(
-      'evaluate_cluster_lights(in.ndc, in.viewZ, in.worldPos, n, v, albedo, metallic, a, f0)',
+      'evaluate_cluster_lights(in.ndc, in.viewZ, in.worldPos, n, v, diffuseAlbedo, metallic, a, f0)',
     );
     expect(source).toContain('coatAlpha, vec3<f32>(0.04)');
   });

package/src/__tests__/material-builtins.unit.test.ts

@@ -70,6 +70,41 @@ describe('built-in MaterialAsset sources', () => {
       { ...material, values: { ...material.values, baseColor: [0.2, 0.3, 0.4, 1] } }.values,
     ).toMatchObject({ baseColor: [0.2, 0.3, 0.4, 1] });
   });
+
+  it.each([
+    'default-standard-pbr.wgsl',
+    'default-standard-pbr-skin.wgsl',
+  ] as const)('keeps the Standard user-region ABI before Skylight in %s', (file) => {
+    const text = source(file);
+    const bindings = [
+      'baseColorSampler',
+      'baseColorTexture',
+      'metallicRoughnessSampler',
+      'metallicRoughnessTexture',
+      'normalSampler',
+      'normalTexture',
+      'specularTintSampler',
+      'specularTintTexture',
+      'emissiveSampler',
+      'emissiveTexture',
+      'occlusionSampler',
+      'occlusionTexture',
+      'transmissionSampler',
+      'transmissionTexture',
+      'thicknessSampler',
+      'thicknessTexture',
+      'irradianceMap',
+    ];
+    let previous = -1;
+    for (const name of bindings) {
+      const index = text.indexOf(`var ${name}`);
+      expect(index, `${file} must declare ${name}`).toBeGreaterThan(previous);
+      previous = index;
+    }
+    expect(text).toContain('@binding(13) var transmissionSampler');
+    expect(text).toContain('@binding(16) var thicknessTexture');
+    expect(text).toContain('@binding(17) var irradianceMap');
+  });
 });
 
 describe('built-in and custom material derived layout matrix', () => {
@@ -77,9 +112,11 @@ describe('built-in and custom material derived layout matrix', () => {
     const names = DEFAULT_STANDARD_PBR_PARAM_SCHEMA.map((entry) => entry.name);
     expect(names).toContain('emissiveTexture');
     expect(names).toContain('occlusionTexture');
+    expect(names).toContain('transmissionTexture');
+    expect(names).toContain('thicknessTexture');
     expect(
       DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter((entry) => entry.type === 'texture2d'),
-    ).toHaveLength(6);
+    ).toHaveLength(8);
   });
 
   it('derives a coordinate record for every texture parameter in an interleaved custom schema', () => {

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

@@ -1,5 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { derive } from '@forgeax/engine-types';
 import Ajv2020 from 'ajv/dist/2020.js';
 import { describe, expect, it } from 'vitest';
 import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from '../material-schemas.js';
@@ -56,3 +57,125 @@ describe('standard PBR material alpha contract', () => {
     expect(validateAlpha({ baseColor: [1, 1, 1, 0.5], alphaMode: 'MASK' })).toBe(true);
   });
 });
+
+describe('standard PBR transmission material contract', () => {
+  it('declares the seven transmission and volume parameters once, separate from CPU and GPU evidence', () => {
+    const entries = DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter((entry) =>
+      [
+        'transmission',
+        'ior',
+        'thickness',
+        'attenuationColor',
+        'attenuationDistance',
+        'transmissionTexture',
+        'thicknessTexture',
+      ].includes(entry.name),
+    );
+    expect(entries).toEqual([
+      { name: 'transmission', type: 'f32', default: 0 },
+      { name: 'ior', type: 'f32', default: 1.5 },
+      { name: 'thickness', type: 'f32', default: 0 },
+      { name: 'attenuationColor', type: 'vec3', colorSpace: 'linear', default: [1, 1, 1] },
+      { name: 'attenuationDistance', type: 'f32' },
+      { name: 'transmissionTexture', type: 'texture2d' },
+      { name: 'thicknessTexture', type: 'texture2d' },
+    ]);
+  });
+
+  it('derives numeric layout and paired texture bindings from the same schema', () => {
+    const derived = derive(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
+    expect(derived.numericMembers.map((member) => member.name)).toEqual(
+      expect.arrayContaining([
+        'transmission',
+        'ior',
+        'thickness',
+        'attenuationColor',
+        'attenuationDistance',
+      ]),
+    );
+    expect(derived.textureFieldNames.has('transmissionTexture')).toBe(true);
+    expect(derived.textureFieldNames.has('thicknessTexture')).toBe(true);
+    expect(derived.samplerForTexture.get('transmissionTexture')).toBe(
+      'transmissionTexture_sampler',
+    );
+    expect(derived.samplerForTexture.get('thicknessTexture')).toBe('thicknessTexture_sampler');
+  });
+
+  it('keeps the seven transmission inputs in the reflected UBO and coordinate contract', {
+    timeout: 20_000,
+  }, async () => {
+    const derived = derive(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
+    const transmissionNames = [
+      'transmission',
+      'ior',
+      'thickness',
+      'attenuationColor',
+      'attenuationDistance',
+      'transmissionTexture',
+      'thicknessTexture',
+    ];
+
+    expect(derived.numericMembers.map((member) => member.name)).toEqual(
+      expect.arrayContaining(transmissionNames.slice(0, 5)),
+    );
+    expect(derived.coordinateRecords.map((record) => record.parameter)).toEqual(
+      expect.arrayContaining(transmissionNames.slice(5)),
+    );
+    expect(derived.resourceBindings.filter((binding) => binding.binding >= 13)).toEqual([
+      {
+        name: 'transmissionTexture_sampler',
+        parameter: 'transmissionTexture',
+        kind: 'sampler',
+        binding: 13,
+      },
+      {
+        name: 'transmissionTexture',
+        parameter: 'transmissionTexture',
+        kind: 'texture',
+        binding: 14,
+      },
+      {
+        name: 'thicknessTexture_sampler',
+        parameter: 'thicknessTexture',
+        kind: 'sampler',
+        binding: 15,
+      },
+      {
+        name: 'thicknessTexture',
+        parameter: 'thicknessTexture',
+        kind: 'texture',
+        binding: 16,
+      },
+    ]);
+
+    const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
+    const manifest = await buildEngineShaderManifest();
+    const material = manifest.materialShaders.find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    expect(material).toBeDefined();
+    if (material === undefined) return;
+    const transmissionVariant = material.variants.find(
+      (variant) =>
+        variant.defines.CLUSTER_FORWARD_AVAILABLE === false &&
+        variant.defines.STORAGE_BUFFER_AVAILABLE === true &&
+        variant.defines.TRANSMISSION_AVAILABLE === true &&
+        variant.defines.VERTEX_COLOR_AVAILABLE === false,
+    );
+    expect(transmissionVariant).toBeDefined();
+    if (transmissionVariant === undefined) return;
+    expect(derived.totalBytes).toBe(384);
+    expect(transmissionVariant.composedWgsl).toMatch(
+      /@group\(1\)\s*@binding\(13\)\s*var transmissionSampler/,
+    );
+    expect(transmissionVariant.composedWgsl).toMatch(
+      /@group\(1\)\s*@binding\(14\)\s*var transmissionTexture/,
+    );
+    expect(transmissionVariant.composedWgsl).toMatch(
+      /@group\(1\)\s*@binding\(15\)\s*var thicknessSampler/,
+    );
+    expect(transmissionVariant.composedWgsl).toMatch(
+      /@group\(1\)\s*@binding\(16\)\s*var thicknessTexture/,
+    );
+  });
+});

package/src/__tests__/motion-blur.unit.test.ts

@@ -0,0 +1,44 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const source = readFileSync(resolve(import.meta.dirname, '../motion-blur.wgsl'), 'utf8');
+
+describe('motion-blur.wgsl', () => {
+  it('declares the portable raster gather contract', () => {
+    expect(source).toContain('@fragment');
+    expect(source).toContain('symmetric');
+    expect(source).toContain('maxRadiusPixels');
+    expect(source).toContain('shutterAngle');
+    expect(source).toContain('sampleCount');
+    expect(source).toContain('textureSample');
+  });
+
+  it('samples scene temporal depth through the portable color path', () => {
+    expect(source).toContain('@group(1) @binding(3) var sceneTemporal : texture_2d<f32>');
+    expect(source).toContain('textureLoad(sceneTemporal, samplePixel, 0)');
+    expect(source).not.toContain('texture_depth_2d');
+    expect(source).not.toContain('sceneDepth');
+    expect(source).not.toContain('depthSampler');
+  });
+
+  it('keeps depth, reactive, reset, and alpha guards in the shader owner', () => {
+    expect(source).toContain('reactive');
+    expect(source).toContain('invalidDepth');
+    expect(source).toContain('depthReject');
+    expect(source).toContain('reset');
+    expect(source).toContain('output.a');
+    expect(source).toContain('#import forgeax_scene_temporal::{unpackSceneTemporalV1}');
+    expect(source).toContain('let blurWeight = (1.0 - reactive)');
+    expect(source).toContain('for (var index = 0u; index < 16u; index += 1u)');
+    expect(source).not.toContain('positiveUv');
+    expect(source).not.toContain('negativeUv');
+  });
+
+  it('does not introduce compute, storage, or temporal history writes', () => {
+    expect(source).not.toContain('@compute');
+    expect(source).not.toContain('var<storage');
+    expect(source).not.toContain('history');
+    expect(source).not.toContain('atomic');
+  });
+});

package/src/__tests__/points-lines-shader.unit.test.ts

@@ -0,0 +1,43 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+
+const source = readFileSync(
+  fileURLToPath(new URL('../points-lines.wgsl', import.meta.url)),
+  'utf8',
+);
+
+describe('points-lines triangle expansion shader contract', () => {
+  it('declares one engine-owned material module and physical viewport input', () => {
+    expect(source).toContain('#define_import_path forgeax_material::points_lines');
+    expect(source).toContain('struct PointsLinesView');
+    expect(source).toContain('physicalViewport');
+    expect(source).toContain('model : mat4x4<f32>');
+    expect(source).toContain('pointsLinesView.model');
+    expect(source).toMatch(/@group\(0\)\s*@binding\(10\)\s+var<uniform>\s+pointsLinesView/);
+  });
+
+  it('expands square and circle points from clip-space pixel deltas', () => {
+    expect(source).toContain('fn expandPoint');
+    expect(source).toContain('sizePx');
+    expect(source).toContain('square');
+    expect(source).toContain('circleCoverage');
+    expect(source).toContain('sampleCenter');
+    expect(source).toContain('physicalViewport');
+  });
+
+  it('expands each butt segment independently without native wide primitive state', () => {
+    expect(source).toContain('fn expandLine');
+    expect(source).toContain('widthPx');
+    expect(source).toContain('butt');
+    expect(source).toContain('line-list');
+    expect(source).not.toMatch(/pointSize|lineWidth/);
+    expect(source).not.toContain('primitive-wide');
+  });
+
+  it('keeps the portable source free of compute and runtime compiler dependencies', () => {
+    expect(source).not.toMatch(/@compute|var<storage>|storage-read|indirect/);
+    expect(source).not.toMatch(/engine-(?:naga|shader-compiler|wgpu-wasm)/);
+    expect(source).not.toMatch(/fn\s+(?:compile|compose|reflect)/);
+  });
+});

package/src/__tests__/scene-temporal.unit.test.ts

@@ -10,10 +10,25 @@ const pbrTemporalConsumers = [
 ] as const;
 
 describe('scene temporal varyings', () => {
-  it.each(localTemporalShaders)('%s linearly interpolates both clip authorities', (file) => {
+  it('defines the temporal-v1 accessor ABI in one owner module', () => {
+    const source = readFileSync(resolve(import.meta.dirname, '..', 'scene-temporal.wgsl'), 'utf8');
+    expect(source).toContain('struct SceneTemporalV1');
+    expect(source).toContain('fn unpackSceneTemporalV1');
+    expect(source).toContain('motionUv = packed.xy');
+    expect(source).toContain('exp2(packed.z) - 1.0');
+    expect(source).toContain('reactive = clamp(packed.w');
+    expect(source).toContain('packed.z < 0.0');
+    expect(source).toContain('SCENE_DATA_TEMPORAL_V1_CLEAR');
+    expect(source).toContain('rgba16float');
+  });
+
+  it.each(localTemporalShaders)('%s perspective-interpolates both clip authorities', (file) => {
     const source = readFileSync(resolve(import.meta.dirname, '..', file), 'utf8');
-    expect(source).toMatch(/@interpolate\(linear\) currentClip : vec4<f32>/);
-    expect(source).toMatch(/@interpolate\(linear\) previousClip : vec4<f32>/);
+    expect(source).toMatch(/@interpolate\(perspective\) currentClip : vec4<f32>/);
+    expect(source).toMatch(/@interpolate\(perspective\) previousClip : vec4<f32>/);
+    expect(source).not.toMatch(
+      /@interpolate\((?:linear|noperspective)\) (?:currentClip|previousClip)/,
+    );
   });
 
   it('keeps PBR UV selection and fragment projection in one module', () => {
@@ -25,8 +40,11 @@ describe('scene temporal varyings', () => {
   it.each(pbrTemporalConsumers)('%s imports the shared PBR temporal authority', (file) => {
     const source = readFileSync(resolve(import.meta.dirname, '..', file), 'utf8');
     expect(source).toContain('#import forgeax_pbr::temporal::{projectPbrSceneTemporal}');
-    expect(source).toMatch(/@interpolate\(linear\) currentClip : vec4<f32>/);
-    expect(source).toMatch(/@interpolate\(linear\) previousClip : vec4<f32>/);
+    expect(source).toMatch(/@interpolate\(perspective\) currentClip : vec4<f32>/);
+    expect(source).toMatch(/@interpolate\(perspective\) previousClip : vec4<f32>/);
+    expect(source).not.toMatch(
+      /@interpolate\((?:linear|noperspective)\) (?:currentClip|previousClip)/,
+    );
     expect(source).not.toContain('fn transformedTemporalUv');
   });
 });

package/src/__tests__/shader-manifest-transmission.unit.test.ts

@@ -0,0 +1,75 @@
+import { ok, type ShaderModule } from '@forgeax/engine-rhi';
+import { describe, expect, it } from 'vitest';
+import { ShaderRegistry, type ShaderRegistryDevice } from '../index.js';
+
+function dataUrl(payload: unknown): string {
+  return `data:application/json,${encodeURIComponent(JSON.stringify(payload))}`;
+}
+
+function device(): ShaderRegistryDevice {
+  return {
+    createShaderModule(): ReturnType<ShaderRegistryDevice['createShaderModule']> {
+      return ok({} as ShaderModule);
+    },
+  };
+}
+
+function variant(definesKey: string, transmission: boolean) {
+  return {
+    definesKey,
+    defines: {
+      CLUSTER_FORWARD_AVAILABLE: false,
+      STORAGE_BUFFER_AVAILABLE: true,
+      TRANSMISSION_AVAILABLE: transmission,
+      VERTEX_COLOR_AVAILABLE: false,
+    },
+    composedWgsl: `standard-${transmission}`,
+  };
+}
+
+function standardRow(variants: readonly unknown[]) {
+  return {
+    identifier: 'forgeax::default-standard-pbr',
+    sourcePath: 'default-standard-pbr.wgsl',
+    composedWgsl: 'standard-default',
+    paramSchema: '[]',
+    variants,
+  };
+}
+
+async function load(materialShaders: readonly unknown[]) {
+  const registry = new ShaderRegistry({
+    device: device(),
+    manifestUrl: dataUrl({ entries: [], materialShaders }),
+  });
+  return registry.loadManifest();
+}
+
+describe('Standard transmission manifest validation', () => {
+  const falseKey =
+    'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+TRANSMISSION_AVAILABLE=false+VERTEX_COLOR_AVAILABLE=false';
+  const trueKey =
+    'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+TRANSMISSION_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false';
+
+  it('accepts one Standard row with both exact transmission states', async () => {
+    const result = await load([standardRow([variant(falseKey, false), variant(trueKey, true)])]);
+    expect(result.ok).toBe(true);
+  });
+
+  it('rejects a Standard row when either transmission state is missing', async () => {
+    const result = await load([standardRow([variant(falseKey, false)])]);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error.code).toBe('manifest-malformed');
+  });
+
+  it('rejects duplicate material rows and duplicate variant keys', async () => {
+    const row = standardRow([variant(falseKey, false), variant(trueKey, true)]);
+    const duplicateRow = await load([row, row]);
+    expect(duplicateRow.ok).toBe(false);
+
+    const duplicateVariant = await load([
+      standardRow([variant(trueKey, true), variant(trueKey, true)]),
+    ]);
+    expect(duplicateVariant.ok).toBe(false);
+  });
+});