@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/relaunch-root.test.js

@@ -1,249 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/relaunch-root.test.ts
-//
-// Bug regression (commit 07e704e, "broker becomes universal host"): `/new` on a
-// ROOT used to do an in-place SAME-id reset (resetRoot reaped + wiped + re-pointed
-// the same node id) instead of starting a genuinely new node. Model B fixes it:
-// relaunchRoot parks the old root `done` (kept as history, NOT canceled) and mints
-// a FRESH node id + broker, re-pointing the viewer pane. These tests lock in that
-// behavior via the injectable deps seam, so they run tmux-free and broker-free.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { CrtrClient } from '../../api/client.js';
-import { createApiServer } from '../../daemon/api/server.js';
-import registerCanvasStophook from '../../pi-extensions/canvas-stophook.js';
-import { createNode, getNode, subscribe } from '../canvas/canvas.js';
-import { beginExecution, recordExecutionPid } from '../canvas/executions.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { resetScopeCache } from '../scope.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
-import { apiSocketPath } from '../canvas/paths.js';
-import { brokerCapReached, resetFleetForTests } from '../runtime/fleet.js';
-import { buildPiArgv } from '../runtime/launch.js';
-import { relaunchRoot } from '../runtime/reset.js';
-import { bindTestFleet } from './helpers/fleet.js';
-let home;
-let tf;
-const previousHome = process.env['HOME'];
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-/** A tmux-free / broker-free deps seam. `pid` controls the new broker launch:
- *  a number = success, null = a boot failure. Records the node ids launchBroker
- *  was called with, so the boot-failure test can find the half-born new node. */
-async function waitForApi() {
-    const client = CrtrClient.forLocalSocket({ autostart: false });
-    for (let i = 0; i < 200; i++) {
-        if (existsSync(apiSocketPath())) {
-            try {
-                await client.healthz();
-                return;
-            }
-            catch { /* the socket can appear before it accepts */ }
-        }
-        await new Promise((resolve) => setTimeout(resolve, 5));
-    }
-    throw new Error('API socket did not become ready');
-}
-function makeDeps(pid) {
-    const launched = [];
-    const deps = {
-        launchBroker: (nodeId) => {
-            launched.push(nodeId);
-            return { pid, exited: new Promise(() => { }) };
-        },
-        waitForViewSocket: () => true,
-        respawnViewer: () => true,
-        teardownBroker: async () => ({ confirmed: true }),
-    };
-    return { deps, launched };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-relaunch-'));
-    process.env['HOME'] = home;
-    process.env['CRTR_HOME'] = join(home, 'canvas');
-});
-beforeEach(() => {
-    closeDb();
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    resetScopeCache();
-    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
-    migrate(openDb());
-    tf = bindTestFleet();
-});
-after(() => {
-    closeDb();
-    closeScopedStores();
-    tf.fleet.dispose();
-    resetFleetForTests();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-    if (previousHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = previousHome;
-    resetScopeCache();
-});
-test('relaunchRoot parks the old root done and mints a fresh active root, reaping descendants', async () => {
-    // root → child → grandchild (a parent that subscribes to its workers).
-    createNode(node('root', { parent: null, lifecycle: 'resident', cwd: '/tmp/proj' }));
-    createNode(node('child', { parent: 'root' }));
-    createNode(node('grand', { parent: 'child' }));
-    subscribe('root', 'child', true);
-    subscribe('child', 'grand', true);
-    const { deps, launched } = makeDeps(4242);
-    const res = await relaunchRoot('root', deps);
-    // A fresh, DIFFERENT node id was minted and booted.
-    assert.ok(res, 'relaunchRoot returns the new node id');
-    const newId = res.newNodeId;
-    assert.notEqual(newId, 'root', 'a genuinely NEW node id (not a same-id reset — the bug)');
-    assert.deepEqual(launched, [newId], 'the new node id is the one we booted a broker for');
-    // (1) Old root parked DONE — kept as history, NOT canceled (explicit CTO call).
-    assert.equal(getNode('root')?.status, 'done', 'old root parked done (kept as history)');
-    // (2) The new node is an active, top-level resident inheriting the old root's
-    //     kind + cwd.
-    const fresh = getNode(newId);
-    assert.equal(fresh?.status, 'active', 'new node is active');
-    assert.equal(fresh?.parent, null, 'new node is a root (no spine parent)');
-    assert.equal(fresh?.kind, 'general', 'new node inherits the old root kind');
-    assert.equal(fresh?.cwd, '/tmp/proj', 'new node inherits the old root cwd');
-    assert.equal(fresh?.lifecycle, 'resident', 'a relaunched root is resident');
-    // (3) Descendants reaped → canceled (A5: an externally-reaped node did not
-    //     finish its OWN work; done is reserved for finalize).
-    assert.equal(getNode('child')?.status, 'canceled', 'descendant child canceled');
-    assert.equal(getNode('grand')?.status, 'canceled', 'descendant grandchild canceled');
-});
-test('relaunchRoot preserves an explicit model override as an exact replay recipe', async () => {
-    const exactModel = 'anthropic/claude-opus-5:high';
-    createNode(node('root', {
-        parent: null,
-        lifecycle: 'resident',
-        model_override: exactModel,
-        launch: { extensions: [], env: {}, model: exactModel, modelExact: true },
-    }));
-    const { deps } = makeDeps(4242);
-    const result = await relaunchRoot('root', deps);
-    assert.ok(result);
-    const replacement = getNode(result.newNodeId);
-    assert.equal(replacement?.launch?.model, exactModel);
-    assert.equal(replacement?.launch?.modelExact, true, 'the replacement cannot route away from the override');
-    assert.ok(buildPiArgv(replacement, {}).argv.includes('--crtr-model-exact'), 'broker replay preserves the exact-model contract');
-});
-test('relaunchRoot on a boot failure leaves the old root + descendants fully intact', async () => {
-    // The mint-and-boot-FIRST ordering: a launch failure (pid=null) must occur
-    // BEFORE the old root is parked or its descendants reaped.
-    createNode(node('root', { parent: null, lifecycle: 'resident' }));
-    createNode(node('child', { parent: 'root' }));
-    subscribe('root', 'child', true);
-    const { deps, launched } = makeDeps(null); // broker never starts
-    const res = await relaunchRoot('root', deps);
-    assert.equal(res, null, 'a boot failure returns null');
-    // Old root + descendant untouched: still live, ready to keep running.
-    assert.equal(getNode('root')?.status, 'active', 'old root left active + untouched');
-    assert.equal(getNode('child')?.status, 'active', 'descendant left active + untouched');
-    // The half-born new node was crashed (so the daemon never watches a zombie).
-    assert.equal(launched.length, 1, 'one broker launch was attempted');
-    assert.equal(getNode(launched[0])?.status, 'dead', 'the half-born new node is crashed (dead)');
-});
-test('relaunchRoot at capacity refuses visibly and settles the half-born row before preserving the old root', async () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident' }));
-    createNode(node('child', { parent: 'root' }));
-    subscribe('root', 'child', true);
-    const launched = [];
-    const deps = {
-        launchBroker: (nodeId) => {
-            launched.push(nodeId);
-            throw brokerCapReached(2, 2);
-        },
-        waitForViewSocket: () => true,
-        respawnViewer: () => true,
-        teardownBroker: async () => ({ confirmed: true }),
-    };
-    await assert.rejects(() => relaunchRoot('root', deps), (error) => {
-        const details = error.details ?? {};
-        assert.equal(details['error'], 'broker_cap_reached');
-        assert.match(String(details['message']), /2 live brokers at the cap of 2/);
-        return true;
-    });
-    assert.equal(getNode('root')?.status, 'active', 'the old root remains live');
-    assert.equal(getNode('child')?.status, 'active', 'its descendants remain live');
-    assert.equal(launched.length, 1);
-    assert.equal(getNode(launched[0])?.status, 'dead', 'the half-born replacement is terminal, not an active pid-less strand');
-});
-test('root /new capacity refusal reaches the attached human through broker UI notify', async () => {
-    process.env['CRTR_MAX_LIVE_BROKERS'] = '2';
-    process.env['CRTR_NODE_ID'] = 'root';
-    createNode(node('root', { parent: null, lifecycle: 'resident' }));
-    const tf = bindTestFleet();
-    const executionId = beginExecution('root', { daemonEpoch: tf.fleet.epoch() });
-    assert.equal(recordExecutionPid(executionId, 'root', process.pid), 'recorded');
-    const previousExecutionId = process.env['CRTR_EXECUTION_ID'];
-    process.env['CRTR_EXECUTION_ID'] = executionId;
-    const never = new Promise(() => { });
-    tf.fleet.register('filler-a', { pid: 700_001, exited: never });
-    tf.fleet.register('filler-b', { pid: 700_002, exited: never });
-    const server = createApiServer();
-    try {
-        await waitForApi();
-        let sessionStart;
-        registerCanvasStophook({
-            on(event, handler) {
-                if (event === 'session_start')
-                    sessionStart = async (ev, ctx) => { await handler(ev, ctx); };
-            },
-            sendUserMessage() { },
-            sendMessage() { },
-        });
-        let resolveNotice;
-        const notice = new Promise((resolve) => { resolveNotice = resolve; });
-        await sessionStart?.({ reason: 'new' }, {
-            sessionManager: {
-                getSessionId: () => 'root-new-session',
-                getSessionFile: () => null,
-                getBranch: () => [],
-            },
-            ui: { notify: (message) => resolveNotice(message) },
-        });
-        const message = await Promise.race([
-            notice,
-            new Promise((_, reject) => setTimeout(() => reject(new Error('capacity notice was not shown')), 1_000)),
-        ]);
-        assert.match(message, /^\/new refused: no broker slot is free/);
-        assert.match(message, /2 live brokers at the cap of 2/);
-    }
-    finally {
-        await server.close();
-        tf.fleet.dispose();
-        resetFleetForTests();
-        delete process.env['CRTR_MAX_LIVE_BROKERS'];
-        delete process.env['CRTR_NODE_ID'];
-        if (previousExecutionId === undefined)
-            delete process.env['CRTR_EXECUTION_ID'];
-        else
-            process.env['CRTR_EXECUTION_ID'] = previousExecutionId;
-    }
-});
-test('relaunchRoot is a no-op for a non-root child and an already-parked root', async () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident' }));
-    createNode(node('child', { parent: 'root' }));
-    createNode(node('done-root', { parent: null, status: 'done' }));
-    const { deps, launched } = makeDeps(1);
-    assert.equal(await relaunchRoot('child', deps), null, 'a child is not a relaunchable root');
-    assert.equal(await relaunchRoot('done-root', deps), null, 'a done root is not relaunched again (double /new)');
-    assert.equal(await relaunchRoot('ghost', deps), null, 'an unknown node is a no-op');
-    assert.deepEqual(launched, [], 'no broker was booted for any of the no-op cases');
-});

