@celilo/e2e 0.20.0 → 0.20.2

package/registry-server/src/storage.test.ts

@@ -1,152 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { existsSync, mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import type { IndexEntry } from './storage';
-import { RegistryStorage } from './storage';
-
-let dataDir: string;
-let storage: RegistryStorage;
-
-beforeEach(() => {
-  dataDir = mkdtempSync(join(tmpdir(), 'celilo-registry-test-'));
-  storage = new RegistryStorage(dataDir);
-});
-
-afterEach(() => {
-  rmSync(dataDir, { recursive: true, force: true });
-});
-
-// ── indexPath ─────────────────────────────────────────────────────────────────
-
-describe('RegistryStorage.indexPath', () => {
-  test('1-char name → index/1/{name}', () => {
-    expect(storage.indexPath('a')).toBe(join(dataDir, 'index', '1', 'a'));
-  });
-
-  test('2-char name → index/2/{name}', () => {
-    expect(storage.indexPath('ab')).toBe(join(dataDir, 'index', '2', 'ab'));
-  });
-
-  test('3-char name → index/3/{first2}/{name}', () => {
-    expect(storage.indexPath('abc')).toBe(join(dataDir, 'index', '3', 'ab', 'abc'));
-  });
-
-  test('4-char name → index/{01}/{23}/{name}', () => {
-    expect(storage.indexPath('abcd')).toBe(join(dataDir, 'index', 'ab', 'cd', 'abcd'));
-  });
-
-  test('long name uses first 4 chars for directories', () => {
-    expect(storage.indexPath('homebridge')).toBe(join(dataDir, 'index', 'ho', 'me', 'homebridge'));
-  });
-
-  test('real module names produce expected paths', () => {
-    expect(storage.indexPath('caddy')).toBe(join(dataDir, 'index', 'ca', 'dd', 'caddy'));
-    expect(storage.indexPath('celilo-registry')).toBe(
-      join(dataDir, 'index', 'ce', 'li', 'celilo-registry'),
-    );
-  });
-});
-
-// ── readIndex / appendIndex ───────────────────────────────────────────────────
-
-describe('RegistryStorage index read/write', () => {
-  function entry(vers: string, yanked = false): IndexEntry {
-    return { name: 'homebridge', vers, deps: [], cksum: 'abc123', yanked };
-  }
-
-  test('readIndex returns empty array for unknown module', () => {
-    expect(storage.readIndex('nonexistent')).toEqual([]);
-  });
-
-  test('appendIndex then readIndex round-trips entries', () => {
-    storage.appendIndex(entry('1.0.0+1'));
-    storage.appendIndex(entry('1.0.0+2'));
-    const result = storage.readIndex('homebridge');
-    expect(result).toHaveLength(2);
-    expect(result[0].vers).toBe('1.0.0+1');
-    expect(result[1].vers).toBe('1.0.0+2');
-  });
-
-  test('updateIndex replaces all entries', () => {
-    storage.appendIndex(entry('1.0.0+1'));
-    storage.appendIndex(entry('1.0.0+2'));
-    storage.updateIndex('homebridge', [entry('1.0.0+2', true), entry('1.0.0+3')]);
-    const result = storage.readIndex('homebridge');
-    expect(result).toHaveLength(2);
-    expect(result[0].yanked).toBe(true);
-    expect(result[1].vers).toBe('1.0.0+3');
-  });
-
-  test('appendIndex creates parent directories', () => {
-    storage.appendIndex(entry('1.0.0+1'));
-    expect(existsSync(storage.indexPath('homebridge'))).toBe(true);
-  });
-});
-
-// ── storePackage / readPackage ────────────────────────────────────────────────
-
-describe('RegistryStorage package store/read', () => {
-  test('storePackage returns sha256 hex', () => {
-    const data = Buffer.from('fake netapp bytes');
-    const cksum = storage.storePackage('homebridge', '1.0.0+1', data);
-    expect(cksum).toMatch(/^[0-9a-f]{64}$/);
-  });
-
-  test('packageExists returns false before store, true after', () => {
-    expect(storage.packageExists('homebridge', '1.0.0+1')).toBe(false);
-    storage.storePackage('homebridge', '1.0.0+1', Buffer.from('data'));
-    expect(storage.packageExists('homebridge', '1.0.0+1')).toBe(true);
-  });
-
-  test('readPackage returns stored bytes', () => {
-    const data = Buffer.from('fake netapp bytes');
-    storage.storePackage('homebridge', '1.0.0+1', data);
-    const result = storage.readPackage('homebridge', '1.0.0+1');
-    expect(result?.toString()).toBe('fake netapp bytes');
-  });
-
-  test('readPackage returns null for missing version', () => {
-    expect(storage.readPackage('homebridge', '9.9.9+1')).toBeNull();
-  });
-
-  test('sha256 is consistent with stored data', () => {
-    const data = Buffer.from('deterministic content');
-    const cksum = storage.storePackage('homebridge', '1.0.0+1', data);
-    expect(cksum).toBe(storage.sha256(data));
-  });
-});
-
-// ── listModules / getModule ───────────────────────────────────────────────────
-
-describe('RegistryStorage listModules / getModule', () => {
-  test('listModules returns empty when no modules stored', () => {
-    expect(storage.listModules()).toEqual([]);
-  });
-
-  test('listModules returns stored modules with their index entries', () => {
-    storage.storePackage('homebridge', '1.0.0+1', Buffer.from('a'));
-    storage.appendIndex({
-      name: 'homebridge',
-      vers: '1.0.0+1',
-      deps: [],
-      cksum: 'x',
-      yanked: false,
-    });
-    const list = storage.listModules();
-    expect(list).toHaveLength(1);
-    expect(list[0].name).toBe('homebridge');
-    expect(list[0].versions).toHaveLength(1);
-  });
-
-  test('getModule returns null for unknown module', () => {
-    expect(storage.getModule('nonexistent')).toBeNull();
-  });
-
-  test('getModule returns module with versions when index has entries', () => {
-    storage.appendIndex({ name: 'caddy', vers: '2.0.0+1', deps: [], cksum: 'y', yanked: false });
-    const mod = storage.getModule('caddy');
-    expect(mod?.name).toBe('caddy');
-    expect(mod?.versions).toHaveLength(1);
-  });
-});

package/registry-server/src/sweep.test.ts

@@ -1,326 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { existsSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { RegistryStorage } from './storage';
-import { DEFAULT_KEEP_BUILD_REVISIONS, parseRevision, planModuleSweep, sweep } from './sweep';
-
-let dataDir: string;
-let storage: RegistryStorage;
-
-beforeEach(() => {
-  dataDir = mkdtempSync(join(tmpdir(), 'celilo-registry-sweep-'));
-  storage = new RegistryStorage(dataDir);
-});
-
-afterEach(() => {
-  rmSync(dataDir, { recursive: true, force: true });
-});
-
-/** Publish a version through the same two calls the real publish path uses. */
-function publish(name: string, vers: string, sizeBytes = 32): void {
-  storage.storePackage(name, vers, Buffer.alloc(sizeBytes, 7));
-  storage.appendIndex({ name, vers, deps: [], cksum: `sha256:${vers}`, yanked: false });
-}
-
-/**
- * THE invariant. A sweep that trims payloads without trimming index lines
- * leaves the index advertising a version whose file is gone — search lists it
- * and the download 404s. The reverse leaves unreachable bytes on the disk the
- * sweep exists to reclaim. Both directions have to hold.
- */
-function expectIndexAndPayloadsAgree(name: string): void {
-  const indexed = storage.readIndex(name).map((e) => e.vers);
-  const stored = storage.storedVersions(name).sort();
-  for (const vers of indexed) {
-    expect(storage.readPackage(name, vers)).not.toBeNull();
-  }
-  expect(stored).toEqual([...indexed].sort());
-}
-
-describe('parseRevision', () => {
-  test('splits a release from its build revision', () => {
-    expect(parseRevision('1.0.3+7')).toEqual({ release: '1.0.3', revision: 7 });
-  });
-
-  test('keeps a Debian epoch with the release', () => {
-    expect(parseRevision('2:1.0.0+1')).toEqual({ release: '2:1.0.0', revision: 1 });
-  });
-
-  test('returns null for a version with no build revision', () => {
-    expect(parseRevision('1.0.0')).toBeNull();
-  });
-});
-
-describe('planModuleSweep', () => {
-  const entry = (vers: string, yanked = false) => ({
-    name: 'm',
-    vers,
-    deps: [],
-    cksum: 'sha256:x',
-    yanked,
-  });
-
-  /**
-   * Plan against a store where every indexed version HAS its payload — the
-   * ordinary case. Passing an empty stored set instead would trip the
-   * unreadable guard, which is a different scenario with its own tests below.
-   */
-  const planWithPayloads = (entries: ReturnType<typeof entry>[], keepBuildRevisions: number) =>
-    planModuleSweep(
-      'm',
-      entries,
-      entries.map((e) => e.vers),
-      { keepBuildRevisions },
-    );
-
-  test('keeps the newest build revision of every release', () => {
-    const entries = [
-      entry('1.0.0+1'),
-      entry('1.0.0+2'),
-      entry('1.0.2+8'),
-      entry('1.0.2+9'),
-      entry('1.0.3+5'),
-      entry('1.0.3+6'),
-      entry('1.0.3+7'),
-    ];
-    const plan = planWithPayloads(entries, 1);
-    expect(plan.keep.map((e) => e.vers)).toEqual(['1.0.0+2', '1.0.2+9', '1.0.3+7']);
-    expect(plan.remove).toEqual(['1.0.0+1', '1.0.2+8', '1.0.3+5', '1.0.3+6']);
-  });
-
-  test('never removes the only revision of a release', () => {
-    const entries = [entry('0.9.0+2'), entry('1.0.0+1')];
-    const plan = planWithPayloads(entries, 1);
-    expect(plan.remove).toEqual([]);
-  });
-
-  test('a module can never be swept out of existence', () => {
-    const entries = [entry('1.0.0+1')];
-    const plan = planWithPayloads(entries, 1);
-    expect(plan.keep).toHaveLength(1);
-  });
-
-  test('keeps more revisions per release when asked', () => {
-    const entries = [entry('1.0.3+5'), entry('1.0.3+6'), entry('1.0.3+7')];
-    const plan = planWithPayloads(entries, 2);
-    expect(plan.keep.map((e) => e.vers)).toEqual(['1.0.3+6', '1.0.3+7']);
-  });
-
-  test('keepBuildRevisions below 1 is clamped — no policy deletes a whole release', () => {
-    // Needs MORE THAN ONE release to be a real check. With a single release
-    // the latest-line retention below masks a missing clamp; with two, an
-    // unclamped 0 wipes out every release except the last.
-    const entries = [entry('1.0.0+1'), entry('1.0.0+2'), entry('1.0.3+5'), entry('1.0.3+6')];
-    const plan = planWithPayloads(entries, 0);
-    expect(plan.keep.map((e) => e.vers)).toEqual(['1.0.0+2', '1.0.3+6']);
-  });
-
-  test('retains what latestVersion resolves to even when the index is out of order', () => {
-    // Last line wins for RegistryClient.latestVersion regardless of ordering,
-    // so a disordered index must not lose the version clients actually fetch.
-    const entries = [entry('1.0.3+7'), entry('1.0.3+6'), entry('1.0.3+5')];
-    const plan = planWithPayloads(entries, 1);
-    expect(plan.keep.map((e) => e.vers)).toContain('1.0.3+5');
-    expect(plan.keep.map((e) => e.vers)).toContain('1.0.3+7');
-  });
-
-  test('retains the last NON-yanked line, which is what clients resolve to', () => {
-    const entries = [entry('1.0.3+5'), entry('1.0.3+6'), entry('1.0.3+7', true)];
-    const plan = planWithPayloads(entries, 1);
-    expect(plan.keep.map((e) => e.vers)).toContain('1.0.3+6');
-  });
-
-  test('keeps a version it cannot parse rather than deleting it', () => {
-    const entries = [entry('nonsense'), entry('1.0.0+1'), entry('1.0.0+2')];
-    const plan = planWithPayloads(entries, 1);
-    expect(plan.remove).toEqual(['1.0.0+1']);
-  });
-
-  test('reports a payload with no index line as an orphan', () => {
-    const plan = planModuleSweep('m', [entry('1.0.0+2')], ['1.0.0+1', '1.0.0+2'], {
-      keepBuildRevisions: 1,
-    });
-    expect(plan.orphans).toEqual(['1.0.0+1']);
-  });
-});
-
-describe('sweep over a fixture store', () => {
-  test('index and payloads agree afterwards, and every release survives', () => {
-    for (const rev of [1, 2, 3, 4, 5]) publish('celilo-registry', `1.0.3+${rev}`);
-    for (const rev of [1, 2]) publish('celilo-registry', `1.0.2+${rev}`);
-    publish('forgejo', '2.1.0+1');
-
-    const report = sweep(storage, { keepBuildRevisions: DEFAULT_KEEP_BUILD_REVISIONS });
-
-    expect(report.removedCount).toBe(5);
-    expectIndexAndPayloadsAgree('celilo-registry');
-    expectIndexAndPayloadsAgree('forgejo');
-    // Original index order is preserved: the fixture published 1.0.3 before
-    // 1.0.2, and the sweep filters lines rather than re-sorting them.
-    expect(storage.readIndex('celilo-registry').map((e) => e.vers)).toEqual(['1.0.3+5', '1.0.2+2']);
-    expect(storage.readIndex('forgejo').map((e) => e.vers)).toEqual(['2.1.0+1']);
-  });
-
-  test('reclaims the bytes it says it reclaims', () => {
-    publish('m', '1.0.0+1', 4096);
-    publish('m', '1.0.0+2', 4096);
-    const report = sweep(storage, { keepBuildRevisions: 1 });
-    expect(report.reclaimedBytes).toBe(4096);
-  });
-
-  test('a dry run changes nothing', () => {
-    for (const rev of [1, 2, 3]) publish('m', `1.0.0+${rev}`);
-    const report = sweep(storage, { keepBuildRevisions: 1 }, true);
-
-    expect(report.removedCount).toBe(2);
-    expect(storage.readIndex('m')).toHaveLength(3);
-    expect(storage.storedVersions('m').sort()).toEqual(['1.0.0+1', '1.0.0+2', '1.0.0+3']);
-  });
-
-  test('is idempotent — a second sweep finds nothing to do', () => {
-    for (const rev of [1, 2, 3]) publish('m', `1.0.0+${rev}`);
-    sweep(storage, { keepBuildRevisions: 1 });
-    const second = sweep(storage, { keepBuildRevisions: 1 });
-
-    expect(second.removedCount).toBe(0);
-    expect(second.orphanCount).toBe(0);
-    expect(second.reclaimedBytes).toBe(0);
-    expectIndexAndPayloadsAgree('m');
-  });
-
-  test('a sweep interrupted after the index rewrite self-heals on the next run', () => {
-    for (const rev of [1, 2, 3]) publish('m', `1.0.0+${rev}`);
-    // The crash window: index trimmed, payloads not yet unlinked. The version
-    // is unlisted but still on disk — wasted bytes, not a broken registry.
-    storage.updateIndex('m', storage.readIndex('m').slice(-1));
-    expect(storage.storedVersions('m')).toHaveLength(3);
-
-    const report = sweep(storage, { keepBuildRevisions: 1 });
-
-    expect(report.orphanCount).toBe(2);
-    expectIndexAndPayloadsAgree('m');
-  });
-
-  test('a version left unlisted stays downloadable until its payload goes', () => {
-    // Why index-first is the safe order: the download route reads the payload
-    // directly and never consults the index, so the window an interrupted
-    // sweep opens serves stale-but-valid bytes rather than 404ing.
-    publish('m', '1.0.0+1');
-    storage.updateIndex('m', []);
-    expect(storage.readPackage('m', '1.0.0+1')).not.toBeNull();
-  });
-
-  test('reclaims a half-written publish, which is what makes the version publishable again', () => {
-    // Both states below exist on the production registry, created 2026-08-22 by
-    // real failures: an ENOSPC that killed a run after storePackage, and an
-    // EACCES on appendIndex. handlePublish has no rollback between the two.
-    //
-    // The consequence is worse than wasted bytes: `packageExists` reads the
-    // FILESYSTEM, so the orphan makes its own version permanently
-    // unpublishable — "versions are immutable". Removing the orphan is the
-    // repair, and nothing else in the product performs it.
-    storage.storePackage('celilo-mgmt', '0.6.2+2', Buffer.alloc(2048, 1));
-    publish('celilo-mgmt', '0.6.1+1');
-    expect(storage.packageExists('celilo-mgmt', '0.6.2+2')).toBe(true);
-
-    const report = sweep(storage, { keepBuildRevisions: 1 });
-
-    expect(report.orphanCount).toBe(1);
-    expect(storage.packageExists('celilo-mgmt', '0.6.2+2')).toBe(false);
-    expectIndexAndPayloadsAgree('celilo-mgmt');
-  });
-
-  test('REPORTS an index line with no payload and does not remove it', () => {
-    // The dangerous direction. Removing the line would actually repair the
-    // module — a dangling entry already 404s — but a missing payload is
-    // indistinguishable from an unreadable store, so it is reported only.
-    publish('m', '1.0.0+1');
-    publish('m', '1.0.0+2');
-    storage.removePackage('m', '1.0.0+1');
-
-    const report = sweep(storage, { keepBuildRevisions: 1 });
-
-    expect(report.danglingCount).toBe(1);
-    expect(report.modules[0]?.dangling).toEqual(['1.0.0+1']);
-    // Still listed: the sweep reported it rather than acting on it.
-    expect(storage.readIndex('m').map((e) => e.vers)).toContain('1.0.0+1');
-  });
-
-  test('touches nothing when a module has index lines and no payloads at all', () => {
-    // An unmounted volume or a wrong DATA_DIR looks exactly like this. Acting
-    // on it would trim the index of a module whose files are merely
-    // unreachable.
-    for (const rev of [1, 2, 3]) publish('m', `1.0.0+${rev}`);
-    for (const rev of [1, 2, 3]) storage.removePackage('m', `1.0.0+${rev}`);
-
-    const report = sweep(storage, { keepBuildRevisions: 1 });
-
-    expect(report.unreadable).toEqual(['m']);
-    expect(report.removedCount).toBe(0);
-    expect(storage.readIndex('m')).toHaveLength(3);
-  });
-
-  test('a dangling entry does not stop the rest of the sweep', () => {
-    publish('m', '1.0.0+1');
-    publish('m', '1.0.0+2');
-    publish('m', '1.0.0+3');
-    storage.removePackage('m', '1.0.0+1');
-
-    const report = sweep(storage, { keepBuildRevisions: 1 });
-
-    expect(report.danglingCount).toBe(1);
-    // 1.0.0+2 is superseded and still had its payload, so it is swept normally.
-    expect(report.removedCount).toBe(1);
-    expect(storage.readIndex('m').map((e) => e.vers)).toEqual(['1.0.0+1', '1.0.0+3']);
-  });
-
-  test('never sweeps the last SERVABLE version because a newer line is dangling', () => {
-    // The failure this guards: retention computed over every index line lets a
-    // dangling NEWEST entry satisfy both the per-release rule and the
-    // latest-line rule, so every servable older version reads as superseded.
-    // The module ends up listed, with one index line, and undownloadable.
-    publish('m', '1.0.0+1');
-    publish('m', '1.0.0+2');
-    publish('m', '1.0.0+3');
-    storage.removePackage('m', '1.0.0+3'); // the newest line is now dangling
-
-    sweep(storage, { keepBuildRevisions: 1 });
-
-    // Something is still downloadable, which is the whole point.
-    const servable = storage
-      .readIndex('m')
-      .map((e) => e.vers)
-      .filter((v) => storage.packageExists('m', v));
-    expect(servable.length).toBeGreaterThan(0);
-    expect(servable).toContain('1.0.0+2');
-  });
-
-  test('an empty store sweeps cleanly', () => {
-    const report = sweep(storage, { keepBuildRevisions: 1 });
-    expect(report.removedCount).toBe(0);
-    expect(report.modules).toEqual([]);
-  });
-});
-
-describe('updateIndex atomicity', () => {
-  test('leaves no temp file behind', () => {
-    publish('m', '1.0.0+1');
-    storage.updateIndex('m', storage.readIndex('m'));
-    expect(existsSync(`${storage.indexPath('m')}.tmp`)).toBe(false);
-  });
-
-  test('a write that cannot land leaves the original index intact', () => {
-    publish('m', '1.0.0+1');
-    publish('m', '1.0.0+2');
-    const before = storage.readIndex('m');
-    // Block the temp path so the new content cannot be written. A truncating
-    // in-place write ignores the obstruction and replaces the index anyway;
-    // the rename path fails with the original still on disk. This stands in
-    // for the failure that actually matters — ENOSPC on the full disk this
-    // sweep exists to relieve — which needs an fs seam to reproduce directly.
-    mkdirSync(`${storage.indexPath('m')}.tmp`, { recursive: true });
-    expect(() => storage.updateIndex('m', before.slice(0, 1))).toThrow();
-    expect(storage.readIndex('m')).toEqual(before);
-  });
-});

package/registry-server/src/validation.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { isValidName, isValidVersion, validateNameAndVersion } from './validation';
-
-describe('isValidName', () => {
-  test.each(['homebridge', 'my-module', 'a', 'a1', 'dns-external', 'x-y-z-2'])(
-    'accepts %s',
-    (name) => {
-      expect(isValidName(name)).toBe(true);
-    },
-  );
-
-  test.each([
-    ['empty', ''],
-    ['uppercase', 'Homebridge'],
-    ['underscore', 'my_module'],
-    ['leading hyphen', '-foo'],
-    ['trailing hyphen', 'foo-'],
-    ['double hyphen', 'foo--bar'],
-    ['space', 'foo bar'],
-    ['path traversal', '../etc'],
-    ['slash', 'foo/bar'],
-    ['dot', 'foo.bar'],
-    ['null byte', 'foo\0bar'],
-    ['newline', 'foo\nbar'],
-    ['carriage return', 'foo\rbar'],
-    ['URL-encoded slash after decode would be', '..%2F..'],
-    ['over 128 chars', `${'a'.repeat(129)}`],
-  ])('rejects %s', (_label, name) => {
-    expect(isValidName(name)).toBe(false);
-  });
-});
-
-describe('isValidVersion', () => {
-  test.each(['1.0.0+1', '1.4.2+1', '0.0.1+99', '1.5.0+1', '2:1.0.0+1', '0.0.0+1'])(
-    'accepts %s',
-    (vers) => {
-      expect(isValidVersion(vers)).toBe(true);
-    },
-  );
-
-  test.each([
-    ['empty', ''],
-    ['no pkgrev', '1.0.0'],
-    ['pkgrev not numeric', '1.0.0+abc'],
-    ['semver not numeric', 'a.b.c+1'],
-    ['hyphen pkgrev', '1.0.0-1'],
-    ['path traversal', '../../etc'],
-    ['slash', '1.0.0+1/foo'],
-    ['dot-dot', '1.0.0+1/..'],
-    ['null byte', '1.0.0+1\0'],
-    ['newline', '1.0.0+1\n'],
-    ['space', '1.0.0 +1'],
-    ['extra dot', '1.0.0.0+1'],
-    ['negative pkgrev', '1.0.0+-1'],
-    ['four parts', '1.2.3.4+1'],
-    ['pkgrev missing', '1.0.0+'],
-    ['URL-encoded bad version', '..%2F..%2Fetc'],
-    ['over 128 chars', `${'1'.repeat(129)}.0.0+1`],
-  ])('rejects %s', (_label, vers) => {
-    expect(isValidVersion(vers)).toBe(false);
-  });
-});
-
-describe('validateNameAndVersion', () => {
-  test('accepts a matched valid pair', () => {
-    expect(validateNameAndVersion('homebridge', '1.4.2+1')).toEqual({ ok: true });
-  });
-
-  test('flags the name field when bad', () => {
-    const r = validateNameAndVersion('../etc', '1.0.0+1');
-    expect(r.ok).toBe(false);
-    if (!r.ok) expect(r.field).toBe('name');
-  });
-
-  test('flags the vers field when bad', () => {
-    const r = validateNameAndVersion('homebridge', '../etc');
-    expect(r.ok).toBe(false);
-    if (!r.ok) expect(r.field).toBe('vers');
-  });
-
-  test('reports name first when both are bad (fail-fast)', () => {
-    const r = validateNameAndVersion('../etc', '1.0.0');
-    expect(r.ok).toBe(false);
-    if (!r.ok) expect(r.field).toBe('name');
-  });
-});