@forgeax/engine-import 0.1.21 → 0.1.24

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

@@ -44,7 +44,14 @@ describe('ScriptablePack staged asset snapshot source', () => {
         guids: [DEPENDENCY],
         async build() {
           builds.push('dependency');
-          return ok([{ guid: DEPENDENCY, asset: mesh(2), digest: 'sha256:dependency' }]);
+          return ok([
+            {
+              guid: DEPENDENCY,
+              sourceKey: 'dependency',
+              asset: mesh(2),
+              digest: 'sha256:dependency',
+            },
+          ]);
         },
       },
       {
@@ -56,7 +63,7 @@ describe('ScriptablePack staged asset snapshot source', () => {
           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) }]);
+          return ok([{ guid: ROOT, sourceKey: 'root', asset: mesh(value.vertices[0] ?? 0) }]);
         },
       },
     ];
@@ -81,7 +88,9 @@ describe('ScriptablePack staged asset snapshot source', () => {
         guids: [ROOT],
         async build(source) {
           const result = await source.readByGuid(DEPENDENCY);
-          return result.ok ? ok([{ guid: ROOT, asset: result.value.asset }]) : result;
+          return result.ok
+            ? ok([{ guid: ROOT, sourceKey: 'root', asset: result.value.asset }])
+            : result;
         },
       },
       {
@@ -89,7 +98,9 @@ describe('ScriptablePack staged asset snapshot source', () => {
         guids: [DEPENDENCY],
         async build(source) {
           const result = await source.readByGuid(ROOT);
-          return result.ok ? ok([{ guid: DEPENDENCY, asset: result.value.asset }]) : result;
+          return result.ok
+            ? ok([{ guid: DEPENDENCY, sourceKey: 'dependency', asset: result.value.asset }])
+            : result;
         },
       },
     ];
@@ -101,8 +112,11 @@ describe('ScriptablePack staged asset snapshot source', () => {
     expect(result).toMatchObject({
       ok: false,
       error: {
-        code: 'pack-source-build-cycle',
-        actual: 'a.pack.ts -> b.pack.ts -> a.pack.ts',
+        code: 'pack-content-dependency-stalled',
+        detail: {
+          waitingGuids: [AssetGuid.format(ROOT)],
+          pendingSubjects: ['a.pack.ts', 'b.pack.ts', 'a.pack.ts'],
+        },
       },
     });
   });
@@ -116,7 +130,9 @@ describe('ScriptablePack staged asset snapshot source', () => {
           guids: [ROOT],
           async build(ownerSource) {
             const result = await ownerSource.readByGuid(DEPENDENCY);
-            return result.ok ? ok([{ guid: ROOT, asset: result.value.asset }]) : result;
+            return result.ok
+              ? ok([{ guid: ROOT, sourceKey: 'root', asset: result.value.asset }])
+              : result;
           },
         },
       ],
@@ -134,7 +150,7 @@ describe('ScriptablePack staged asset snapshot source', () => {
   it('resolves declared direct Pack outputs in the same generation', async () => {
     const source = createScriptablePackStagedAssetSnapshotSource({
       generation: 3,
-      declaredExternalOutputs: [{ guid: DEPENDENCY, asset: mesh(7) }],
+      declaredExternalOutputs: [{ guid: DEPENDENCY, sourceKey: 'dependency', asset: mesh(7) }],
       owners: [
         {
           id: 'root.pack.ts',
@@ -145,6 +161,7 @@ describe('ScriptablePack staged asset snapshot source', () => {
               ? ok([
                   {
                     guid: ROOT,
+                    sourceKey: 'root',
                     asset: mesh((dependency.value.asset as MeshAsset).vertices[0] ?? 0),
                   },
                 ])
@@ -178,7 +195,14 @@ describe('ScriptablePack staged asset snapshot source', () => {
         guids: [DEPENDENCY],
         async build() {
           dependencyBuilds += 1;
-          return ok([{ guid: DEPENDENCY, asset: mesh(2), digest: 'sha256:dependency' }]);
+          return ok([
+            {
+              guid: DEPENDENCY,
+              sourceKey: 'dependency',
+              asset: mesh(2),
+              digest: 'sha256:dependency',
+            },
+          ]);
         },
       },
       {
@@ -192,7 +216,12 @@ describe('ScriptablePack staged asset snapshot source', () => {
           await repairBuildGate;
           const value = dependency.value.asset as MeshAsset;
           return ok([
-            { guid: ROOT, asset: mesh((value.vertices[0] ?? 0) + 1), digest: 'sha256:root' },
+            {
+              guid: ROOT,
+              sourceKey: 'root',
+              asset: mesh((value.vertices[0] ?? 0) + 1),
+              digest: 'sha256:root',
+            },
           ]);
         },
       },
@@ -201,7 +230,9 @@ describe('ScriptablePack staged asset snapshot source', () => {
         guids: [HEALTHY],
         async build() {
           healthyBuilds += 1;
-          return ok([{ guid: HEALTHY, asset: mesh(7), digest: 'sha256:healthy' }]);
+          return ok([
+            { guid: HEALTHY, sourceKey: 'healthy', asset: mesh(7), digest: 'sha256:healthy' },
+          ]);
         },
       },
     ];
@@ -272,7 +303,7 @@ describe('ScriptablePack staged asset snapshot source', () => {
       id: 'mesh.pack.ts',
       guids: [ROOT],
       async build() {
-        return ok([{ guid: ROOT, asset: mesh(3), digest: 'sha256:mesh' }]);
+        return ok([{ guid: ROOT, sourceKey: 'mesh', asset: mesh(3), digest: 'sha256:mesh' }]);
       },
     };
     const first = await createScriptablePackStagedAssetSnapshotSource({

package/src/__tests__/source-package-publication-lod.integration.test.ts

@@ -0,0 +1,29 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { publishImportPublication } from '../source-package-publication.js';
+
+describe('LOD publication boundary', () => {
+  const roots: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+  });
+
+  it('publishes the complete root package through the shared host', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-lod-publication-'));
+    roots.push(root);
+    const guid = '019e3969-1d48-7c3b-ac24-6d68f457065f';
+    const result = await publishImportPublication({
+      root,
+      guid,
+      desiredKey: 'a'.repeat(64),
+      pack: { lods: [{ meshGuid: 'lod-1', screenCoverage: 0.5 }] },
+      previousCatalog: [],
+      nextCatalog: [],
+      publishedGuids: [guid, 'lod-1'],
+    });
+    expect(result.ok).toBe(true);
+  });
+});

package/src/__tests__/source-package-publication.integration.test.ts

@@ -1,6 +1,8 @@
-import { mkdtemp, rm } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { mkdtemp, readdir, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { DdcEntryStore } from '@forgeax/engine-ddc';
 import { afterEach, describe, expect, it } from 'vitest';
 import {
   commitImportPublication,
@@ -11,6 +13,40 @@ import {
 
 const GUID = '019e3969-1d48-7c3b-ac24-6d68f457065f';
 const KEY = 'a'.repeat(64);
+const ARTIFACT_PATH = `${GUID}/body.bin`;
+const ARTIFACT_BYTES = new Uint8Array([9, 8, 7]);
+const ARTIFACT_DIGEST = `sha256:${createHash('sha256').update(ARTIFACT_BYTES).digest('hex')}`;
+
+const validArtifact = {
+  path: ARTIFACT_PATH,
+  mediaType: 'application/octet-stream',
+  bytes: ARTIFACT_BYTES,
+};
+
+const validDescriptor = {
+  path: ARTIFACT_PATH,
+  mediaType: validArtifact.mediaType,
+  byteLength: ARTIFACT_BYTES.byteLength,
+  integrity: { algorithm: 'sha256' as const, digest: ARTIFACT_DIGEST },
+};
+
+function closurePack(
+  artifacts: Readonly<Record<string, unknown>> = { body: validDescriptor },
+): Record<string, unknown> {
+  return {
+    schemaVersion: '2.0.0',
+    kind: 'internal-text-package',
+    assets: [
+      {
+        guid: GUID,
+        kind: 'fixture',
+        payload: { value: 'same' },
+        refs: [],
+        artifacts,
+      },
+    ],
+  };
+}
 
 function input(root: string, desiredKey = KEY): ImportPublicationInput {
   return {
@@ -72,4 +108,134 @@ describe('source package publication concurrency', () => {
       error: { code: 'source-package-ddc-failed', detail: 'DDC lifecycle commit returned stale' },
     });
   });
+
+  it('persists concurrent equivalent transports without sharing a temporary path', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-source-publication-'));
+    roots.push(root);
+    const transport = {
+      path: join(root, 'runtime', `${GUID}.pack.json`),
+      body: JSON.stringify({ guid: GUID, value: 'concurrent' }),
+    };
+    const staged = await Promise.all(
+      Array.from({ length: 8 }, () => stageImportPublication({ ...input(root), transport })),
+    );
+    expect(staged.every((candidate) => candidate.ok)).toBe(true);
+    if (staged.some((candidate) => !candidate.ok)) return;
+
+    const results = await Promise.all(
+      staged.map((candidate) =>
+        candidate.ok ? commitImportPublication(candidate.candidate) : Promise.resolve(candidate),
+      ),
+    );
+    expect(results.every((result) => result.ok && result.transportPersisted)).toBe(true);
+    expect(await readFile(transport.path, 'utf8')).toBe(transport.body);
+    expect((await readdir(join(root, 'runtime'))).some((name) => name.includes('.tmp'))).toBe(
+      false,
+    );
+  });
+
+  it('publishes the complete transport artifact closure into the DDC entry', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-source-publication-'));
+    roots.push(root);
+    const pack = closurePack();
+    const publicationInput = {
+      ...input(root),
+      pack,
+      transport: {
+        path: join(root, 'runtime', `${GUID}.pack.json`),
+        body: JSON.stringify(pack),
+        artifacts: [validArtifact],
+      },
+    };
+
+    const staged = await stageImportPublication(publicationInput);
+    expect(staged.ok).toBe(true);
+    if (!staged.ok) return;
+    await expect(commitImportPublication(staged.candidate)).resolves.toMatchObject({ ok: true });
+
+    const entry = await new DdcEntryStore(root).read(KEY);
+    expect(entry?.artifacts[ARTIFACT_PATH]).toMatchObject({
+      mediaType: validArtifact.mediaType,
+      bytes: validArtifact.bytes,
+    });
+  });
+
+  it.each([
+    {
+      label: 'missing body',
+      pack: closurePack(),
+      artifacts: [],
+    },
+    {
+      label: 'media type mismatch',
+      pack: closurePack(),
+      artifacts: [{ ...validArtifact, mediaType: 'application/x-wrong' }],
+    },
+    {
+      label: 'byte length mismatch',
+      pack: closurePack(),
+      artifacts: [{ ...validArtifact, bytes: new Uint8Array([9, 8]) }],
+    },
+    {
+      label: 'sha256 mismatch',
+      pack: closurePack({
+        body: {
+          ...validDescriptor,
+          integrity: { algorithm: 'sha256' as const, digest: 'sha256:bad' },
+        },
+      }),
+      artifacts: [validArtifact],
+    },
+    {
+      label: 'duplicate transport path',
+      pack: closurePack(),
+      artifacts: [validArtifact, validArtifact],
+    },
+    {
+      label: 'duplicate descriptor path',
+      pack: closurePack({ body: validDescriptor, alias: { ...validDescriptor } }),
+      artifacts: [validArtifact],
+    },
+    {
+      label: 'unexpected transport body',
+      pack: closurePack(),
+      artifacts: [
+        validArtifact,
+        {
+          path: `${GUID}/extra.bin`,
+          mediaType: 'application/octet-stream',
+          bytes: new Uint8Array([1]),
+        },
+      ],
+    },
+    {
+      label: 'transport body mismatch',
+      pack: closurePack(),
+      body: JSON.stringify({ schemaVersion: '2.0.0', kind: 'internal-text-package', assets: [] }),
+      artifacts: [validArtifact],
+    },
+  ] as const)('rejects $label before advancing the DDC head', async ({ pack, artifacts, body }) => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-source-publication-'));
+    roots.push(root);
+    const publicationInput: ImportPublicationInput = {
+      ...input(root),
+      pack,
+      transport: {
+        path: join(root, 'runtime', `${GUID}.pack.json`),
+        body: body ?? JSON.stringify(pack),
+        artifacts,
+      },
+    };
+
+    const staged = await stageImportPublication(publicationInput);
+
+    expect(staged).toMatchObject({
+      ok: false,
+      error: {
+        code: 'source-package-publication-invalid',
+      },
+      head: { state: 'missing' },
+    });
+    expect(await new DdcEntryStore(root).listKeys()).toEqual([]);
+  });
 });

package/src/browser.ts

@@ -12,3 +12,8 @@ export {
 } from './import-runner.js';
 export { ImporterRegistry } from './importer-registry.js';
 export { packMeshBinV4 } from './mesh-bin.js';
+export {
+  deriveDefaultLodScreenCoverages,
+  reconcileMeshLodMeta,
+  validateMeshLodContract,
+} from './mesh-lod.js';