@forgeax/engine-pack 0.1.2

package/src/__tests__/cli.unit.test.ts

@@ -0,0 +1,448 @@
+// Consolidated by feat-20260609-test-pool-startup-reduction-merge-tiny-test-files
+// biome-ignore-all lint/complexity/noUselessLoneBlockStatements: scope isolation between merged source files
+//
+// Source files (N=4 — NOT 5, atlas-cli-region-mismatch.test.ts excluded: its
+// vi.mock('../atlas/shelf-pack.js') is hoisted to file-top and conflicts with
+// atlas-cli-happy-path.test.ts which needs the real shelf-pack):
+//   - packages/pack/src/__tests__/atlas-cli-empty-input.test.ts
+//   - packages/pack/src/__tests__/atlas-cli-happy-path.test.ts
+//   - packages/pack/src/__tests__/atlas-cli-size-exceeded.test.ts
+//   - packages/pack/src/__tests__/cli-asset.test.ts
+//
+// Paradigm: each block-scoped describe('<source-filename>.test.ts', ...) preserves
+// source as ancestorTitles[0]. Top-level imports merged + deduped.
+
+import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { runCliAsset } from '../cli-asset.js';
+
+interface CapturedIO {
+  stdout: string[];
+  stderr: string[];
+}
+
+function makeIO(): CapturedIO {
+  return { stdout: [], stderr: [] };
+}
+
+function ctxFor(io: CapturedIO) {
+  return {
+    stdoutWrite: (line: string): void => {
+      io.stdout.push(line);
+    },
+    stderrWrite: (line: string): void => {
+      io.stderr.push(line);
+    },
+  };
+}
+
+interface UpngEncode {
+  encode: (imgs: ArrayBuffer[], w: number, h: number, cnum: number) => ArrayBuffer;
+}
+
+async function loadUpng(): Promise<UpngEncode> {
+  const mod = (await import('upng-js')) as { default?: UpngEncode } & UpngEncode;
+  return (mod.default ?? mod) as UpngEncode;
+}
+
+async function writeSolidPng(
+  path: string,
+  width: number,
+  height: number,
+  rgba: [number, number, number, number],
+): Promise<void> {
+  const upng = await loadUpng();
+  const pixels = new Uint8Array(width * height * 4);
+  for (let i = 0; i < width * height; i++) {
+    pixels[i * 4 + 0] = rgba[0];
+    pixels[i * 4 + 1] = rgba[1];
+    pixels[i * 4 + 2] = rgba[2];
+    pixels[i * 4 + 3] = rgba[3];
+  }
+  const buf = upng.encode([pixels.buffer as ArrayBuffer], width, height, 0);
+  await writeFile(path, Buffer.from(buf));
+}
+
+{
+  // ─── from atlas-cli-empty-input.test.ts ───
+
+  describe('atlas-cli-empty-input.test.ts', () => {
+    let tmp: string;
+
+    beforeEach(async () => {
+      tmp = await mkdtemp(join(tmpdir(), 'atlas-cli-empty-'));
+    });
+
+    afterEach(async () => {
+      await rm(tmp, { recursive: true, force: true });
+    });
+
+    describe('atlas CLI empty-input fail-fast (T-27 / AC-10 a)', () => {
+      it('exits 1 with atlas-empty-input + receivedCount=0', async () => {
+        const io = makeIO();
+        const code = await runCliAsset(
+          [
+            'atlas',
+            '--input',
+            `${tmp}/nonexistent-*.png`,
+            '--name',
+            'walk',
+            '--output',
+            tmp,
+            '--max-atlas-size',
+            '4096',
+          ],
+          ctxFor(io),
+        );
+
+        expect(code).toBe(1);
+        expect(io.stderr.length).toBe(1);
+        const line = io.stderr[0] as string;
+        expect(line.includes('\n')).toBe(false);
+        const parsed = JSON.parse(line) as {
+          code: string;
+          expected: string;
+          hint: string;
+          detail?: { receivedCount?: number };
+        };
+        expect(parsed.code).toBe('atlas-empty-input');
+        expect(typeof parsed.expected).toBe('string');
+        expect(parsed.expected.length).toBeGreaterThan(0);
+        expect(typeof parsed.hint).toBe('string');
+        expect(parsed.hint.length).toBeGreaterThan(0);
+        expect(parsed.detail?.receivedCount).toBe(0);
+      });
+    });
+  });
+}
+
+{
+  // ─── from atlas-cli-happy-path.test.ts ───
+
+  describe('atlas-cli-happy-path.test.ts', () => {
+    let tmp: string;
+
+    beforeEach(async () => {
+      tmp = await mkdtemp(join(tmpdir(), 'atlas-cli-happy-'));
+    });
+
+    afterEach(async () => {
+      await rm(tmp, { recursive: true, force: true });
+    });
+
+    describe('atlas CLI happy path (T-26 / AC-06)', () => {
+      it('packs 3 PNGs into <name>.atlas.png + <name>.atlas.meta.json', async () => {
+        await writeSolidPng(join(tmp, 'walk-0.png'), 64, 64, [255, 0, 0, 255]);
+        await writeSolidPng(join(tmp, 'walk-1.png'), 64, 64, [0, 255, 0, 255]);
+        await writeSolidPng(join(tmp, 'walk-2.png'), 64, 64, [0, 0, 255, 255]);
+
+        const io = makeIO();
+        const code = await runCliAsset(
+          [
+            'atlas',
+            '--input',
+            `${tmp}/*.png`,
+            '--name',
+            'walk',
+            '--output',
+            tmp,
+            '--max-atlas-size',
+            '4096',
+          ],
+          ctxFor(io),
+        );
+
+        expect(code).toBe(0);
+        expect(io.stderr).toEqual([]);
+
+        const atlasBytes = await readFile(join(tmp, 'walk.atlas.png'));
+        expect(atlasBytes.length).toBeGreaterThan(0);
+        expect(atlasBytes[0]).toBe(0x89);
+        expect(atlasBytes[1]).toBe(0x50);
+        expect(atlasBytes[2]).toBe(0x4e);
+        expect(atlasBytes[3]).toBe(0x47);
+
+        const metaText = await readFile(join(tmp, 'walk.atlas.meta.json'), 'utf-8');
+        const meta = JSON.parse(metaText) as {
+          name: string;
+          atlasWidth: number;
+          atlasHeight: number;
+          regions: Array<{ name: string; uMin: number; vMin: number; uW: number; vH: number }>;
+        };
+        expect(meta.name).toBe('walk');
+        expect(meta.atlasWidth).toBeGreaterThan(0);
+        expect(meta.atlasHeight).toBeGreaterThan(0);
+        expect(meta.atlasWidth).toBeLessThanOrEqual(4096);
+        expect(meta.atlasHeight).toBeLessThanOrEqual(4096);
+        expect(meta.regions).toHaveLength(3);
+        const regionNames = meta.regions.map((r) => r.name).sort();
+        expect(regionNames).toEqual(['walk-0', 'walk-1', 'walk-2']);
+        for (const r of meta.regions) {
+          expect(r.uMin).toBeGreaterThanOrEqual(0);
+          expect(r.uMin).toBeLessThanOrEqual(1);
+          expect(r.vMin).toBeGreaterThanOrEqual(0);
+          expect(r.vMin).toBeLessThanOrEqual(1);
+          expect(r.uW).toBeGreaterThan(0);
+          expect(r.uW).toBeLessThanOrEqual(1);
+          expect(r.vH).toBeGreaterThan(0);
+          expect(r.vH).toBeLessThanOrEqual(1);
+          expect(r.uMin + r.uW).toBeLessThanOrEqual(1 + 1e-9);
+          expect(r.vMin + r.vH).toBeLessThanOrEqual(1 + 1e-9);
+        }
+      });
+    });
+  });
+}
+
+{
+  // ─── from atlas-cli-size-exceeded.test.ts ───
+
+  describe('atlas-cli-size-exceeded.test.ts', () => {
+    let tmp: string;
+
+    beforeEach(async () => {
+      tmp = await mkdtemp(join(tmpdir(), 'atlas-cli-size-'));
+    });
+
+    afterEach(async () => {
+      await rm(tmp, { recursive: true, force: true });
+    });
+
+    describe('atlas CLI size-exceeded fail-fast (T-28 / AC-10 b)', () => {
+      it('exits 1 with atlas-size-exceeded + detail name/width/height/maxAtlasSize', async () => {
+        await writeSolidPng(join(tmp, 'giant.png'), 256, 256, [255, 200, 100, 255]);
+
+        const io = makeIO();
+        const code = await runCliAsset(
+          [
+            'atlas',
+            '--input',
+            `${tmp}/*.png`,
+            '--name',
+            'walk',
+            '--output',
+            tmp,
+            '--max-atlas-size',
+            '64',
+          ],
+          ctxFor(io),
+        );
+
+        expect(code).toBe(1);
+        expect(io.stderr.length).toBe(1);
+        const parsed = JSON.parse(io.stderr[0] as string) as {
+          code: string;
+          expected: string;
+          hint: string;
+          detail?: { name?: string; width?: number; height?: number; maxAtlasSize?: number };
+        };
+        expect(parsed.code).toBe('atlas-size-exceeded');
+        expect(typeof parsed.expected).toBe('string');
+        expect(parsed.expected.length).toBeGreaterThan(0);
+        expect(typeof parsed.hint).toBe('string');
+        expect(parsed.hint.length).toBeGreaterThan(0);
+        expect(parsed.detail?.name).toBe('giant');
+        expect(parsed.detail?.width).toBe(256);
+        expect(parsed.detail?.height).toBe(256);
+        expect(parsed.detail?.maxAtlasSize).toBe(64);
+      });
+    });
+  });
+}
+
+{
+  // ─── from cli-asset.test.ts ───
+
+  describe('cli-asset.test.ts', () => {
+    let tempDir: string;
+
+    beforeEach(async () => {
+      tempDir = await mkdtemp(join(tmpdir(), 'pack-cli-asset-'));
+    });
+
+    afterEach(async () => {
+      await rm(tempDir, { recursive: true, force: true });
+    });
+
+    describe('cli-asset (forgeax-engine-remote-asset plugin bin)', () => {
+      describe('subcommand routing (a)', () => {
+        it('routes scan as a known subcommand and returns 0 on empty roots', async () => {
+          const io = makeIO();
+          const code = await runCliAsset(['scan', '--roots', tempDir], ctxFor(io));
+          expect(code).toBe(0);
+          expect(io.stdout.length).toBeGreaterThanOrEqual(1);
+          expect(io.stdout[0]).toBe('[]');
+        });
+
+        it('routes verify as a known subcommand on a clean dir (exit 0)', async () => {
+          const io = makeIO();
+          const code = await runCliAsset(['verify'], { ...ctxFor(io), cwd: tempDir });
+          expect(code).toBe(0);
+        });
+
+        it('routes lookup and rejects malformed GUID with exit 1', async () => {
+          const io = makeIO();
+          const code = await runCliAsset(['lookup', 'not-a-uuid'], { ...ctxFor(io), cwd: tempDir });
+          expect(code).toBe(1);
+          expect(io.stderr.length).toBeGreaterThanOrEqual(1);
+          const parsed = JSON.parse(io.stderr[0] as string);
+          expect(parsed.code).toBe('pack-guid-malformed');
+        });
+
+        it('emits a JSON Lines envelope with code on unknown subcommand and exits 1', async () => {
+          const io = makeIO();
+          const code = await runCliAsset(['totally-not-a-subcommand'], ctxFor(io));
+          expect(code).toBe(1);
+          expect(io.stderr.length).toBe(1);
+          const parsed = JSON.parse(io.stderr[0] as string);
+          expect(typeof parsed.code).toBe('string');
+          expect(typeof parsed.expected).toBe('string');
+          expect(typeof parsed.hint).toBe('string');
+        });
+
+        it('prints help on --help and exits 0', async () => {
+          const io = makeIO();
+          const code = await runCliAsset(['--help'], ctxFor(io));
+          expect(code).toBe(0);
+          const help = io.stdout.join('\n');
+          expect(help).toContain('scan');
+          expect(help).toContain('lookup');
+          expect(help).toContain('verify');
+        });
+      });
+
+      describe('PackError stderr JSON Lines (b)', () => {
+        it('emits code / expected / hint as a single JSON line on pack-orphan-meta', async () => {
+          const orphanDir = join(tempDir, 'orphan');
+          await mkdir(orphanDir, { recursive: true });
+          await writeFile(
+            join(orphanDir, 'foo.png.meta.json'),
+            JSON.stringify({
+              schemaVersion: '1.0.0',
+              kind: 'external-asset-package',
+              importer: 'image',
+              source: 'foo.png',
+              importSettings: {},
+              subAssets: [
+                { guid: '01234567-89ab-7def-8123-456789abcdef', sourceIndex: 0, kind: 'texture' },
+              ],
+            }),
+            'utf-8',
+          );
+          const io = makeIO();
+          const code = await runCliAsset(['scan', '--roots', orphanDir], ctxFor(io));
+          expect(code).toBe(1);
+          expect(io.stderr.length).toBe(1);
+          const line = io.stderr[0] as string;
+          expect(line.includes('\n')).toBe(false);
+          const parsed = JSON.parse(line);
+          expect(typeof parsed.code).toBe('string');
+          expect(parsed.code).toMatch(/^pack-/);
+          expect(typeof parsed.hint).toBe('string');
+        });
+
+        it('emits pack-guid-malformed via lookup with code/expected/hint', async () => {
+          const io = makeIO();
+          const code = await runCliAsset(['lookup', 'oops'], { ...ctxFor(io), cwd: tempDir });
+          expect(code).toBe(1);
+          const parsed = JSON.parse(io.stderr[0] as string);
+          expect(parsed.code).toBe('pack-guid-malformed');
+          expect(typeof parsed.expected).toBe('string');
+          expect(typeof parsed.hint).toBe('string');
+        });
+      });
+
+      describe('image sidecar enumeration (T-2.B1)', () => {
+        const IMAGE_GUID = '019e2cc6-0c86-79da-aa76-b0984c86d45c';
+
+        it('scan enumerates *.meta.json subAssets', async () => {
+          const sidecarDir = join(tempDir, 'wood');
+          await mkdir(sidecarDir, { recursive: true });
+          await writeFile(join(sidecarDir, 'wood-container.jpg'), 'placeholder', 'utf-8');
+          await writeFile(
+            join(sidecarDir, 'wood-container.jpg.meta.json'),
+            JSON.stringify({
+              schemaVersion: '1.0.0',
+              kind: 'external-asset-package',
+              importer: 'image',
+              source: 'wood-container.jpg',
+              importSettings: {
+                colorSpace: 'srgb',
+                mipmap: 'auto',
+                addressMode: 'repeat',
+                filterMode: 'linear',
+              },
+              subAssets: [{ guid: IMAGE_GUID, sourceIndex: 0, kind: 'texture' }],
+            }),
+            'utf-8',
+          );
+          const io = makeIO();
+          const code = await runCliAsset(['scan', '--roots', sidecarDir], ctxFor(io));
+          expect(code).toBe(0);
+          const parsed = JSON.parse(io.stdout[0] as string);
+          expect(parsed).toHaveLength(1);
+          expect(parsed[0].guid).toBe(IMAGE_GUID);
+          expect(parsed[0].kind).toBe('texture');
+          expect(parsed[0].sourcePath).toContain('wood-container.jpg.meta.json');
+        });
+
+        it('lookup hits image GUID surfaced by *.meta.json', async () => {
+          const sidecarDir = join(tempDir, 'wood');
+          await mkdir(sidecarDir, { recursive: true });
+          await writeFile(join(sidecarDir, 'wood-container.jpg'), 'placeholder', 'utf-8');
+          await writeFile(
+            join(sidecarDir, 'wood-container.jpg.meta.json'),
+            JSON.stringify({
+              schemaVersion: '1.0.0',
+              kind: 'external-asset-package',
+              importer: 'image',
+              source: 'wood-container.jpg',
+              importSettings: {
+                colorSpace: 'srgb',
+                mipmap: 'auto',
+                addressMode: 'repeat',
+                filterMode: 'linear',
+              },
+              subAssets: [{ guid: IMAGE_GUID, sourceIndex: 0, kind: 'texture' }],
+            }),
+            'utf-8',
+          );
+          const io = makeIO();
+          const code = await runCliAsset(['lookup', IMAGE_GUID], {
+            ...ctxFor(io),
+            cwd: sidecarDir,
+          });
+          expect(code).toBe(0);
+          const parsed = JSON.parse(io.stdout[0] as string);
+          expect(parsed.guid).toBe(IMAGE_GUID);
+          expect(parsed.kind).toBe('texture');
+        });
+      });
+
+      describe('exit codes (c)', () => {
+        it('verify ok -> 0', async () => {
+          const io = makeIO();
+          const code = await runCliAsset(['verify'], { ...ctxFor(io), cwd: tempDir });
+          expect(code).toBe(0);
+        });
+
+        it('verify err -> 1', async () => {
+          const subDir = join(tempDir, 'bad');
+          await mkdir(subDir, { recursive: true });
+          await writeFile(
+            join(subDir, 'broken.pack.json'),
+            '{"this is not": "schema-valid"}',
+            'utf-8',
+          );
+          const io = makeIO();
+          const code = await runCliAsset(['verify'], { ...ctxFor(io), cwd: subDir });
+          expect(code).toBe(1);
+        });
+      });
+    });
+  });
+
+  void chmod;
+}

