@forgeax/engine-pack 0.1.2

package/src/__tests__/load-asset-config.test.ts

@@ -0,0 +1,121 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { loadAssetConfig } from '../config.js';
+
+describe('loadAssetConfig SSOT (w8 / AC-13)', () => {
+  let tmpDir: string;
+
+  beforeAll(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'forgeax-test-loadAssetConfig-'));
+  });
+
+  afterAll(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('missing package.json returns default roots + empty paths', () => {
+    const result = loadAssetConfig(join(tmpDir, 'nonexistent'));
+    expect(result.roots).toEqual([join(join(tmpDir, 'nonexistent'), 'assets')]);
+    expect(result.paths).toEqual({});
+  });
+
+  it('package.json without forgeax.assets returns default', async () => {
+    const dir = join(tmpDir, 'no-forgeax');
+    await mkdir(dir);
+    await writeFile(join(dir, 'package.json'), JSON.stringify({ name: 'test' }));
+    const result = loadAssetConfig(dir);
+    expect(result.roots).toEqual([join(dir, 'assets')]);
+    expect(result.paths).toEqual({});
+  });
+
+  it('reads forgeax.assets.roots from package.json', async () => {
+    const dir = join(tmpDir, 'with-roots');
+    await mkdir(dir);
+    await writeFile(
+      join(dir, 'package.json'),
+      JSON.stringify({
+        name: 'test',
+        forgeax: { assets: { roots: ['my-assets', 'more'] } },
+      }),
+    );
+    const result = loadAssetConfig(dir);
+    expect(result.roots).toEqual([join(dir, 'my-assets'), join(dir, 'more')]);
+    expect(result.paths).toEqual({});
+  });
+
+  it('empty forgeax.assets.roots array falls back to default', async () => {
+    const dir = join(tmpDir, 'empty-roots');
+    await mkdir(dir);
+    await writeFile(
+      join(dir, 'package.json'),
+      JSON.stringify({
+        name: 'test',
+        forgeax: { assets: { roots: [] } },
+      }),
+    );
+    const result = loadAssetConfig(dir);
+    expect(result.roots).toEqual([join(dir, 'assets')]);
+  });
+
+  it('reads forgeax.assets.paths with cwd-relative resolution', async () => {
+    const dir = join(tmpDir, 'with-paths');
+    await mkdir(dir);
+    await writeFile(
+      join(dir, 'package.json'),
+      JSON.stringify({
+        name: 'test',
+        forgeax: {
+          assets: {
+            paths: {
+              shared: 'lib/assets',
+              vendor: '../vendor-assets',
+            },
+          },
+        },
+      }),
+    );
+    const result = loadAssetConfig(dir);
+    expect(result.paths).toEqual({
+      shared: join(dir, 'lib/assets'),
+      vendor: join(dir, '../vendor-assets'),
+    });
+  });
+
+  it('paths absent defaults to empty object', async () => {
+    const dir = join(tmpDir, 'roots-only');
+    await mkdir(dir);
+    await writeFile(
+      join(dir, 'package.json'),
+      JSON.stringify({
+        name: 'test',
+        forgeax: { assets: { roots: ['a'] } },
+      }),
+    );
+    const result = loadAssetConfig(dir);
+    expect(result.paths).toEqual({});
+  });
+
+  it('non-string path values are skipped', async () => {
+    const dir = join(tmpDir, 'bad-paths');
+    await mkdir(dir);
+    await writeFile(
+      join(dir, 'package.json'),
+      JSON.stringify({
+        name: 'test',
+        forgeax: {
+          assets: {
+            paths: {
+              good: 'lib/a',
+              badNum: 42,
+              badBool: true,
+            },
+          },
+        },
+      }),
+    );
+    const result = loadAssetConfig(dir);
+    expect(result.paths).toEqual({ good: join(dir, 'lib/a') });
+  });
+});

package/src/__tests__/material-cook-dependencies.unit.test.ts

