@forgeax/engine-pack 0.1.24 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-pack",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -131,7 +131,7 @@
     }
   },
   "dependencies": {
-    "@forgeax/engine-types": "0.1.24",
+    "@forgeax/engine-types": "0.1.25",
     "@noble/hashes": "^2.2.0",
     "fast-glob": "^3.3.3",
     "typescript": "^5.8.3",

package/src/__tests__/material-declaration-boundary.unit.test.ts

@@ -0,0 +1,35 @@
+import { readFile } from 'node:fs/promises';
+import { dirname, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+
+const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../');
+const CONFIG_PATH = resolve(REPO_ROOT, 'packages/pack/tsconfig.json');
+
+async function declarationProjectInputs(): Promise<readonly string[]> {
+  const source = await readFile(CONFIG_PATH, 'utf8');
+  const parsed = ts.parseJsonConfigFileContent(
+    JSON.parse(source),
+    ts.sys,
+    dirname(CONFIG_PATH),
+    undefined,
+    CONFIG_PATH,
+  );
+  return parsed.fileNames.map((fileName) => relative(REPO_ROOT, fileName));
+}
+
+describe('Pack declaration project boundary', () => {
+  it('keeps tests and emitted declarations out of production inputs', async () => {
+    const inputs = await declarationProjectInputs();
+    const config = JSON.parse(await readFile(CONFIG_PATH, 'utf8')) as {
+      readonly exclude?: readonly string[];
+    };
+
+    expect(config.exclude).toEqual(expect.arrayContaining(['src/**/__tests__/**', 'dist/**']));
+    expect(inputs.some((fileName) => fileName.startsWith('packages/pack/src/__tests__/'))).toBe(
+      false,
+    );
+    expect(inputs.some((fileName) => fileName.startsWith('packages/pack/dist/'))).toBe(false);
+  });
+});

package/src/__tests__/material-surface-consumer-census.test.ts

@@ -0,0 +1,24 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const packageRoots = ['packages/pack/src', 'packages/vite-plugin-pack/src', 'packages/render/src'];
+
+describe('Surface consumer census', () => {
+  it('keeps the runtime and Pack consumers on the existing MaterialAsset wire', async () => {
+    const sources = await Promise.all(
+      packageRoots.map(async (root) => {
+        const path = resolve(process.cwd(), root, 'index.ts');
+        try {
+          return await readFile(path, 'utf8');
+        } catch {
+          return '';
+        }
+      }),
+    );
+    const source = sources.join('\n');
+    expect(source).not.toContain('SurfaceAsset');
+    expect(source).not.toContain('surfaceModule');
+    expect(source).not.toContain('shadingModel');
+  });
+});

package/src/__tests__/material-surface-publication.unit.test.ts

@@ -0,0 +1,159 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { Materials } from '@forgeax/engine-render';
+import { describe, expect, it } from 'vitest';
+import { NativeCookerRegistry } from '../native-cooker-registry.js';
+
+const compilerModule = pathToFileURL(
+  resolve(
+    dirname(fileURLToPath(import.meta.url)),
+    '../../../../packages/shader-compiler/dist/index.mjs',
+  ),
+).href;
+
+const GUID = '11111111-1111-4111-8111-111111111111';
+const ROOT_GUID = '22222222-2222-4222-8222-222222222222';
+const CHILD_GUID = '33333333-3333-4333-8333-333333333333';
+const SURFACE = `#define_import_path game_3d::rusted_iron_surface
+#import forgeax_material::surface_v1::{SurfaceData, SurfaceInput}
+fn evaluate_surface(input: SurfaceInput) -> SurfaceData {
+  return SurfaceData(vec3<f32>(0.4, 0.45, 0.47), input.geometricNormalWS, 0.0, 0.5, vec3<f32>(0.0), 1.0, 1.0, 0.0);
+}`;
+
+describe('Surface Pack publication', () => {
+  it('publishes one complete cooked record with source closure and artifact', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-surface-publication-'));
+    try {
+      const sourcePath = join(root, 'rusted-iron-surface.wgsl');
+      await writeFile(sourcePath, SURFACE);
+      const material = Materials.standard({
+        surfaceModule: 'game_3d::rusted_iron_surface',
+        parameters: [],
+        values: {},
+      });
+      const { createMaterialPackCooker } = await import(compilerModule);
+      const draft = await createMaterialPackCooker([root]).cook({
+        guid: GUID,
+        source: material,
+        sourcePath,
+      });
+      const cooked = draft.payload.cooked as {
+        readonly receipt: { readonly sourceClosure: readonly string[] };
+        readonly artifact: { readonly path: string; readonly bytes: Uint8Array };
+      };
+      expect(cooked.receipt.sourceClosure).toContain(sourcePath);
+      expect(cooked.artifact.path).toContain(GUID);
+      const artifact = draft.artifacts[cooked.artifact.path];
+      expect(artifact?.bytes.byteLength).toBeGreaterThan(0);
+      expect(Object.keys(draft.artifacts)).toContain(cooked.artifact.path);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('keeps the accepted generation as last known good after cook failure', async () => {
+    const registry = new NativeCookerRegistry();
+    registry.register({
+      key: 'material',
+      cook: async (input: { readonly fail?: boolean }) => {
+        if (input.fail) throw new Error('surface compose failed');
+        return {
+          guid: GUID,
+          payload: { generation: 1 },
+          refs: [],
+          artifacts: {},
+          inputFingerprint: 'sha256:surface-input',
+        };
+      },
+    });
+    const first = await registry.runTransaction({ key: 'material', input: {} });
+    expect(first).toMatchObject({ ok: true, value: { generation: 1, status: 'committed' } });
+    if (!first.ok) return;
+    const failed = await registry.runTransaction({
+      key: 'material',
+      input: { fail: true },
+      previous: { draft: first.value.draft, generation: first.value.generation },
+    });
+    expect(failed).toMatchObject({
+      ok: true,
+      value: {
+        status: 'recovered',
+        lastKnownGood: { payload: { generation: 1 } },
+        lastKnownGoodGeneration: 1,
+      },
+    });
+  });
+
+  it('cold-cooks a child through the Pack-owned root table and publishes its parent ref', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-surface-root-child-'));
+    try {
+      const rootMaterial = Materials.standard({
+        baseColor: [1, 1, 1, 1],
+        metallic: 0,
+        roughness: 0.5,
+      });
+      const child = {
+        kind: 'material' as const,
+        parent: ROOT_GUID as never,
+        values: { baseColor: [0.4, 0.45, 0.47, 1] },
+      };
+      const { createMaterialPackCooker } = await import(compilerModule);
+      const draft = await createMaterialPackCooker([root]).cook({
+        guid: CHILD_GUID,
+        source: child,
+        table: { [ROOT_GUID]: rootMaterial, [CHILD_GUID]: child },
+      });
+      const cooked = draft.payload.cooked as {
+        readonly authored: { readonly parent?: string };
+        readonly resolved: {
+          readonly parameters: readonly { readonly name: string }[];
+          readonly values: Readonly<Record<string, unknown>>;
+        };
+        readonly refs: { readonly parent: readonly string[] };
+      };
+      expect(cooked.authored.parent).toBe(ROOT_GUID);
+      expect(cooked.refs.parent).toEqual([ROOT_GUID]);
+      expect(cooked.resolved.parameters.map((parameter) => parameter.name)).toContain('baseColor');
+      expect(cooked.resolved.values.baseColor).toEqual([0.4, 0.45, 0.47, 1]);
+      expect(draft.refs).toContain(ROOT_GUID);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('does not publish an artifact when a physical material requests Deferred', async () => {
+    const { createMaterialPackCooker } = await import(compilerModule);
+    const material = {
+      kind: 'material' as const,
+      passes: [
+        {
+          name: 'forward',
+          program: {
+            module: 'forgeax_material::standard',
+            moduleSlots: { surface: 'forgeax_material::default_standard_surface' },
+          },
+        },
+        {
+          name: 'deferred',
+          program: {
+            module: 'forgeax_material::standard',
+            moduleSlots: { surface: 'forgeax_material::default_standard_surface' },
+          },
+        },
+      ],
+      parameters: [
+        { name: 'clearcoat', type: 'f32' as const },
+        { name: 'clearcoatRoughness', type: 'f32' as const },
+      ],
+      values: { clearcoat: 0, clearcoatRoughness: 0.5 },
+    };
+    await expect(
+      createMaterialPackCooker().cook({
+        guid: GUID,
+        source: material,
+      }),
+    ).rejects.toThrow('material-physical-contract-invalid');
+  });
+});

package/src/__tests__/material-surface-wire.unit.test.ts

@@ -0,0 +1,30 @@
+import { Materials } from '@forgeax/engine-render';
+import { assertMaterialAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+
+const customOptions = {
+  surfaceModule: 'game_3d::rusted_iron_surface',
+  parameters: [{ name: 'ironColor', type: 'color' as const }],
+  values: { ironColor: [0.4, 0.45, 0.47, 1] },
+};
+
+describe('custom Surface MaterialAsset wire projection', () => {
+  it('uses Standard module and the existing Surface slot wire', () => {
+    const material = Materials.standard(customOptions as never);
+    expect(material.passes?.map((pass) => pass.program.module)).toEqual([
+      'forgeax_material::standard',
+      'forgeax_material::standard',
+      'forgeax_material::standard',
+    ]);
+    expect(
+      material.passes?.every(
+        (pass) => pass.program.moduleSlots?.surface === customOptions.surfaceModule,
+      ),
+    ).toBe(true);
+    const wire = JSON.parse(JSON.stringify(material)) as Record<string, unknown>;
+    assertMaterialAsset(wire);
+    expect(wire).not.toHaveProperty('surfaceModule');
+    expect(wire).not.toHaveProperty('shadingModel');
+    expect(wire).not.toHaveProperty('surface');
+  });
+});

package/src/build.ts

@@ -60,6 +60,8 @@ export {
   type MaterialCookReceipt,
   type MaterialCookRecordError,
   type MaterialCookRefs,
+  type MaterialCookVariant,
+  type MaterialCookVariantContext,
   projectCookedMaterialRecord,
   serializeCookedMaterialRecord,
   serializeMaterialCookReceipt,

package/src/evidence/material-cook.ts

@@ -25,6 +25,19 @@ export interface MaterialCookArtifact {
   readonly bytes: Uint8Array;
 }
 
+/** Backend capability projection for one immutable cooked material artifact. */
+export interface MaterialCookVariantContext {
+  readonly backend: 'webgpu' | 'webgl2' | 'wgpu-native';
+  readonly capability: 'storage-buffer' | 'uniform-fallback';
+}
+
+/** Additional backend artifact published with one material generation. */
+export interface MaterialCookVariant {
+  readonly context: MaterialCookVariantContext;
+  readonly specializationKey: string;
+  readonly artifact: MaterialCookArtifact;
+}
+
 export interface MaterialCookWasmProvenance {
   readonly sourceContentKey: string;
   readonly artifactSha256: string;
@@ -75,6 +88,10 @@ export interface CookedMaterialRecord {
   readonly materialGuid?: string;
   readonly publicationGeneration?: number;
   readonly specializationKey?: string;
+  /** Compiler context used by the primary `artifact` entry. */
+  readonly variantContext?: MaterialCookVariantContext;
+  /** Additional immutable artifacts for other backend capability lanes. */
+  readonly variants?: readonly MaterialCookVariant[];
   readonly artifactDigest?: string;
   readonly sourceClosure?: readonly string[];
   readonly parameterContract?: MaterialParameterContract;
@@ -110,6 +127,7 @@ const STANDARD_ROOT_MODULES = new Set([
   'forgeax::pbr-skin',
   'forgeax_material::standard',
   'forgeax_material::pbr-skin',
+  'forgeax::default-shadow-caster',
 ]);
 
 /** Shared ownership predicate for the built-in Standard material root. */
@@ -258,6 +276,17 @@ function invalid(field: string, actual?: unknown): Result<never, MaterialCookRec
   });
 }
 
+function normalizeArtifactBytes(value: unknown): Uint8Array | undefined {
+  if (Array.isArray(value)) {
+    return value.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)
+      ? Uint8Array.from(value)
+      : undefined;
+  }
+  if (!ArrayBuffer.isView(value)) return undefined;
+  const view = value as ArrayBufferView;
+  return new Uint8Array(view.buffer, view.byteOffset, view.byteLength).slice();
+}
+
 const IDENTITY_FIELDS = [
   'materialContractDigest',
   'sourceRevision',
@@ -390,6 +419,49 @@ export function validateCookedMaterialRecord(
     return invalid('publicationGeneration', candidate.publicationGeneration);
   if (candidate.specializationKey !== undefined && typeof candidate.specializationKey !== 'string')
     return invalid('specializationKey');
+  if (candidate.variantContext !== undefined) {
+    if (candidate.variantContext === null || typeof candidate.variantContext !== 'object')
+      return invalid('variantContext');
+    const context = candidate.variantContext as Record<string, unknown>;
+    if (
+      (context.backend !== 'webgpu' &&
+        context.backend !== 'webgl2' &&
+        context.backend !== 'wgpu-native') ||
+      (context.capability !== 'storage-buffer' && context.capability !== 'uniform-fallback')
+    )
+      return invalid('variantContext', candidate.variantContext);
+  }
+  if (candidate.variants !== undefined) {
+    if (!Array.isArray(candidate.variants)) return invalid('variants');
+    for (const [index, value] of candidate.variants.entries()) {
+      if (value === null || typeof value !== 'object') return invalid(`variants[${index}]`);
+      const variant = value as Record<string, unknown>;
+      const context = variant.context;
+      if (context === null || typeof context !== 'object')
+        return invalid(`variants[${index}].context`);
+      const contextRecord = context as Record<string, unknown>;
+      if (
+        (contextRecord.backend !== 'webgpu' &&
+          contextRecord.backend !== 'webgl2' &&
+          contextRecord.backend !== 'wgpu-native') ||
+        (contextRecord.capability !== 'storage-buffer' &&
+          contextRecord.capability !== 'uniform-fallback')
+      )
+        return invalid(`variants[${index}].context`, context);
+      if (typeof variant.specializationKey !== 'string' || variant.specializationKey.length === 0)
+        return invalid(`variants[${index}].specializationKey`);
+      if (variant.artifact === null || typeof variant.artifact !== 'object')
+        return invalid(`variants[${index}].artifact`);
+      const variantArtifact = variant.artifact as Record<string, unknown>;
+      if (
+        typeof variantArtifact.mediaType !== 'string' ||
+        typeof variantArtifact.path !== 'string' ||
+        typeof variantArtifact.digest !== 'string' ||
+        normalizeArtifactBytes(variantArtifact.bytes) === undefined
+      )
+        return invalid(`variants[${index}].artifact`);
+    }
+  }
   if (candidate.artifactDigest !== undefined && typeof candidate.artifactDigest !== 'string')
     return invalid('artifactDigest');
   if (
@@ -467,12 +539,25 @@ export function validateCookedMaterialRecord(
     ...candidate,
     artifact: {
       ...artifact,
-      bytes: ArrayBuffer.isView(artifact.bytes)
-        ? Uint8Array.from(artifact.bytes as Uint8Array)
-        : Uint8Array.from(artifact.bytes as number[]),
+      bytes: normalizeArtifactBytes(artifact.bytes) as Uint8Array,
     },
+    ...(Array.isArray(candidate.variants)
+      ? {
+          variants: candidate.variants.map((value) => {
+            const variant = value as Record<string, unknown>;
+            const variantArtifact = variant.artifact as Record<string, unknown>;
+            return {
+              ...variant,
+              artifact: {
+                ...variantArtifact,
+                bytes: normalizeArtifactBytes(variantArtifact.bytes) as Uint8Array,
+              },
+            };
+          }),
+        }
+      : {}),
     receipt: receiptResult.value,
-  } as CookedMaterialRecord;
+  } as unknown as CookedMaterialRecord;
   return ok(normalized);
 }
 
@@ -483,6 +568,8 @@ export function projectCookedMaterialRecord(
     resolved: record.resolved,
     refs: record.refs,
     artifact: record.artifact,
+    ...(record.variantContext === undefined ? {} : { variantContext: record.variantContext }),
+    ...(record.variants === undefined ? {} : { variants: record.variants }),
     receipt: record.receipt,
     schemaVersion: record.schemaVersion,
   };

package/src/index.ts

@@ -16,6 +16,8 @@ export {
   type MaterialCookReceipt,
   type MaterialCookRecordError,
   type MaterialCookRefs,
+  type MaterialCookVariant,
+  type MaterialCookVariantContext,
   type MaterialCookWasmProvenance,
   materialLayerPlanIdentity,
   projectCookedMaterialRecord,

package/src/material-cook.ts

@@ -7,6 +7,8 @@ export {
   type MaterialCookReceipt,
   type MaterialCookRecordError,
   type MaterialCookRefs,
+  type MaterialCookVariant,
+  type MaterialCookVariantContext,
   type MaterialCookWasmProvenance,
   materialLayerPlanIdentity,
   projectCookedMaterialRecord,

package/src/scanner.ts

@@ -62,9 +62,13 @@ export interface ScriptablePackScanOptions {
 }
 
 /** Stable default policy shared by inventory and production owners. */
-export const STANDARD_SCRIPTABLE_PACK_SCAN_OPTIONS = Object.freeze(
-  {},
-) satisfies ScriptablePackScanOptions;
+export const STANDARD_SCRIPTABLE_PACK_SCAN_OPTIONS = Object.freeze({
+  // Scriptable Packs execute in an isolated worker.  A cold worker must
+  // compile the authored source closure before it can return metadata;
+  // heavy procedural packs otherwise make the shared catalog fall back to
+  // an empty degraded projection at the old 15-second budget.
+  timeoutMs: 60_000,
+}) satisfies ScriptablePackScanOptions;
 
 export interface InventoryDeclaration {
   readonly guid: string;

package/src/schema/material-cook.schema.json

@@ -9,6 +9,49 @@
     "materialGuid": { "type": "string", "minLength": 1 },
     "publicationGeneration": { "type": "integer", "minimum": 1 },
     "specializationKey": { "type": "string", "minLength": 1 },
+    "variantContext": {
+      "type": "object",
+      "required": ["backend", "capability"],
+      "properties": {
+        "backend": { "enum": ["webgpu", "webgl2", "wgpu-native"] },
+        "capability": { "enum": ["storage-buffer", "uniform-fallback"] }
+      },
+      "additionalProperties": false
+    },
+    "variants": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["context", "specializationKey", "artifact"],
+        "properties": {
+          "context": {
+            "type": "object",
+            "required": ["backend", "capability"],
+            "properties": {
+              "backend": { "enum": ["webgpu", "webgl2", "wgpu-native"] },
+              "capability": { "enum": ["storage-buffer", "uniform-fallback"] }
+            },
+            "additionalProperties": false
+          },
+          "specializationKey": { "type": "string", "minLength": 1 },
+          "artifact": {
+            "type": "object",
+            "required": ["mediaType", "path", "digest", "bytes"],
+            "properties": {
+              "mediaType": { "type": "string" },
+              "path": { "type": "string" },
+              "digest": { "type": "string", "pattern": "^sha256:" },
+              "bytes": {
+                "type": "array",
+                "items": { "type": "integer", "minimum": 0, "maximum": 255 }
+              }
+            },
+            "additionalProperties": false
+          }
+        },
+        "additionalProperties": false
+      }
+    },
     "artifactDigest": { "type": "string", "pattern": "^sha256:" },
     "sourceClosure": { "type": "array", "items": { "type": "string" } },
     "parameterContract": {

package/dist/__tests__/ai-recovery.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ai-recovery.unit.test.d.ts.map

package/dist/__tests__/ai-recovery.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai-recovery.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/ai-recovery.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/artifact-path.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=artifact-path.test.d.ts.map

package/dist/__tests__/artifact-path.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"artifact-path.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/artifact-path.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/asset-evidence-error-hints.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=asset-evidence-error-hints.test.d.ts.map

package/dist/__tests__/asset-evidence-error-hints.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-evidence-error-hints.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-evidence-error-hints.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/asset-evidence-lifecycle.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=asset-evidence-lifecycle.test.d.ts.map

package/dist/__tests__/asset-evidence-lifecycle.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-evidence-lifecycle.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-evidence-lifecycle.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/asset-evidence-schema.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=asset-evidence-schema.test.d.ts.map

package/dist/__tests__/asset-evidence-schema.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-evidence-schema.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-evidence-schema.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/atlas-cli-region-mismatch.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=atlas-cli-region-mismatch.test.d.ts.map

package/dist/__tests__/atlas-cli-region-mismatch.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atlas-cli-region-mismatch.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/atlas-cli-region-mismatch.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/atlas-error-code-owner.test-d.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=atlas-error-code-owner.test-d.d.ts.map

package/dist/__tests__/atlas-error-code-owner.test-d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atlas-error-code-owner.test-d.d.ts","sourceRoot":"","sources":["../../src/__tests__/atlas-error-code-owner.test-d.ts"],"names":[],"mappings":""}

package/dist/__tests__/cli-asset-evidence.integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cli-asset-evidence.integration.test.d.ts.map

package/dist/__tests__/cli-asset-evidence.integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-asset-evidence.integration.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/cli-asset-evidence.integration.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/cli.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cli.unit.test.d.ts.map

package/dist/__tests__/cli.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/cli.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/evidence-source-inventory.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=evidence-source-inventory.unit.test.d.ts.map

package/dist/__tests__/evidence-source-inventory.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"evidence-source-inventory.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/evidence-source-inventory.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/guid-collision.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=guid-collision.unit.test.d.ts.map

package/dist/__tests__/guid-collision.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"guid-collision.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/guid-collision.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/guid-validator-surface.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=guid-validator-surface.unit.test.d.ts.map

package/dist/__tests__/guid-validator-surface.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"guid-validator-surface.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/guid-validator-surface.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/inventory-schema.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=inventory-schema.test.d.ts.map

package/dist/__tests__/inventory-schema.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inventory-schema.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/inventory-schema.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/material-cook-dependencies.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=material-cook-dependencies.unit.test.d.ts.map

package/dist/__tests__/material-cook-dependencies.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"material-cook-dependencies.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/material-cook-dependencies.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/material-cook-receipt-layer-plan.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=material-cook-receipt-layer-plan.unit.test.d.ts.map

package/dist/__tests__/material-cook-receipt-layer-plan.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"material-cook-receipt-layer-plan.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/material-cook-receipt-layer-plan.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/material-cook-receipt.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=material-cook-receipt.unit.test.d.ts.map

package/dist/__tests__/material-cook-receipt.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"material-cook-receipt.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/material-cook-receipt.unit.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/material-cook-schema.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=material-cook-schema.unit.test.d.ts.map

package/dist/__tests__/material-cook-schema.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"material-cook-schema.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/material-cook-schema.unit.test.ts"],"names":[],"mappings":""}