@forgeax/engine-import 0.1.2

package/src/__tests__/scriptable-pack-production-producers.unit.test.ts

@@ -0,0 +1,429 @@
+import { defineComponent } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type {
+  AnimationClip,
+  AnimationGraph,
+  Asset,
+  AssetGuid as AssetGuidType,
+  AudioClipAsset,
+  EquirectAsset,
+  FontAsset,
+  MaterialAsset,
+  MeshAsset,
+  ParticleEffectAsset,
+  RenderPipelineAsset,
+  SamplerAsset,
+  SceneAsset,
+  SkeletonAsset,
+  SkinAsset,
+  TextureAsset,
+  TilesetAsset,
+  VideoAsset,
+} from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { createStandardAssetOutputProducerRegistry } from '../scriptable-pack-output-producers.js';
+
+function guid(value: string): AssetGuidType {
+  const parsed = AssetGuid.parse(value);
+  if (!parsed.ok) throw parsed.error;
+  return parsed.value;
+}
+
+const MATERIAL_GUID = guid('019ffa97-3000-7000-8000-000000000001');
+const MESH_GUID = guid('019ffa97-3000-7000-8000-000000000002');
+const ScriptableMeshFilter = defineComponent('ScriptablePackTestMeshFilter', {
+  assetHandle: 'shared<MeshAsset>',
+});
+const ScriptableMeshRenderer = defineComponent('ScriptablePackTestMeshRenderer', {
+  materials: 'array<shared<MaterialAsset>>',
+});
+const componentCatalog = new Map<
+  string,
+  typeof ScriptableMeshFilter | typeof ScriptableMeshRenderer
+>([
+  [ScriptableMeshFilter.name, ScriptableMeshFilter],
+  [ScriptableMeshRenderer.name, ScriptableMeshRenderer],
+]);
+
+const OUTPUT_GUID = guid('019ffa97-3000-7000-8000-000000000010');
+const ATLAS_GUID = guid('019ffa97-3000-7000-8000-000000000011');
+const SKELETON_GUID = guid('019ffa97-3000-7000-8000-000000000012');
+
+function canonicalAttributes(vertexCount: number): MeshAsset['attributes'] {
+  return {
+    position: new Float32Array(vertexCount * 3),
+    normal: new Float32Array(vertexCount * 3),
+    uv: new Float32Array(vertexCount * 2),
+    tangent: new Float32Array(vertexCount * 4),
+  };
+}
+
+const particleProgram = {
+  format: 'forgeax-vfx-program-2',
+  fingerprint: 'sha256:scriptable-pack-matrix',
+  emitters: [
+    {
+      id: 'default',
+      module: 'matrix/default',
+      capacity: 16,
+      backend: { required: 'gpu' },
+      space: 'local',
+      schedule: {},
+      bounds: {},
+      renderers: [],
+      simulationWhenCulled: 'pause',
+      wgsl: 'fn main() {}',
+      reflection: {},
+    },
+  ],
+} as const;
+
+const matrixAssets = [
+  {
+    kind: 'mesh',
+    vertices: new Float32Array(48),
+    indices: new Uint16Array([0]),
+    attributes: canonicalAttributes(4),
+    submeshes: [],
+    materialSlots: [],
+  } satisfies MeshAsset,
+  { kind: 'material', values: { roughness: 0.5 } } satisfies MaterialAsset,
+  { kind: 'scene', entities: [] } satisfies SceneAsset,
+  {
+    kind: 'texture',
+    width: 1,
+    height: 1,
+    format: 'rgba8unorm',
+    data: new Uint8Array([255, 255, 255, 255]),
+    colorSpace: 'srgb',
+    mipmap: false,
+  } satisfies TextureAsset,
+  {
+    kind: 'equirect',
+    width: 1,
+    height: 1,
+    format: 'rgba16float',
+    data: new Uint8Array(8),
+    colorSpace: 'linear',
+  } satisfies EquirectAsset,
+  { kind: 'sampler', magFilter: 'linear' } satisfies SamplerAsset,
+  {
+    kind: 'font',
+    atlas: ATLAS_GUID,
+    sampler: OUTPUT_GUID,
+    glyphs: {},
+    common: {
+      lineHeight: 1,
+      base: 1,
+      distanceRange: 4,
+      pxRange: 4,
+      atlasWidth: 1,
+      atlasHeight: 1,
+    },
+  } satisfies FontAsset,
+  { kind: 'render-pipeline', pipelineId: 'forgeax::urp' } satisfies RenderPipelineAsset,
+  {
+    kind: 'tileset',
+    atlases: [AssetGuid.format(ATLAS_GUID)],
+    tileWidth: 1,
+    tileHeight: 1,
+    columns: 1,
+    rows: 1,
+    regions: [{ x: 0, y: 0, width: 1, height: 1 }],
+    tiles: [{ regionIndex: 0 }],
+  } satisfies TilesetAsset,
+  { kind: 'video', url: 'https://example.test/scene.webm' } satisfies VideoAsset,
+  {
+    kind: 'skeleton',
+    inverseBindMatrices: new Float32Array(16),
+    jointCount: 1,
+  } satisfies SkeletonAsset,
+  {
+    kind: 'skin',
+    skeletonGuid: AssetGuid.format(SKELETON_GUID),
+    jointPaths: ['root'],
+  } satisfies SkinAsset,
+  { kind: 'animation-clip', duration: 1, channels: [] } satisfies AnimationClip,
+  {
+    kind: 'animation-graph',
+    nodes: [{ type: 'clip', clip: AssetGuid.format(OUTPUT_GUID), weight: 1 }],
+    root: 0,
+  } satisfies AnimationGraph,
+  {
+    kind: 'audio',
+    sourceKey: 'audio/matrix',
+    mediaType: 'audio/wav',
+    bytes: new Uint8Array([82, 73, 70, 70]),
+  } satisfies AudioClipAsset,
+  {
+    kind: 'particle-effect',
+    schemaVersion: 2,
+    programFingerprint: particleProgram.fingerprint,
+    emitters: [{ id: 'default', capacity: 16 }],
+    program: particleProgram,
+  } satisfies ParticleEffectAsset,
+] as const satisfies readonly Asset[];
+
+describe('standard ScriptablePack output producers', () => {
+  void ScriptableMeshFilter;
+  void ScriptableMeshRenderer;
+  it('registers the production producer versions for all ordinary Asset kinds', () => {
+    const registry = createStandardAssetOutputProducerRegistry();
+    expect(registry.versions()).toEqual({
+      'animation-clip': 'ordinary-pod/1',
+      'animation-graph': 'ordinary-pod/1',
+      audio: 'ordinary-pod/1',
+      equirect: 'ordinary-pod/1',
+      font: 'ordinary-pod/1',
+      material: 'material-pack/1',
+      mesh: 'mesh-binary/4',
+      'particle-effect': 'ordinary-pod/1',
+      'render-pipeline': 'ordinary-pod/1',
+      sampler: 'ordinary-pod/1',
+      scene: 'scene-pack/2',
+      skeleton: 'ordinary-pod/1',
+      skin: 'ordinary-pod/1',
+      texture: 'ordinary-pod/1',
+      tileset: 'ordinary-pod/1',
+      video: 'ordinary-pod/1',
+    });
+  });
+
+  it('provides a real producer contract for every ordinary Asset kind', async () => {
+    const registry = createStandardAssetOutputProducerRegistry();
+    const expectedKinds = [
+      'mesh',
+      'material',
+      'scene',
+      'texture',
+      'equirect',
+      'sampler',
+      'font',
+      'render-pipeline',
+      'tileset',
+      'video',
+      'skeleton',
+      'skin',
+      'animation-clip',
+      'animation-graph',
+      'audio',
+      'particle-effect',
+    ] as const;
+
+    expect(Object.keys(registry.versions()).sort()).toEqual([...expectedKinds].sort());
+    for (const [index, asset] of matrixAssets.entries()) {
+      const producer = registry.get(asset.kind);
+      expect(producer, `${asset.kind} producer`).toBeDefined();
+      if (producer === undefined) continue;
+      const result = await producer.produce({
+        guid: AssetGuid.format(OUTPUT_GUID),
+        sourceKey: `matrix/${index}/${asset.kind}`,
+        asset,
+      });
+      expect(result.ok, `${asset.kind} producer result`).toBe(true);
+      if (!result.ok) continue;
+      expect(result.value.payload.kind ?? asset.kind).toBe(asset.kind);
+      const hasPayload = Object.keys(result.value.payload).length > 0;
+      const hasDescriptor =
+        asset.kind === 'video' &&
+        'url' in asset &&
+        typeof asset.url === 'string' &&
+        asset.url.length > 0;
+      expect(
+        hasPayload ||
+          result.value.refs.length + Object.keys(result.value.artifacts).length > 0 ||
+          hasDescriptor,
+        `${asset.kind} producer facts`,
+      ).toBe(true);
+    }
+  });
+
+  it('publishes media and VFX producer facts without host execution', async () => {
+    const registry = createStandardAssetOutputProducerRegistry();
+    for (const kind of ['audio', 'video', 'particle-effect'] as const) {
+      const asset = matrixAssets.find((candidate) => candidate.kind === kind);
+      const producer = registry.get(kind);
+      expect(producer, `${kind} producer`).toBeDefined();
+      expect(asset, `${kind} fixture`).toBeDefined();
+      if (producer === undefined || asset === undefined) continue;
+      const result = await producer.produce({
+        guid: AssetGuid.format(OUTPUT_GUID),
+        sourceKey: `media/${kind}`,
+        asset,
+      });
+      expect(result.ok, `${kind} result`).toBe(true);
+      if (!result.ok) continue;
+      if (kind === 'video') {
+        expect(result.value.payload).toMatchObject({ kind, url: (asset as VideoAsset).url });
+      } else {
+        expect(Object.keys(result.value.artifacts)).not.toHaveLength(0);
+      }
+    }
+  });
+
+  it('serializes a scene through component schemas and emits recursive GUID refs', async () => {
+    const registry = createStandardAssetOutputProducerRegistry();
+    const producer = registry.get('scene');
+    expect(producer).toBeDefined();
+    if (producer === undefined) return;
+
+    const scene: SceneAsset = {
+      kind: 'scene',
+      entities: [
+        {
+          localId: 0 as never,
+          components: {
+            ScriptablePackTestMeshFilter: { assetHandle: AssetGuid.format(MESH_GUID) },
+            ScriptablePackTestMeshRenderer: {
+              materials: [AssetGuid.format(MATERIAL_GUID)],
+            },
+          },
+        },
+      ],
+    };
+    const result = await producer.produce({
+      guid: '019ffa97-3000-7000-8000-000000000003',
+      sourceKey: 'scene/showcase',
+      asset: scene,
+      components: componentCatalog,
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.payload).toMatchObject({
+      entities: [
+        {
+          localId: 0,
+          components: {
+            ScriptablePackTestMeshFilter: { assetHandle: 0 },
+            ScriptablePackTestMeshRenderer: { materials: [1] },
+          },
+        },
+      ],
+    });
+    expect(result.value.refs).toEqual([
+      {
+        guid: AssetGuid.format(MESH_GUID),
+        sourceField: {
+          componentName: 'ScriptablePackTestMeshFilter',
+          fieldName: 'assetHandle',
+        },
+        sceneEntityId: 0,
+      },
+      {
+        guid: AssetGuid.format(MATERIAL_GUID),
+        sourceField: {
+          componentName: 'ScriptablePackTestMeshRenderer',
+          fieldName: 'materials',
+          arrayIndex: 0,
+        },
+        sceneEntityId: 0,
+      },
+    ]);
+  });
+
+  it('packs mesh bytes and projects material parent references', async () => {
+    const registry = createStandardAssetOutputProducerRegistry();
+    const mesh = registry.get('mesh');
+    const material = registry.get('material');
+    expect(mesh).toBeDefined();
+    expect(material).toBeDefined();
+    if (mesh === undefined || material === undefined) return;
+
+    const meshAsset: MeshAsset = {
+      kind: 'mesh',
+      vertices: new Float32Array(48),
+      indices: new Uint16Array([0]),
+      attributes: canonicalAttributes(4),
+      submeshes: [],
+      materialSlots: [{ slotName: 'Default', defaultMaterial: MATERIAL_GUID }],
+    };
+    const meshResult = await mesh.produce({
+      guid: AssetGuid.format(MESH_GUID),
+      sourceKey: 'mesh/generated',
+      asset: meshAsset,
+    });
+    expect(meshResult.ok).toBe(true);
+    if (meshResult.ok)
+      expect(meshResult.value.artifacts.body?.bytes.byteLength).toBeGreaterThan(28);
+
+    const materialAsset: MaterialAsset = { kind: 'material', parent: MATERIAL_GUID };
+    const materialResult = await material.produce({
+      guid: AssetGuid.format(MATERIAL_GUID),
+      sourceKey: 'material/generated',
+      asset: materialAsset,
+    });
+    expect(materialResult.ok).toBe(true);
+    if (materialResult.ok) {
+      expect(materialResult.value.payload).toMatchObject({ parent: 0 });
+      expect(materialResult.value.refs).toEqual([
+        { guid: AssetGuid.format(MATERIAL_GUID), sourceField: { fieldName: 'parent' } },
+      ]);
+    }
+  });
+
+  it('keeps ordinary output identities and serialized bytes stable across builds', async () => {
+    const registry = createStandardAssetOutputProducerRegistry();
+    const mesh = registry.get('mesh');
+    const material = registry.get('material');
+    const scene = registry.get('scene');
+    expect(mesh).toBeDefined();
+    expect(material).toBeDefined();
+    expect(scene).toBeDefined();
+    if (mesh === undefined || material === undefined || scene === undefined) return;
+
+    const inputs = [
+      {
+        guid: AssetGuid.format(MESH_GUID),
+        sourceKey: 'mesh/generated',
+        asset: {
+          kind: 'mesh' as const,
+          vertices: new Float32Array([
+            0, 0, 0, 0, 0, 1, 0.5, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0.5, 1, 0, 0, 0, 1, 1, 0, 0, 0,
+            0, 1, 1, 1, 0, 0, 0, 1,
+          ]),
+          indices: new Uint16Array([0, 1, 2]),
+          attributes: canonicalAttributes(3),
+          aabb: new Float32Array([0, 0, 0, 1, 1, 0]),
+          submeshes: [
+            {
+              topology: 'triangle-list' as const,
+              indexOffset: 0,
+              indexCount: 3,
+              vertexCount: 3,
+              materialSlot: 0,
+            },
+          ],
+          materialSlots: [{ slotName: 'Default' }],
+        },
+        producer: mesh,
+      },
+      {
+        guid: AssetGuid.format(MATERIAL_GUID),
+        sourceKey: 'material/generated',
+        asset: { kind: 'material' as const, values: {} },
+        producer: material,
+      },
+      {
+        guid: AssetGuid.format(guid('019ffa97-3000-7000-8000-000000000003')),
+        sourceKey: 'scene/generated',
+        asset: { kind: 'scene' as const, entities: [] },
+        producer: scene,
+      },
+    ];
+    const first = await Promise.all(
+      inputs.map(({ producer, ...input }) => producer.produce(input)),
+    );
+    const second = await Promise.all(
+      inputs.map(({ producer, ...input }) => producer.produce(input)),
+    );
+
+    expect(first.map((result) => result.ok)).toEqual([true, true, true]);
+    expect(second.map((result) => result.ok)).toEqual([true, true, true]);
+    expect(first).toEqual(second);
+    for (const result of first) {
+      if (!result.ok) continue;
+      expect(result.value.payload).not.toHaveProperty('scriptableKind');
+    }
+  });
+});

package/src/__tests__/scriptable-pack-staged-snapshot.unit.test.ts

@@ -0,0 +1,258 @@
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type { AssetGuid as AssetGuidType, MeshAsset } from '@forgeax/engine-types';
+import { AssetError, err, ok } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import {
+  createScriptablePackStagedAssetSnapshotSource,
+  type ScriptablePackStagedOwner,
+} from '../index.js';
+
+function guid(value: string): AssetGuidType {
+  const parsed = AssetGuid.parse(value);
+  if (!parsed.ok) throw parsed.error;
+  return parsed.value;
+}
+
+function mesh(seed: number): MeshAsset {
+  return {
+    kind: 'mesh',
+    vertices: new Float32Array([seed, 0, 0]),
+    attributes: {},
+    submeshes: [
+      {
+        topology: 'triangle-list',
+        indexOffset: 0,
+        indexCount: 0,
+        vertexCount: 1,
+        materialSlot: 0,
+      },
+    ],
+    materialSlots: [{ slotName: 'Default' }],
+  };
+}
+
+const ROOT = guid('019ffa97-2000-7000-8000-000000000001');
+const DEPENDENCY = guid('019ffa97-2000-7000-8000-000000000002');
+const HEALTHY = guid('019ffa97-2000-7000-8000-000000000003');
+
+describe('ScriptablePack staged asset snapshot source', () => {
+  it('lazily builds owners in one generation, memoizes, and returns private clones', async () => {
+    const builds: string[] = [];
+    const owners: ScriptablePackStagedOwner[] = [
+      {
+        id: 'dependency.pack.ts',
+        guids: [DEPENDENCY],
+        async build() {
+          builds.push('dependency');
+          return ok([{ guid: DEPENDENCY, asset: mesh(2), digest: 'sha256:dependency' }]);
+        },
+      },
+      {
+        id: 'root.pack.ts',
+        guids: [ROOT],
+        async build(source) {
+          builds.push('root:start');
+          const dependency = await source.readByGuid(DEPENDENCY);
+          if (!dependency.ok) return dependency;
+          builds.push('root:end');
+          const value = dependency.value.asset as MeshAsset;
+          return ok([{ guid: ROOT, asset: mesh(value.vertices[0] ?? 0) }]);
+        },
+      },
+    ];
+    const source = createScriptablePackStagedAssetSnapshotSource({ generation: 12, owners });
+    const first = await source.readByGuid(ROOT);
+    expect(first).toMatchObject({ ok: true, value: { generation: 12 } });
+    if (!first.ok) return;
+    expect(builds).toEqual(['root:start', 'dependency', 'root:end']);
+    expect((first.value.asset as MeshAsset).vertices[0]).toBe(2);
+
+    (first.value.asset as MeshAsset).vertices[0] = 99;
+    const second = await source.readByGuid(ROOT);
+    expect(second.ok && (second.value.asset as MeshAsset).vertices[0]).toBe(2);
+    expect(builds).toEqual(['root:start', 'dependency', 'root:end']);
+    expect(second.ok && second.value.digest).toMatch(/^sha256:/);
+  });
+
+  it('fails a content dependency cycle structurally without consulting fallback', async () => {
+    let fallbackReads = 0;
+    const owners: ScriptablePackStagedOwner[] = [
+      {
+        id: 'a.pack.ts',
+        guids: [ROOT],
+        async build(source) {
+          const result = await source.readByGuid(DEPENDENCY);
+          return result.ok ? ok([{ guid: ROOT, asset: result.value.asset }]) : result;
+        },
+      },
+      {
+        id: 'b.pack.ts',
+        guids: [DEPENDENCY],
+        async build(source) {
+          const result = await source.readByGuid(ROOT);
+          return result.ok ? ok([{ guid: DEPENDENCY, asset: result.value.asset }]) : result;
+        },
+      },
+    ];
+    const source = createScriptablePackStagedAssetSnapshotSource({
+      generation: 1,
+      owners,
+      fallback: {
+        async readByGuid() {
+          fallbackReads += 1;
+          return ok({ asset: mesh(8), generation: 0, digest: 'lkg' });
+        },
+      },
+    });
+    const result = await source.readByGuid(ROOT);
+    expect(result).toMatchObject({
+      ok: false,
+      error: {
+        code: 'pack-source-build-cycle',
+        actual: 'a.pack.ts -> b.pack.ts -> a.pack.ts',
+      },
+    });
+    expect(fallbackReads).toBe(0);
+  });
+
+  it('retries a refused local owner on the same source and coalesces repaired reads', async () => {
+    let rootBuilds = 0;
+    let dependencyBuilds = 0;
+    let healthyBuilds = 0;
+    let fallbackReads = 0;
+    let repaired = false;
+    let releaseRepair!: () => void;
+    const repairBuildGate = new Promise<void>((resolve) => {
+      releaseRepair = resolve;
+    });
+    const failure = new AssetError({
+      code: 'asset-not-imported',
+      expected: 'the repaired local ScriptablePack capability',
+      hint: 'repair the local producer capability and retry the same source',
+    });
+    const owners: ScriptablePackStagedOwner[] = [
+      {
+        id: 'dependency.pack.ts',
+        guids: [DEPENDENCY],
+        async build() {
+          dependencyBuilds += 1;
+          return ok([{ guid: DEPENDENCY, asset: mesh(2), digest: 'sha256:dependency' }]);
+        },
+      },
+      {
+        id: 'root.pack.ts',
+        guids: [ROOT],
+        async build(source) {
+          rootBuilds += 1;
+          const dependency = await source.readByGuid(DEPENDENCY);
+          if (!dependency.ok) return dependency;
+          if (!repaired) return err(failure);
+          await repairBuildGate;
+          const value = dependency.value.asset as MeshAsset;
+          return ok([
+            { guid: ROOT, asset: mesh((value.vertices[0] ?? 0) + 1), digest: 'sha256:root' },
+          ]);
+        },
+      },
+      {
+        id: 'healthy.pack.ts',
+        guids: [HEALTHY],
+        async build() {
+          healthyBuilds += 1;
+          return ok([{ guid: HEALTHY, asset: mesh(7), digest: 'sha256:healthy' }]);
+        },
+      },
+    ];
+    const source = createScriptablePackStagedAssetSnapshotSource({
+      generation: 27,
+      owners,
+      fallback: {
+        async readByGuid() {
+          fallbackReads += 1;
+          return ok({ asset: mesh(99), generation: 0, digest: 'sha256:lkg' });
+        },
+      },
+    });
+
+    const refused = await source.readByGuid(ROOT);
+    expect(refused).toMatchObject({
+      ok: false,
+      error: {
+        code: 'asset-not-imported',
+        expected: 'the repaired local ScriptablePack capability',
+        hint: 'repair the local producer capability and retry the same source',
+      },
+    });
+    expect(rootBuilds).toBe(1);
+    expect(dependencyBuilds).toBe(1);
+    expect(fallbackReads).toBe(0);
+
+    const healthy = await source.readByGuid(HEALTHY);
+    expect(healthy).toMatchObject({
+      ok: true,
+      value: { generation: 27, digest: 'sha256:healthy' },
+    });
+    expect(healthyBuilds).toBe(1);
+    expect(fallbackReads).toBe(0);
+
+    repaired = true;
+    const repairedReads = [
+      source.readByGuid(ROOT),
+      source.readByGuid(ROOT),
+      source.readByGuid(ROOT),
+    ];
+    expect(rootBuilds).toBe(2);
+    releaseRepair();
+    const [first, second, third] = await Promise.all(repairedReads);
+    if (
+      first === undefined ||
+      second === undefined ||
+      third === undefined ||
+      !first.ok ||
+      !second.ok ||
+      !third.ok
+    )
+      throw new Error('repaired concurrent reads must all return snapshots');
+    expect(first).toMatchObject({ ok: true, value: { generation: 27, digest: 'sha256:root' } });
+    expect(second).toMatchObject({ ok: true, value: { generation: 27, digest: 'sha256:root' } });
+    expect(third).toMatchObject({ ok: true, value: { generation: 27, digest: 'sha256:root' } });
+    expect((first.value.asset as MeshAsset).vertices[0]).toBe(3);
+    expect(rootBuilds).toBe(2);
+    expect(dependencyBuilds).toBe(1);
+    expect(healthyBuilds).toBe(1);
+    expect(fallbackReads).toBe(0);
+
+    const dependency = await source.readByGuid(DEPENDENCY);
+    expect(dependency).toMatchObject({
+      ok: true,
+      value: { generation: 27, digest: 'sha256:dependency' },
+    });
+    (first.value.asset as MeshAsset).vertices[0] = 99;
+    const memoized = await source.readByGuid(ROOT);
+    expect(memoized).toMatchObject({ ok: true, value: { generation: 27, digest: 'sha256:root' } });
+    expect(memoized.ok && (memoized.value.asset as MeshAsset).vertices[0]).toBe(3);
+    expect(rootBuilds).toBe(2);
+    expect(fallbackReads).toBe(0);
+  });
+
+  it('carries the staged generation into every locally built snapshot', async () => {
+    const owner: ScriptablePackStagedOwner = {
+      id: 'mesh.pack.ts',
+      guids: [ROOT],
+      async build() {
+        return ok([{ guid: ROOT, asset: mesh(3), digest: 'sha256:mesh' }]);
+      },
+    };
+    const first = await createScriptablePackStagedAssetSnapshotSource({
+      generation: 8,
+      owners: [owner],
+    }).readByGuid(ROOT);
+    const second = await createScriptablePackStagedAssetSnapshotSource({
+      generation: 9,
+      owners: [owner],
+    }).readByGuid(ROOT);
+
+    expect(first).toMatchObject({ ok: true, value: { generation: 8, digest: 'sha256:mesh' } });
+    expect(second).toMatchObject({ ok: true, value: { generation: 9, digest: 'sha256:mesh' } });
+  });
+});