@@ -0,0 +1,45 @@
+import type { AssetGuid } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { collectMaterialCookRefs } from '../evidence/material-cook.js';
+
+describe('material cook dependency closure', () => {
+  it('collects parent, texture, sampler, and module references', () => {
+    expect(
+      collectMaterialCookRefs({
+        parent: 'mat-parent' as unknown as AssetGuid,
+        passes: [{ name: 'forward', program: { module: 'module/pbr' } }],
+        values: {
+          baseColor: {
+            texture: 'texture/albedo' as unknown as AssetGuid,
+            sampler: 'sampler/linear' as unknown as AssetGuid,
+          },
+        },
+      }),
+    ).toEqual({
+      parent: ['mat-parent'],
+      textures: ['texture/albedo'],
+      samplers: ['sampler/linear'],
+      modules: ['module/pbr'],
+    });
+  });
+
+  it('collects string shorthands only from declared texture parameters', () => {
+    expect(
+      collectMaterialCookRefs({
+        parameters: [
+          { name: 'surface', type: 'texture' },
+          { name: 'label', type: 'f32' },
+        ],
+        values: { surface: 'texture/albedo', label: 'not-a-texture-ref' },
+      }),
+    ).toEqual({ parent: [], textures: ['texture/albedo'], samplers: [], modules: [] });
+  });
+
+  it('treats a string value as a texture shorthand when parameters are omitted', () => {
+    expect(
+      collectMaterialCookRefs({
+        values: { baseColorTexture: 'texture/albedo' },
+      }),
+    ).toEqual({ parent: [], textures: ['texture/albedo'], samplers: [], modules: [] });
+  });
+});

package/src/__tests__/material-cook-receipt.unit.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import {
+  type MaterialCookReceipt,
+  serializeMaterialCookReceipt,
+  validateMaterialCookReceipt,
+} from '../evidence/material-cook.js';
+
+const layoutIdentity = 'sha256:layout-identity';
+const artifactDigest = 'sha256:output';
+
+function receipt(overrides: Record<string, unknown> = {}): MaterialCookReceipt {
+  return {
+    schemaVersion: 'material-cook/2',
+    sourceClosure: ['b.wgsl', 'a.material.json'],
+    profile: 'webgpu/v1',
+    compilerVersion: 'compiler/1',
+    inputDigest: 'sha256:input',
+    outputDigest: artifactDigest,
+    layoutIdentity,
+    derivedInterface: { layoutIdentity },
+    ...overrides,
+  } as unknown as MaterialCookReceipt;
+}
+
+describe('material cook receipt', () => {
+  it('serializes a material-cook/2 receipt stably for equivalent cooks', () => {
+    const first = serializeMaterialCookReceipt(receipt());
+    const second = serializeMaterialCookReceipt(
+      receipt({ sourceClosure: ['a.material.json', 'b.wgsl'] }),
+    );
+    expect(first).toBe(second);
+    expect(JSON.parse(first)).toMatchObject({
+      schemaVersion: 'material-cook/2',
+      layoutIdentity,
+      derivedInterface: { layoutIdentity },
+    });
+  });
+
+  it('accepts the expected identity and rejects schema or interface mutations', () => {
+    const expected = { layoutIdentity, artifactDigest, inputDigest: 'sha256:input' };
+    expect(validateMaterialCookReceipt(receipt(), expected)).toEqual({
+      ok: true,
+      value: receipt(),
+    });
+    expect(
+      validateMaterialCookReceipt(receipt({ layoutIdentity: 'sha256:changed-layout' }), expected),
+    ).toMatchObject({ ok: false, error: { code: 'material-cook-record-invalid' } });
+    expect(
+      validateMaterialCookReceipt(
+        receipt({ derivedInterface: { layoutIdentity: 'sha256:changed-layout' } }),
+        expected,
+      ),
+    ).toMatchObject({ ok: false, error: { code: 'material-cook-record-invalid' } });
+  });
+
+  it('rejects missing, stale, mismatched, and material-cook/1 receipts fail-fast', () => {
+    const expected = { layoutIdentity, artifactDigest, inputDigest: 'sha256:input' };
+    for (const value of [
+      receipt({ layoutIdentity: undefined }),
+      receipt({ outputDigest: 'sha256:stale-artifact' }),
+      receipt({ inputDigest: 'sha256:stale-input' }),
+      {
+        sourceClosure: [],
+        profile: 'webgpu/v1',
+        compilerVersion: 'compiler/1',
+        inputDigest: 'sha256:input',
+        outputDigest: artifactDigest,
+      },
+    ]) {
+      expect(validateMaterialCookReceipt(value as MaterialCookReceipt, expected)).toMatchObject({
+        ok: false,
+        error: { code: 'material-cook-record-invalid' },
+      });
+    }
+  });
+
+  it('records the coordinator-owned publication generation', () => {
+    const receipt = {
+      sourceClosure: ['materials/mat-root.material.json'],
+      profile: 'webgpu/v1',
+      compilerVersion: 'compiler/1',
+      inputDigest: 'sha256:input',
+      outputDigest: 'sha256:artifact',
+      publicationGeneration: 11,
+    };
+    expect(receipt).toMatchObject({
+      publicationGeneration: 11,
+      outputDigest: 'sha256:artifact',
+    });
+  });
+});