package/dist/core/__tests__/remote-canvas-target.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/remote-canvas-target.test.js

@@ -1,93 +0,0 @@
-// remote-canvas-target.test.ts — config normalization for
-// `remoteCanvas.targets.<name>` (`../config.ts`'s normalizeRemoteCanvasTarget,
-// exercised through the public readConfig/updateConfig surface — it isn't
-// exported directly) plus `resolveRemoteCanvasTarget`'s error paths
-// (`../remote-canvas-target.ts`). The one load-bearing invariant here:
-// an error message about a missing/unknown target must never leak a token
-// substring, even though it's guiding the agent toward the exact command
-// that would set one.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { ensureScopeInitialized, readConfig, updateConfig } from '../config.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { resetScopeCache } from '../scope.js';
-import { setRelayToken } from '../secrets.js';
-import { getRemoteCanvasTarget, resolveRemoteCanvasTarget } from '../remote-canvas-target.js';
-let home;
-let realHome;
-before(() => {
-    realHome = process.env['HOME'];
-    home = mkdtempSync(join(tmpdir(), 'crtr-remote-target-'));
-    process.env['HOME'] = home;
-});
-beforeEach(() => {
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    resetScopeCache();
-    ensureScopeInitialized('user', join(home, '.crouter'));
-});
-after(() => {
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    if (realHome !== undefined)
-        process.env['HOME'] = realHome;
-    else
-        delete process.env['HOME'];
-});
-test('normalizeRemoteCanvasTarget accepts a valid relayTokenRef entry', () => {
-    updateConfig('user', (cfg) => {
-        cfg.remoteCanvas.targets['cloud'] = { previewEndpoint: 'https://x.preview.bl.run', relayTokenRef: 'cloud' };
-    });
-    const target = getRemoteCanvasTarget('cloud', 'user');
-    assert.deepEqual(target, { previewEndpoint: 'https://x.preview.bl.run', relayTokenRef: 'cloud' });
-});
-test('normalizeRemoteCanvasTarget drops an entry missing relayTokenRef instead of throwing', () => {
-    updateConfig('user', (cfg) => {
-        // Bypass the RemoteCanvasTarget type to write a malformed raw entry, the
-        // same way a hand-edited config.json could.
-        cfg.remoteCanvas.targets['broken'] = { previewEndpoint: 'https://x.preview.bl.run' };
-    });
-    const cfg = readConfig('user');
-    assert.equal(cfg.remoteCanvas.targets['broken'], undefined);
-});
-test('normalizeRemoteCanvasTarget drops an entry with an empty previewEndpoint', () => {
-    updateConfig('user', (cfg) => {
-        cfg.remoteCanvas.targets['broken'] = { previewEndpoint: '', relayTokenRef: 'x' };
-    });
-    assert.equal(readConfig('user').remoteCanvas.targets['broken'], undefined);
-});
-test('resolveRemoteCanvasTarget on an unknown name throws a usage error that never contains a token substring', () => {
-    updateConfig('user', (cfg) => {
-        cfg.remoteCanvas.targets['cloud'] = { previewEndpoint: 'https://x.preview.bl.run', relayTokenRef: 'cloud' };
-    });
-    setRelayToken('cloud', 'super-secret-token', 'user');
-    assert.throws(() => resolveRemoteCanvasTarget('no-such-target', 'user'), (err) => {
-        assert.ok(err instanceof Error);
-        assert.match(err.message, /no remote canvas target named 'no-such-target'/);
-        assert.match(err.message, /configured: cloud/);
-        assert.ok(!err.message.includes('super-secret-token'));
-        return true;
-    });
-});
-test('resolveRemoteCanvasTarget on a target with no stored token throws without leaking a token substring', () => {
-    updateConfig('user', (cfg) => {
-        cfg.remoteCanvas.targets['cloud'] = { previewEndpoint: 'https://x.preview.bl.run', relayTokenRef: 'cloud' };
-    });
-    // Deliberately no setRelayToken call — the secret was never stored.
-    assert.throws(() => resolveRemoteCanvasTarget('cloud', 'user'), (err) => {
-        assert.ok(err instanceof Error);
-        assert.match(err.message, /has no stored relay token/);
-        return true;
-    });
-});
-test('resolveRemoteCanvasTarget on a fully configured target returns the RelayTarget with the real token', () => {
-    updateConfig('user', (cfg) => {
-        cfg.remoteCanvas.targets['cloud'] = { previewEndpoint: 'https://x.preview.bl.run', relayTokenRef: 'cloud' };
-    });
-    setRelayToken('cloud', 'super-secret-token', 'user');
-    const relay = resolveRemoteCanvasTarget('cloud', 'user');
-    assert.deepEqual(relay, { previewEndpoint: 'https://x.preview.bl.run', relayToken: 'super-secret-token' });
-});