package/src/__tests__/evidence-source-inventory.unit.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import {
+  type ProducerSemanticIdentityInput,
+  producerRelativeDdcKey,
+  producerRelativeLogicalPath,
+} from '../evidence/source-inventory.js';
+
+describe('source inventory DDC cold path contract', () => {
+  const input: ProducerSemanticIdentityInput = {
+    producerRoot: '/tmp/game',
+    sourcePath: '/tmp/game/assets/tree.pack.ts',
+    sourceDigest: 'sha256:tree',
+    schemaVersion: '1.0.0',
+    importer: 'scriptable-pack-importer@2',
+    codec: 'pack-v2',
+    settings: { profile: 'default' },
+    producer: 'scriptable-pack@4',
+    profile: 'webgpu/v1',
+    declaredGuids: ['tree-guid'],
+  };
+
+  it('rejects a source outside the injected producer root instead of guessing a basename', () => {
+    expect(() => producerRelativeLogicalPath('/tmp/game', '/tmp/other/tree.pack.ts')).toThrow();
+  });
+
+  it('keeps the correctness key independent from cache availability', () => {
+    const key = producerRelativeDdcKey(input);
+    expect(key).toMatch(/^[a-f0-9]{64}$/);
+    expect(
+      producerRelativeDdcKey({
+        ...input,
+        producerRoot: '/tmp/another-game',
+        sourcePath: '/tmp/another-game/assets/tree.pack.ts',
+      }),
+    ).toBe(key);
+  });
+});