package/src/__tests__/material-cook-schema.unit.test.ts

@@ -0,0 +1,98 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import {
+  type CookedMaterialRecord,
+  createMaterialArtifactDigest,
+  projectCookedMaterialRecord,
+  serializeCookedMaterialRecord,
+  validateCookedMaterialRecord,
+} from '../evidence/material-cook.js';
+
+const record: CookedMaterialRecord = {
+  schemaVersion: 'material-cook/2',
+  guid: 'mat-root',
+  authored: {
+    kind: 'material',
+    passes: [{ name: 'forward', program: { module: 'core/pbr' } }],
+    parameters: [{ name: 'roughness', type: 'f32', static: true }],
+    values: { roughness: 0.5 },
+  },
+  resolved: {
+    passes: [{ name: 'forward', program: { module: 'core/pbr' } }],
+    parameters: [{ name: 'roughness', type: 'f32', static: true }],
+    values: { roughness: 0.5 },
+  },
+  refs: { parent: [], textures: [], samplers: [], modules: ['core/pbr'] },
+  artifact: {
+    mediaType: 'text/wgsl',
+    path: 'materials/mat-root/forward.wgsl',
+    digest: 'sha256:artifact',
+    bytes: new TextEncoder().encode('shader'),
+  },
+  receipt: {
+    schemaVersion: 'material-cook/2',
+    sourceClosure: ['materials/mat-root.material.json'],
+    profile: 'webgpu/v1',
+    compilerVersion: 'compiler/1',
+    inputDigest: 'sha256:input',
+    outputDigest: 'sha256:artifact',
+    layoutIdentity: 'sha256:layout',
+    derivedInterface: { layoutIdentity: 'sha256:layout' },
+  },
+};
+
+describe('cooked material schema', () => {
+  it('requires material-cook/2 identity and derived interface association', () => {
+    const schema = JSON.parse(
+      readFileSync(
+        fileURLToPath(new URL('../schema/material-cook.schema.json', import.meta.url)),
+        'utf8',
+      ),
+    ) as {
+      properties: Record<
+        string,
+        { const?: string; required?: string[]; properties?: Record<string, unknown> }
+      >;
+      required: string[];
+    };
+    expect(schema.properties.schemaVersion?.const).toBe('material-cook/2');
+    expect(schema.properties.receipt?.required).toEqual(
+      expect.arrayContaining(['layoutIdentity', 'derivedInterface']),
+    );
+    expect(schema.properties.receipt?.properties?.derivedInterface).toBeDefined();
+  });
+
+  it('serializes a stable cooked DTO and derives an artifact digest', () => {
+    const first = serializeCookedMaterialRecord(record);
+    const second = serializeCookedMaterialRecord({ ...record });
+
+    expect(first).toBe(second);
+    expect(createMaterialArtifactDigest(record.artifact.bytes)).toBe(
+      'sha256:e137e75a5e0e7a623ca39de480667a55b43e0eedec58767634ebaef07c33383a',
+    );
+    expect(validateCookedMaterialRecord(JSON.parse(first))).toEqual({ ok: true, value: record });
+  });
+
+  it('projects cooked data without exposing an authored GUID entry', () => {
+    const projection = projectCookedMaterialRecord(record);
+
+    expect(projection.resolved.values).toEqual({ roughness: 0.5 });
+    expect(projection.artifact.digest).toBe('sha256:artifact');
+    expect(projection).not.toHaveProperty('guid');
+    expect(projection).not.toHaveProperty('authored');
+  });
+
+  it('rejects missing fields and unsupported schema versions', () => {
+    expect(validateCookedMaterialRecord({ ...record, refs: undefined })).toMatchObject({
+      ok: false,
+      error: { code: 'material-cook-record-invalid' },
+    });
+    expect(
+      validateCookedMaterialRecord({ ...record, schemaVersion: 'material-cook/1' }),
+    ).toMatchObject({
+      ok: false,
+      error: { code: 'material-cook-record-invalid' },
+    });
+  });
+});