package/dist/core/__tests__/repository-association.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/repository-association.test.js

@@ -1,153 +0,0 @@
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { gitSync } from '../git.js';
-import { realpathOrSelf } from '../fs-utils.js';
-import { associateRepository, normalizeOwnerRelativePath, resetRepositoryAssociationCache, } from '../memory/repository-association.js';
-import { slugCanonicalPath, slugCanonicalSegment } from '../memory/identity.js';
-const cleanups = [];
-let previousHome;
-before(() => {
-    previousHome = process.env['HOME'];
-});
-beforeEach(() => {
-    process.env['HOME'] = realpathOrSelf(mkdtempSync(join('/tmp', 'crtr-association-home-')));
-    cleanups.push(process.env['HOME']);
-    resetRepositoryAssociationCache();
-});
-after(() => {
-    resetRepositoryAssociationCache();
-    for (const path of cleanups)
-        rmSync(path, { recursive: true, force: true });
-    if (previousHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = previousHome;
-});
-function temp(prefix) {
-    const path = realpathOrSelf(mkdtempSync(join('/tmp', prefix)));
-    cleanups.push(path);
-    return path;
-}
-function initGit(path) {
-    mkdirSync(path, { recursive: true });
-    assert.equal(gitSync(['-C', path, 'init', '-q'], undefined).status, 0);
-}
-function makeStore(owner) {
-    mkdirSync(join(owner, '.crouter', 'memory'), { recursive: true });
-    writeFileSync(join(owner, '.crouter', 'memory', 'INDEX.md'), '# store\n');
-}
-test('associates git roots, nested owners, and embedded repositories', () => {
-    const root = temp('crtr-association-git-');
-    initGit(root);
-    const nested = join(root, 'packages', 'api');
-    mkdirSync(nested, { recursive: true });
-    const atRoot = associateRepository(root);
-    assert.equal(atRoot.ok, true);
-    if (!atRoot.ok)
-        return;
-    assert.equal(atRoot.association.kind, 'git');
-    assert.equal(atRoot.association.repositoryRoot, root);
-    assert.equal(atRoot.association.ownerRelativePath, '');
-    assert.match(atRoot.association.repositoryKey, /^git:/);
-    assert.equal(atRoot.association.declarationPath, join(root, '.crouter', 'memory', 'INDEX.md'));
-    const belowRoot = associateRepository(nested);
-    assert.equal(belowRoot.ok, true);
-    if (!belowRoot.ok)
-        return;
-    assert.equal(belowRoot.association.repositoryRoot, root);
-    assert.equal(belowRoot.association.ownerRelativePath, 'packages/api');
-    const embedded = join(root, 'embedded');
-    initGit(embedded);
-    const embeddedOwner = join(embedded, 'pkg');
-    mkdirSync(embeddedOwner, { recursive: true });
-    const embeddedResult = associateRepository(embeddedOwner);
-    assert.equal(embeddedResult.ok, true);
-    if (!embeddedResult.ok)
-        return;
-    assert.equal(embeddedResult.association.repositoryRoot, embedded);
-    assert.equal(embeddedResult.association.ownerRelativePath, 'pkg');
-});
-test('linked worktrees share repository key and owner-relative path', () => {
-    const main = temp('crtr-association-main-');
-    initGit(main);
-    writeFileSync(join(main, 'README'), 'repo\n');
-    assert.equal(gitSync(['-C', main, 'add', 'README'], undefined).status, 0);
-    assert.equal(gitSync(['-C', main, '-c', 'user.name=Test', '-c', 'user.email=test@example.com', 'commit', '-qm', 'initial'], undefined).status, 0);
-    const linked = join(temp('crtr-association-linked-parent-'), 'checkout');
-    assert.equal(gitSync(['-C', main, 'worktree', 'add', '-q', linked, 'HEAD'], undefined).status, 0);
-    const mainOwner = join(main, 'packages', 'api');
-    const linkedOwner = join(linked, 'packages', 'api');
-    mkdirSync(mainOwner, { recursive: true });
-    mkdirSync(linkedOwner, { recursive: true });
-    const first = associateRepository(mainOwner);
-    const second = associateRepository(linkedOwner);
-    assert.equal(first.ok, true);
-    assert.equal(second.ok, true);
-    if (!first.ok || !second.ok)
-        return;
-    assert.equal(first.association.repositoryKey, second.association.repositoryKey);
-    assert.equal(first.association.ownerRelativePath, second.association.ownerRelativePath);
-    assert.notEqual(first.association.repositoryRoot, second.association.repositoryRoot);
-});
-test('non-git association chooses the outermost ancestor store and respects the home fence', () => {
-    const outer = join(homedir(), 'workspace');
-    const inner = join(outer, 'packages', 'api');
-    mkdirSync(inner, { recursive: true });
-    makeStore(outer);
-    makeStore(inner);
-    const result = associateRepository(inner);
-    assert.equal(result.ok, true);
-    if (!result.ok)
-        return;
-    assert.equal(result.association.kind, 'non-git');
-    assert.equal(result.association.repositoryRoot, outer);
-    assert.equal(result.association.repositoryKey, `path:${outer}`);
-    assert.equal(result.association.ownerRelativePath, 'packages/api');
-    const homeStoreOwner = join(homedir(), 'not-a-project');
-    mkdirSync(homeStoreOwner, { recursive: true });
-    makeStore(homedir());
-    const fenced = associateRepository(homeStoreOwner);
-    assert.equal(fenced.ok, false);
-    if (!fenced.ok)
-        assert.equal(fenced.code, 'no-project-root');
-});
-test('non-git failures are not cached and symlinked owners realpath before deriving paths', () => {
-    const root = temp('crtr-association-heal-');
-    const owner = join(root, 'docs');
-    mkdirSync(owner, { recursive: true });
-    const before = associateRepository(owner);
-    assert.equal(before.ok, false);
-    if (!before.ok)
-        assert.equal(before.code, 'no-project-root');
-    makeStore(root);
-    const healed = associateRepository(owner);
-    assert.equal(healed.ok, true);
-    if (!healed.ok)
-        return;
-    assert.equal(healed.association.repositoryRoot, root);
-    assert.equal(healed.association.ownerRelativePath, 'docs');
-    const link = join(root, 'alias');
-    symlinkSync(owner, link, 'dir');
-    const linked = associateRepository(link);
-    assert.equal(linked.ok, true);
-    if (!linked.ok)
-        return;
-    assert.equal(linked.association.ownerRelativePath, 'docs');
-    assert.equal(linked.association.repositoryRoot, root);
-});
-test('slugging and owner-path validation are explicit and lossless', () => {
-    assert.equal(slugCanonicalSegment('  My Notes!!!  '), 'my-notes');
-    assert.equal(slugCanonicalSegment('notes.md'), 'notes.md');
-    assert.equal(slugCanonicalPath('01-My Notes!!!/notes.md'), 'my-notes/notes');
-    assert.deepEqual(normalizeOwnerRelativePath('My Notes!!!\\notes.md'), { ok: true, path: 'my-notes/notes.md' });
-    assert.deepEqual(normalizeOwnerRelativePath('01-api/00-Notes'), { ok: true, path: 'api/notes' });
-    assert.deepEqual(normalizeOwnerRelativePath(''), { ok: true, path: '' });
-    assert.deepEqual(normalizeOwnerRelativePath('.'), { ok: true, path: '' });
-    for (const path of ['!!!', 'INDEX']) {
-        const result = normalizeOwnerRelativePath(path);
-        assert.equal(result.ok, false, `${path} must be rejected`);
-    }
-});

package/dist/core/__tests__/repository-root-identity.test.d.ts

@@ -1 +0,0 @@
-export {};