package/src/__tests__/guid-collision.unit.test.ts

@@ -0,0 +1,112 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { scan } from '../scanner.js';
+
+const COLLIDING_GUID = '018e7a4d-1234-7abc-8def-000000000001';
+const roots: string[] = [];
+
+const pack = (guid: string) => ({
+  schemaVersion: '1.0.0',
+  kind: 'internal-text-package',
+  assets: [{ guid, kind: 'mesh', payload: {}, refs: [] }],
+});
+
+const meta = (guid: string, source: string) => ({
+  schemaVersion: '1.0.0',
+  kind: 'external-asset-package',
+  importer: 'image',
+  source,
+  importSettings: {},
+  subAssets: [{ guid, sourceIndex: 0, kind: 'texture', sourceKey: 'image/main' }],
+});
+
+async function makeRoot(name: string): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), `forgeax-guid-${name}-`));
+  roots.push(root);
+  return root;
+}
+
+async function expectGuidCollision(
+  rootList: readonly string[],
+  expectedNames: readonly string[],
+): Promise<void> {
+  const result = await scan(rootList);
+  expect(result.ok).toBe(false);
+  if (result.ok) return;
+
+  expect(result.error.code).toBe('pack-guid-collision');
+  if (result.error.code !== 'pack-guid-collision') return;
+
+  expect(result.error.expected).toContain('pack error');
+  expect(result.error.hint.length).toBeGreaterThan(0);
+  const detail = result.error.detail;
+  if (!('guid' in detail) || !('paths' in detail)) return;
+
+  expect(detail.guid).toBe(COLLIDING_GUID);
+  expect(detail.paths).toHaveLength(2);
+  for (const name of expectedNames) {
+    expect(detail.paths.some((path) => path.endsWith(name))).toBe(true);
+  }
+}
+
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe('normalized GUID collision collection', () => {
+  it('reports a pack asset and meta subAsset collision in one root', async () => {
+    const root = await makeRoot('pack-meta');
+    await writeFile(join(root, 'asset.pack.json'), JSON.stringify(pack(COLLIDING_GUID)));
+    await writeFile(join(root, 'image.png'), Buffer.from('fixture'));
+    await writeFile(
+      join(root, 'image.png.meta.json'),
+      JSON.stringify(meta(COLLIDING_GUID, 'image.png')),
+    );
+
+    await expectGuidCollision([root], ['asset.pack.json', 'image.png.meta.json']);
+  });
+
+  it('reports meta subAsset collisions across independent roots', async () => {
+    const firstRoot = await makeRoot('cross-a');
+    const secondRoot = await makeRoot('cross-b');
+    await writeFile(join(firstRoot, 'hero.png'), Buffer.from('first'));
+    await writeFile(join(secondRoot, 'hero.png'), Buffer.from('second'));
+    await writeFile(
+      join(firstRoot, 'hero.png.meta.json'),
+      JSON.stringify(meta(COLLIDING_GUID, 'hero.png')),
+    );
+    await writeFile(
+      join(secondRoot, 'hero.png.meta.json'),
+      JSON.stringify(meta(COLLIDING_GUID, 'hero.png')),
+    );
+
+    await expectGuidCollision([firstRoot, secondRoot], ['hero.png.meta.json']);
+  });
+
+  it('reports a ScriptablePack output colliding with a JSON sidecar', async () => {
+    const root = await makeRoot('scriptable-meta');
+    await writeFile(join(root, 'image.png'), Buffer.from('fixture'));
+    await writeFile(
+      join(root, 'image.png.meta.json'),
+      JSON.stringify(meta(COLLIDING_GUID, 'image.png')),
+    );
+    await writeFile(
+      join(root, 'generated.pack.ts'),
+      `
+const guid = (value: string) => new Uint8Array(value.replaceAll('-', '').match(/../g)!.map((byte: string) => Number.parseInt(byte, 16)));
+export default {
+  schemaVersion: '1.0.0',
+  packageId: guid('018e7a4d-1234-7abc-8def-000000000002'),
+  assets: { mesh: { guid: guid('${COLLIDING_GUID}'), kind: 'mesh' } },
+  externalAssets: {},
+  build: () => ({ ok: true, value: { mesh: { kind: 'mesh' } } }),
+};
+`,
+    );
+
+    await expectGuidCollision([root], ['image.png.meta.json', 'generated.pack.ts']);
+  });
+});