package/src/__tests__/mesh-bin-consumer-surface.unit.test.ts

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const encoderSource = readFileSync(
+  new URL('../../../import/src/mesh-bin.ts', import.meta.url),
+  'utf8',
+);
+const decoderSource = readFileSync(
+  new URL('../../../geometry/src/assets/mesh-binary.ts', import.meta.url),
+  'utf8',
+);
+
+describe('mesh-bin consumer owner surface', () => {
+  it('routes both production halves through Pack-owned facts', () => {
+    for (const source of [encoderSource, decoderSource]) {
+      expect(source).toContain("from '@forgeax/engine-pack'");
+      expect(source).toContain('MESH_BIN_HEADER_V4_BYTES');
+      expect(source).not.toContain('const HEADER_V2_BYTES = 28');
+    }
+  });
+});

package/src/__tests__/mesh-bin-contract.unit.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import {
+  decodeMeshBinHeader,
+  MESH_BIN_HEADER_V4_BYTES,
+  MESH_BIN_VERSION,
+} from '../mesh-bin-contract.js';
+
+describe('mesh-bin v4 wire contract', () => {
+  it('owns a fixed v4 header and rejects legacy versions at the contract boundary', () => {
+    expect(MESH_BIN_VERSION).toBe(4);
+    expect(MESH_BIN_HEADER_V4_BYTES).toBeGreaterThan(28);
+    expect(decodeMeshBinHeader(new Uint8Array(MESH_BIN_HEADER_V4_BYTES))).toMatchObject({
+      ok: false,
+      error: { code: 'mesh-bin-version-unsupported' },
+    });
+  });
+
+  it('reports truncated headers as structured failures with recovery context', () => {
+    const result = decodeMeshBinHeader(new Uint8Array(MESH_BIN_HEADER_V4_BYTES - 1), 'mesh/source');
+    expect(result).toMatchObject({
+      ok: false,
+      error: {
+        code: 'mesh-bin-header-truncated',
+        subject: 'mesh-bin',
+        sourceKey: 'mesh/source',
+        expected: expect.any(String),
+        actual: expect.any(String),
+        recovery: expect.stringContaining('re-cook'),
+      },
+    });
+  });
+});