package/src/__tests__/guid-validator-surface.unit.test.ts

@@ -0,0 +1,20 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { isValidAssetGuidString } from '../guid';
+
+const ownerSource = readFileSync(new URL('../guid.ts', import.meta.url), 'utf8');
+const scannerSource = readFileSync(new URL('../scanner.ts', import.meta.url), 'utf8');
+const cliSource = readFileSync(new URL('../cli-asset.ts', import.meta.url), 'utf8');
+
+describe('asset GUID validator owner', () => {
+  it('keeps scanner and CLI validation on the GUID owner', () => {
+    expect(isValidAssetGuidString('019e3969-1d48-7c3b-ac24-6d68f457065f')).toBe(true);
+    expect(isValidAssetGuidString('not-a-guid')).toBe(false);
+    expect(isValidAssetGuidString(undefined)).toBe(false);
+    expect(ownerSource.match(/const UUID_RE = \/\^\[0-9a-f\]/g)).toHaveLength(1);
+    expect(scannerSource).not.toMatch(/const UUID_RE =/);
+    expect(cliSource).not.toMatch(/const UUID_RE =/);
+    expect(scannerSource.match(/isValidAssetGuidString/g)).toHaveLength(4);
+    expect(cliSource.match(/isValidAssetGuidString/g)).toHaveLength(3);
+  });
+});