package/src/__tests__/meta-schema-optional.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, it } from 'vitest';
+import { validateMeta } from '../schema-compiled.js';
+import { SCRIPTABLE_PACK_ASSET_KINDS } from '../scriptable-pack.js';
+
+describe('meta.schema.json source optional (w8 / AC-4)', () => {
+  const minimalMeta = {
+    schemaVersion: '1.0.0',
+    kind: 'external-asset-package',
+    importer: 'image',
+    importSettings: {},
+    subAssets: [{ guid: '00000000-0000-4000-8000-000000000001', sourceIndex: 0, kind: 'texture' }],
+  };
+
+  it('meta without source key passes ajv validation (AC-4)', () => {
+    const valid = validateMeta(minimalMeta);
+    expect(valid).toBe(true);
+  });
+
+  it('meta with explicit source passes ajv validation (AC-1 back-compat)', () => {
+    const metaWithSource = { ...minimalMeta, source: 'foo.png' };
+    const valid = validateMeta(metaWithSource);
+    expect(valid).toBe(true);
+  });
+
+  it('meta missing required field importer fails validation', () => {
+    const { importer: _, ...withoutImporter } = minimalMeta;
+    const valid = validateMeta(withoutImporter);
+    expect(valid).toBe(false);
+  });
+
+  it('ajv reinstantiation idempotent — same validator returns same result', () => {
+    const valid1 = validateMeta(minimalMeta);
+    const valid2 = validateMeta(minimalMeta);
+    expect(valid1).toBe(valid2);
+  });
+});
+
+describe('meta.schema.json subAssets[].kind open-string (w6 / D-1 scheme A)', () => {
+  const metaWithSubKind = (kind: string) => ({
+    schemaVersion: '1.0.0',
+    kind: 'external-asset-package',
+    importer: 'image',
+    importSettings: {},
+    subAssets: [{ guid: '00000000-0000-4000-8000-000000000001', sourceIndex: 0, kind }],
+  });
+
+  // (a) Host custom kind passes validation — RED against current closed enum,
+  //     GREEN after schema enum is dropped to open string with minLength: 1.
+  //     When this test is red it proves the enum wall exists; when it turns
+  //     green it proves D-1 scheme A is effective.
+  it('(a) host custom kind passes validation (red→green)', () => {
+    const valid = validateMeta(metaWithSubKind('reel-game-blob'));
+    expect(valid).toBe(true);
+  });
+
+  // (b) Zero-regression: all 12 known kind values from the prior closed enum
+  //     still pass validation.  'image' is included here because the schema
+  //     layer does NOT decommission it — the fold layer (M4) handles that.
+  const knownKinds = [
+    'mesh',
+    'material',
+    'scene',
+    'texture',
+    'image',
+    'cube-texture',
+    'material-shader',
+    'skeleton',
+    'skin',
+    'animation-clip',
+    'audio',
+    'font',
+  ];
+
+  for (const kind of knownKinds) {
+    it(`(b) known kind '${kind}' passes validation (zero-regression)`, () => {
+      const valid = validateMeta(metaWithSubKind(kind));
+      expect(valid).toBe(true);
+    });
+  }
+
+  for (const kind of SCRIPTABLE_PACK_ASSET_KINDS) {
+    it(`published durable kind '${kind}' remains valid in open Meta schema`, () => {
+      expect(validateMeta(metaWithSubKind(kind))).toBe(true);
+    });
+  }
+
+  // (c) Empty string rejected by minLength: 1 (schema layer gate).
+  it('(c) empty-string kind fails validation (minLength: 1)', () => {
+    const valid = validateMeta(metaWithSubKind(''));
+    expect(valid).toBe(false);
+  });
+
+  // (d) subAssets[].kind field still exists in the schema and is typed as
+  //     string (AC-06 + OOS-2: field not deleted, only enum removed).
+  it('(d) subAssets[].kind field is string-typed and required', () => {
+    // Verify kind field is required — missing it fails.
+    const withoutKind = {
+      schemaVersion: '1.0.0',
+      kind: 'external-asset-package',
+      importer: 'image',
+      importSettings: {},
+      subAssets: [{ guid: '00000000-0000-4000-8000-000000000001', sourceIndex: 0 }],
+    };
+    expect(validateMeta(withoutKind)).toBe(false);
+
+    // Verify kind with non-string value (number) fails type check.
+    const numberKind = {
+      schemaVersion: '1.0.0',
+      kind: 'external-asset-package',
+      importer: 'image',
+      importSettings: {},
+      subAssets: [{ guid: '00000000-0000-4000-8000-000000000001', sourceIndex: 0, kind: 42 }],
+    };
+    expect(validateMeta(numberKind)).toBe(false);
+  });
+});

package/src/__tests__/meta-source-overrides.unit.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+import { validateProducerContract } from '../producer-contract.js';
+import { validateMeta } from '../schema-compiled.js';
+
+const baseMeta = () => ({
+  schemaVersion: '1.0.0',
+  kind: 'external-asset-package',
+  importer: 'fixture',
+  importSettings: {},
+  subAssets: [
+    {
+      guid: '11111111-1111-4111-8111-111111111111',
+      sourceIndex: 0,
+      sourceKey: 'mesh/main',
+      kind: 'mesh',
+    },
+  ],
+});
+
+describe('Meta sourceOverrides', () => {
+  it('accepts a legal optional override without narrowing its payload', () => {
+    const meta = {
+      ...baseMeta(),
+      sourceOverrides: { 'mesh/main': { lod: 2, customProducerField: true } },
+    };
+    expect(validateMeta(meta)).toBe(true);
+    expect(validateProducerContract(meta)).toMatchObject({ ok: true });
+  });
+
+  it('rejects unknown or duplicate source keys before publication', () => {
+    const unknown = {
+      ...baseMeta(),
+      sourceOverrides: { 'mesh/other': { lod: 1 } },
+    };
+    const unknownResult = validateProducerContract(unknown);
+    expect(unknownResult).toMatchObject({
+      ok: false,
+      error: {
+        code: 'unknown-source-key',
+        authority: 'pack',
+      },
+    });
+
+    const duplicate = {
+      ...baseMeta(),
+      subAssets: [
+        ...baseMeta().subAssets,
+        {
+          guid: '22222222-2222-4222-8222-222222222222',
+          sourceIndex: 1,
+          sourceKey: 'mesh/main',
+          kind: 'mesh',
+        },
+      ],
+      sourceOverrides: { 'mesh/main': { lod: 1 } },
+    };
+    expect(validateProducerContract(duplicate)).toMatchObject({
+      ok: false,
+      error: { code: 'duplicate-source-key' },
+    });
+  });
+
+  it('keeps omitted and empty overrides equivalent to legacy Meta', () => {
+    const legacy = baseMeta();
+    const empty = { ...legacy, sourceOverrides: {} };
+    expect(validateMeta(legacy)).toBe(true);
+    expect(validateMeta(empty)).toBe(true);
+    expect(validateProducerContract(legacy)).toMatchObject({ ok: true });
+    expect(validateProducerContract(empty)).toMatchObject({ ok: true });
+  });
+});

package/src/__tests__/native-cooker-registry.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+import { NativeCookerRegistry } from '../native-cooker-registry.js';
+
+describe('NativeCookerRegistry artifact boundary', () => {
+  it('keeps native artifact bytes available before converting to CookProduct descriptors', async () => {
+    const bytes = new TextEncoder().encode('{"program":true}');
+    const registry = new NativeCookerRegistry();
+    registry.register({
+      key: 'test-effect',
+      cook: () => ({
+        guid: '019e9c00-0000-7000-8000-000000000000',
+        payload: { kind: 'test-effect' },
+        refs: ['019e9c00-0000-7000-8000-000000000001'],
+        artifacts: {
+          'test-effect/program.json': { mediaType: 'application/json', bytes },
+        },
+        inputFingerprint: 'sha256:test-input',
+      }),
+    });
+
+    const draft = await registry.runDraft('test-effect', {});
+    expect(draft.ok).toBe(true);
+    if (!draft.ok) throw new Error(draft.error.hint);
+    expect(draft.value.artifacts['test-effect/program.json']?.bytes).toEqual(bytes);
+
+    const product = await registry.run('test-effect', {});
+    expect(product.ok).toBe(true);
+    if (!product.ok) throw new Error(product.error.hint);
+    expect(product.value.artifacts['test-effect/program.json']).toMatchObject({
+      path: 'test-effect/program.json',
+      mediaType: 'application/json',
+      byteLength: bytes.byteLength,
+    });
+  });
+
+  it('discovers a typed producer input before cooking and preserves the typed output contract', async () => {
+    const registry = new NativeCookerRegistry();
+    registry.register({
+      key: 'typed-effect',
+      discover: (input) => {
+        if (typeof input !== 'object' || input === null || !('source' in input)) {
+          throw new Error('source is required');
+        }
+        return { source: String(input.source), revision: 3 };
+      },
+      cook: (input: { readonly source: string; readonly revision: number }) => ({
+        guid: '019e9c00-0000-7000-8000-000000000010',
+        payload: { source: input.source, revision: input.revision },
+        refs: [],
+        artifacts: {
+          'typed-effect/program.json': {
+            mediaType: 'application/json',
+            bytes: new TextEncoder().encode(JSON.stringify(input)),
+          },
+        },
+        inputFingerprint: `sha256:${input.source}`,
+      }),
+    });
+
+    const result = await registry.runDraft('typed-effect', { source: 'module.wgsl' });
+    expect(result.ok).toBe(true);
+    if (result.ok) expect(result.value.payload).toEqual({ source: 'module.wgsl', revision: 3 });
+  });
+});