@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/helpers/viewer-panes.d.ts

@@ -1,12 +0,0 @@
-/** Read a pane's `@crtr_node` option ('' when unset / pane gone). */
-export declare function paneTag(pane: string): string;
-/** Every pane in `session` whose `@crtr_node` tag names `id` — the node's live
- *  on-screen viewer panes. A correct dedup keeps this at exactly 1. */
-export declare function taggedViewerPanes(session: string, id: string): string[];
-/** Every pane in `session` with the facts that explain a missing viewer, plus
- *  the tail of what each pane actually rendered. */
-export declare function describeSessionPanes(session: string, tailLines?: number): string;
-/** Wait until `id` has exactly one tagged viewer pane in `session` and return it
- *  — the attach client sets `@crtr_node` asynchronously on connect, so a test
- *  must let the viewer connect before reading the registry. */
-export declare function waitForOneTaggedViewer(session: string, id: string, timeoutMs?: number): Promise<string>;

package/dist/core/__tests__/helpers/viewer-panes.js

@@ -1,133 +0,0 @@
-// The `@crtr_node` pane-tag registry, read from a REAL tmux server.
-//
-// P1 moved the `surface node focus` viewer registry off the `focuses` DB table
-// onto a tmux pane option that the `crtr surface attach` viewer self-sets once
-// its startup checkpoint clears (`clients/attach/session/pane-tag.ts`). These
-// helpers are the ground truth for "which pane is a node's viewer", shared by
-// every compiled-seam test that asserts viewer dedup or teardown.
-//
-// The waiter dumps the live pane table AND each pane's rendered screen on
-// failure: when a viewer never tags, the reason is almost always printed inside
-// the pane it was launched in (a crashed CLI, a relay close, a usage error), and
-// a bare "never had exactly one tagged viewer pane" message throws that away —
-// which is precisely why the hosted-runner failures were undiagnosable from CI
-// logs while every dev box stayed green.
-import { spawnSync } from 'node:child_process';
-import { readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { TMUX_TIMEOUT_MS } from './harness.js';
-function tmux(args) {
-    return (spawnSync('tmux', args, { encoding: 'utf8', timeout: TMUX_TIMEOUT_MS }).stdout ?? '');
-}
-/** Read a pane's `@crtr_node` option ('' when unset / pane gone). */
-export function paneTag(pane) {
-    return tmux(['show-options', '-p', '-v', '-t', pane, '@crtr_node']).trim();
-}
-/** Every pane in `session` whose `@crtr_node` tag names `id` — the node's live
- *  on-screen viewer panes. A correct dedup keeps this at exactly 1. */
-export function taggedViewerPanes(session, id) {
-    return tmux(['list-panes', '-s', '-t', session, '-F', '#{pane_id} #{@crtr_node}'])
-        .split('\n')
-        .map((l) => l.trim())
-        .filter((l) => l.endsWith(` ${id}`))
-        .map((l) => l.split(' ')[0]);
-}
-/** Every pane in `session` with the facts that explain a missing viewer, plus
- *  the tail of what each pane actually rendered. */
-export function describeSessionPanes(session, tailLines = 25) {
-    // `-a`, not `-s`: a viewer that landed in the WRONG session is a different
-    // failure from a viewer that never opened, and only an all-server listing
-    // tells them apart. Pane size is in the row because a pane too short for the
-    // attach TUI is the reason a viewer dies before it can tag itself.
-    const rows = tmux([
-        'list-panes',
-        '-a',
-        '-t',
-        session,
-        '-F',
-        '#{session_name}\t#{pane_id}\t#{pane_width}x#{pane_height}\t#{pane_dead}\t#{pane_current_command}\t#{@crtr_node}',
-    ])
-        .split('\n')
-        .map((l) => l.trim())
-        .filter((l) => l !== '');
-    if (rows.length === 0)
-        return `  (no panes on the tmux server — the server or session ${session} is gone)`;
-    return rows
-        .map((row) => {
-        const pane = row.split('\t')[1];
-        const screen = tmux(['capture-pane', '-p', '-t', pane])
-            .split('\n')
-            .filter((l) => l.trim() !== '')
-            .slice(-tailLines)
-            .map((l) => `      | ${l}`)
-            .join('\n');
-        return `  ${row}\n${screen === '' ? '      | (blank)' : screen}`;
-    })
-        .join('\n');
-}
-/** Re-run the EXACT command a viewer pane bakes in (`crtr surface attach to
- *  <id>`), in a throwaway pane of the same session, with stdout+stderr redirected
- *  to a file — the only way to see why a viewer died, because tmux closes a
- *  failed pane instantly and takes its screen with it. Also prints the pane's
- *  resolved PATH/HOME/CRTR_HOME and whether `crtr` resolves at all, since a bare
- *  command that the tmux server cannot resolve is the classic runner-only cause. */
-async function probeViewerCommand(session, id) {
-    const log = join(tmpdir(), `crtr-viewer-probe-${process.pid}-${Date.now().toString(36)}.log`);
-    const script = `{ echo "PATH=$PATH"; echo "HOME=$HOME"; echo "CRTR_HOME=$CRTR_HOME"; ` +
-        `echo "which crtr: $(command -v crtr || echo NONE)"; ` +
-        `crtr surface attach to ${id}; echo "attach exit=$?"; } > ${log} 2>&1`;
-    const r = spawnSync('tmux', ['split-window', '-d', '-t', session, script], {
-        encoding: 'utf8',
-        timeout: TMUX_TIMEOUT_MS,
-    });
-    if ((r.status ?? 1) !== 0)
-        return `  (probe split-window failed: ${r.stderr ?? ''})`;
-    // Poll for the trailing marker so a fast failure (the common case: the bare
-    // command does not resolve) costs ~0.2s of the test's remaining budget, not a
-    // fixed sleep. Bounded well under the 30s per-test cap either way.
-    const deadline = Date.now() + 6_000;
-    let body = '';
-    for (;;) {
-        try {
-            body = readFileSync(log, 'utf8');
-        }
-        catch {
-            body = '';
-        }
-        if (body.includes('attach exit=') || Date.now() > deadline)
-            break;
-        await new Promise((res) => setTimeout(res, 200));
-    }
-    if (body === '')
-        return '  (probe produced no output)';
-    try {
-        rmSync(log, { force: true });
-    }
-    catch {
-        /* best effort */
-    }
-    const lines = body.split('\n').filter((l) => l.trim() !== '').slice(-40);
-    return lines.length === 0 ? '  (probe log empty)' : lines.map((l) => `  | ${l}`).join('\n');
-}
-/** Wait until `id` has exactly one tagged viewer pane in `session` and return it
- *  — the attach client sets `@crtr_node` asynchronously on connect, so a test
- *  must let the viewer connect before reading the registry. */
-export async function waitForOneTaggedViewer(session, id, timeoutMs = 15_000) {
-    const deadline = Date.now() + timeoutMs;
-    let panes = [];
-    while (Date.now() < deadline) {
-        panes = taggedViewerPanes(session, id);
-        if (panes.length === 1)
-            return panes[0];
-        await new Promise((r) => setTimeout(r, 150));
-    }
-    const dump = describeSessionPanes(session);
-    const probe = await probeViewerCommand(session, id);
-    throw new Error(`node ${id} never had exactly one tagged viewer pane within ${timeoutMs}ms ` +
-        `(saw ${panes.length}: ${panes.join(', ') || 'none'})\n` +
-        `tmux panes [session / pane_id / size / pane_dead / command / @crtr_node] and their screens:\n` +
-        dump +
-        `\nre-ran the viewer command in a throwaway pane of the same session:\n` +
-        probe);
-}

package/dist/core/__tests__/history-inbox.test.d.ts

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

package/dist/core/__tests__/history-inbox.test.js

@@ -1,121 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/history-inbox.test.ts
-//
-// Locks in the invariants of the `inbox` history source: it stays opt-in
-// (never part of the default corpus), its refs resolve/round-trip as
-// `<node>:inbox/NNNNNN`, direct-message bodies stay full/unclipped, and the
-// sender (`from`) is visible in both the read body and the artifact title.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode } from '../canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { contextDir } from '../canvas/paths.js';
-import { enqueueNodeMail } from '../feed/messages.js';
-import { buildCorpus, nodeArtifacts, resolveRef } from '../canvas/history.js';
-let home;
-function node(id, cwd) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd,
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-    };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-history-inbox-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    mkdirSync(home, { recursive: true });
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-test('history corpus skips malformed frontmatter in another cwd', () => {
-    const broken = createNode(node('broken-frontmatter', '/tmp/hist-broken'));
-    const valid = createNode(node('valid-history', '/tmp/hist-valid'));
-    writeFileSync(join(contextDir(broken.node_id), 'copied-source.md'), '---\ndesc: "unterminated\n---\nsource text\n');
-    writeFileSync(join(contextDir(valid.node_id), 'result.md'), '---\ntitle: result\n---\n0a0afd613\n');
-    const corpus = buildCorpus({ allCwds: true }, { types: ['report', 'doc', 'roadmap'] });
-    assert.equal(corpus.some((a) => a.ref === `${broken.node_id}:context/copied-source.md`), false, 'invalid artifact is skipped');
-    assert.ok(corpus.some((a) => a.loadBody().includes('0a0afd613')), 'valid artifacts remain searchable');
-});
-test('one node\'s artifact listing skips malformed frontmatter instead of failing', () => {
-    const n = createNode(node('single-node-broken', '/tmp/hist-single'));
-    // A context dir often holds foreign markdown (a checked-out repo) whose
-    // `---` header is not crouter frontmatter.
-    writeFileSync(join(contextDir(n.node_id), 'copied-source.md'), '---\npattern: "@(IsString)\\("\n---\nsource text\n');
-    writeFileSync(join(contextDir(n.node_id), 'result.md'), '---\ntitle: result\n---\n0a0afd613\n');
-    const arts = nodeArtifacts(n.node_id);
-    assert.equal(arts.some((a) => a.relpath === 'context/copied-source.md'), false, 'invalid artifact is skipped');
-    assert.ok(arts.some((a) => a.relpath === 'context/result.md'), 'valid artifacts still listed');
-});
-test('default history excludes inbox; --type inbox includes it, with full sender-attributed bodies', () => {
-    const cwd = '/tmp/hist-work';
-    createNode(node('sender-1', cwd));
-    const receiver = createNode(node('receiver-1', cwd));
-    const longBody = 'a'.repeat(4000); // well past any old label-clip length
-    enqueueNodeMail(receiver.node_id, {
-        senderNodeId: 'sender-1', kind: 'message', label: 'first line of a long message',
-        bodyJson: { body: longBody }, urgency: 'urgent', wake: 1,
-    });
-    // (a) default corpus (no explicit types) excludes inbox entirely.
-    const defaultCorpus = buildCorpus({ nodes: [receiver.node_id] }, {});
-    assert.equal(defaultCorpus.some((a) => a.source === 'inbox'), false, 'inbox is opt-in, not part of the default corpus');
-    // (b) explicit --type inbox includes it.
-    const inboxCorpus = buildCorpus({ nodes: [receiver.node_id] }, { types: ['inbox'] });
-    assert.equal(inboxCorpus.length, 1, 'exactly the one appended entry');
-    const artifact = inboxCorpus[0];
-    assert.equal(artifact.source, 'inbox');
-    // (c) ref resolves as <node>:inbox/000000 and round-trips through resolveRef.
-    const expectedRef = `${receiver.node_id}:inbox/000000`;
-    assert.equal(artifact.ref, expectedRef);
-    const resolved = resolveRef(expectedRef);
-    assert.ok(resolved !== null, 'ref resolves back to the entry');
-    assert.equal(resolved.source, 'inbox');
-    // (d) the direct-message body is full/unclipped in both the corpus artifact
-    // and the resolveRef read path.
-    assert.ok(artifact.loadBody().includes(longBody), 'corpus artifact body is unclipped');
-    assert.ok(resolved.body.includes(longBody), 'resolveRef body is unclipped');
-    // (e) the sender is visible — in the read body (not just resolvable via the
-    // node the inbox belongs to) and in the artifact title used by list rows.
-    assert.ok(resolved.body.includes('from: sender-1'), 'read body names the sender');
-    assert.ok(artifact.title.includes('sender-1'), 'artifact title names the sender for list/search rows');
-});
-test('a spilled message body is read RAW — a leading frontmatter-shaped block is not stripped', () => {
-    const cwd = '/tmp/hist-work-3';
-    createNode(node('sender-3', cwd));
-    const receiver = createNode(node('receiver-3', cwd));
-    // Long enough to force the spill-to-messages/ path (past BODY_MAX_CHARS),
-    // and starts with a block that LOOKS like crouter report frontmatter but
-    // isn't one — a spilled message has no frontmatter contract, so this must
-    // survive intact, unlike a report ref (which always has real frontmatter
-    // stripped by fileBodyLoader).
-    const body = '---\nfoo: bar\n---\n' + 'a'.repeat(4000);
-    enqueueNodeMail(receiver.node_id, {
-        senderNodeId: 'sender-3', kind: 'message', label: 'first line',
-        bodyJson: { body }, urgency: 'normal', wake: 1,
-    });
-    const resolved = resolveRef(`${receiver.node_id}:inbox/000000`);
-    assert.ok(resolved !== null);
-    assert.ok(resolved.body.includes('---\nfoo: bar\n---'), 'leading frontmatter-shaped block is preserved, not stripped');
-});
-test('a null-from (system) inbox entry reads as "system", not blank or thrown', () => {
-    const cwd = '/tmp/hist-work-2';
-    const receiver = createNode(node('receiver-2', cwd));
-    enqueueNodeMail(receiver.node_id, { kind: 'update', label: 'system note', urgency: 'normal', wake: 1 });
-    const resolved = resolveRef(`${receiver.node_id}:inbox/000000`);
-    assert.ok(resolved !== null);
-    assert.ok(resolved.body.includes('from: system'), 'null sender renders as "system"');
-});

package/dist/core/__tests__/human-action-delivery.test.d.ts

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

package/dist/core/__tests__/human-action-delivery.test.js

@@ -1,162 +0,0 @@
-import { after, afterEach, beforeEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { ensureScopeInitialized } from '../config.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { enqueueExternalAction } from '../feed/messages.js';
-import { claimExternalActionDelivery, readExternalActionDelivery, settleDelivery } from '../canvas/deliveries.js';
-import { deliveryBackoffMs } from '../canvas/delivery-contract.js';
-import { deliverySettlementForOutcome, runDelivery } from '../../daemon/delivery/run-delivery.js';
-let home;
-const priorHome = process.env['CRTR_HOME'];
-const priorUserHome = process.env['HOME'];
-function actionDelivery(requestId) {
-    return readExternalActionDelivery(`human-action:${requestId}`);
-}
-function enqueueAction(requestId, argv, cwd, completion) {
-    return enqueueExternalAction({
-        destinationId: 'human_action',
-        adapter: { adapter: 'subprocess', argv, cwd },
-        bodyJson: completion,
-        idempotencyKey: `human-action:${requestId}`,
-    });
-}
-async function deliverAction(deliveryId, argv, cwd, document, attempt, claimOwner) {
-    await runDelivery({ argv, cwd, document, attempt }, (settlement) => settleDelivery(deliveryId, attempt, claimOwner, settlement, Date.now()));
-}
-beforeEach(() => {
-    closeDb();
-    home = mkdtempSync(join(tmpdir(), 'crtr-human-action-delivery-'));
-    process.env['CRTR_HOME'] = home;
-    process.env['HOME'] = home;
-    ensureScopeInitialized('user', join(home, '.crouter'));
-    migrate(openDb());
-});
-afterEach(() => {
-    closeDb();
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    if (priorHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = priorHome;
-    if (priorUserHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = priorUserHome;
-});
-test('delivery retries follow the durable backoff and exit boundary', () => {
-    assert.equal(deliveryBackoffMs(1), 5_000);
-    assert.equal(deliveryBackoffMs(2), 10_000);
-    assert.equal(deliveryBackoffMs(3), 20_000);
-    assert.equal(deliveryBackoffMs(11), 3_600_000);
-    assert.equal(deliveryBackoffMs(100), 3_600_000);
-    const now = 1_000_000;
-    const outcome = (exitCode, signal = null) => deliverySettlementForOutcome({
-        exitCode,
-        signal,
-        timedOut: false,
-        stderr: 'diagnostic',
-    }, 2, now);
-    assert.deepEqual(outcome(0), { state: 'accepted' });
-    assert.deepEqual(outcome(77), {
-        state: 'pending',
-        nextAttemptAt: now + 10_000,
-        failure: { kind: 'exit', exitCode: 77, stderr: 'diagnostic' },
-    });
-    assert.deepEqual(outcome(78), {
-        state: 'permanent_failed',
-        failure: { kind: 'exit', exitCode: 78, stderr: 'diagnostic' },
-    });
-    assert.equal(outcome(79).state, 'pending');
-    assert.equal(outcome(null, 'SIGTERM').state, 'pending');
-    assert.equal(deliverySettlementForOutcome({
-        exitCode: null,
-        signal: null,
-        timedOut: true,
-        stderr: '',
-    }, 1, now).state, 'pending');
-    // The kill escalation's signal is the only way to tell the graceful term from the SIGKILL.
-    assert.deepEqual(deliverySettlementForOutcome({
-        exitCode: null,
-        signal: 'SIGKILL',
-        timedOut: true,
-        stderr: 'stalled',
-    }, 1, now), {
-        state: 'pending',
-        nextAttemptAt: now + 5_000,
-        failure: { kind: 'timeout', signal: 'SIGKILL', stderr: 'stalled' },
-    });
-    assert.equal(deliverySettlementForOutcome({
-        exitCode: null,
-        signal: null,
-        timedOut: false,
-        spawnError: new Error('missing executable'),
-        stderr: '',
-    }, 1, now).state, 'pending');
-});
-test('the delivery child gets the consent boundary env, never crtrd\'s own', async () => {
-    const priorUserHome = process.env['HOME'];
-    const project = join(home, 'project');
-    mkdirSync(join(project, '.crouter'), { recursive: true });
-    writeFileSync(join(project, '.crouter', 'config.json'), JSON.stringify({ spawnEnv: { allow: ['NL_*'] } }));
-    const envDump = join(home, 'child-env.txt');
-    const stdinDump = join(home, 'child-stdin.json');
-    const script = join(home, 'action.sh');
-    writeFileSync(script, `#!/bin/sh\nenv > ${envDump}\ncat > ${stdinDump}\n`);
-    chmodSync(script, 0o755);
-    process.env['HOME'] = home; // no real user-scope config contributes to the boundary
-    process.env['NL_CORE_URL'] = 'http://core.test';
-    process.env['CRTRD_ONLY_SECRET'] = 'must-not-cross';
-    const requestId = 'b'.repeat(64);
-    try {
-        enqueueAction(requestId, [script], project, { schema: 'crtr.human-completion/v1', requestId, delivery: { attempt: 0 } });
-        const delivery = actionDelivery(requestId);
-        assert.ok(delivery !== null);
-        const claimed = claimExternalActionDelivery(delivery.deliveryId, Date.now(), 'claimant');
-        assert.ok(claimed !== null);
-        await deliverAction(claimed.deliveryId, [script], project, { schema: 'crtr.human-completion/v1', requestId, delivery: { attempt: 0 } }, claimed.attempts, 'claimant');
-    }
-    finally {
-        delete process.env['NL_CORE_URL'];
-        delete process.env['CRTRD_ONLY_SECRET'];
-        if (priorUserHome === undefined)
-            delete process.env['HOME'];
-        else
-            process.env['HOME'] = priorUserHome;
-    }
-    assert.equal(actionDelivery(requestId)?.state, 'acknowledged');
-    const childEnv = new Map(readFileSync(envDump, 'utf8').split('\n').flatMap((line) => {
-        const split = line.indexOf('=');
-        return split === -1 ? [] : [[line.slice(0, split), line.slice(split + 1)]];
-    }));
-    assert.equal(childEnv.get('CRTRD_ONLY_SECRET'), undefined, 'crtrd host state must not cross without consent');
-    assert.equal(childEnv.get('NL_CORE_URL'), 'http://core.test', 'the target cwd\'s spawnEnv.allow carries its own config across');
-    assert.equal(childEnv.get('CRTR_HOME'), home, 'an action that calls crtr must reach the daemon that delivered to it');
-    assert.equal(JSON.parse(readFileSync(stdinDump, 'utf8')).delivery.attempt, 1);
-});
-test('the guarded claim admits only one contender', () => {
-    const requestId = 'a'.repeat(64);
-    enqueueAction(requestId, ['/bin/true'], home, { schema: 'crtr.human-completion/v1', delivery: { attempt: 0 } });
-    const now = Date.now();
-    const delivery = actionDelivery(requestId);
-    assert.ok(delivery !== null);
-    const first = claimExternalActionDelivery(delivery.deliveryId, now, 'claimant-a');
-    const second = claimExternalActionDelivery(delivery.deliveryId, now, 'claimant-b');
-    assert.equal(first?.state, 'handed_off');
-    assert.equal(first?.attempts, 1);
-    assert.equal(second, null);
-    assert.deepEqual(actionDelivery(requestId) && {
-        state: actionDelivery(requestId).state,
-        attempt: actionDelivery(requestId).attempts,
-        claimOwner: actionDelivery(requestId).claimOwner,
-    }, { state: 'handed_off', attempt: 1, claimOwner: 'claimant-a' });
-});

package/dist/core/__tests__/human-actions.test.d.ts

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

package/dist/core/__tests__/human-actions.test.js

@@ -1,120 +0,0 @@
-// Run with: node --conditions=crtr-src --import tsx/esm --test src/core/__tests__/human-actions.test.ts
-//
-// This pins the silent execution boundary: a request must select the nearest
-// project declaration before farther projects or user scope, and its relative
-// executable/cwd must resolve from that declaration's authoring root.
-import { after, afterEach, before, beforeEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { ensureScopeInitialized, writeRawConfig } from '../config.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { resolveHumanAction } from '../human-actions.js';
-import { createProfile } from '../profiles/manifest.js';
-import { resetScopeCache } from '../scope.js';
-let home;
-let cwd;
-let previousHome;
-let previousProfile;
-let previousCwd;
-before(() => {
-    previousHome = process.env['HOME'];
-    previousProfile = process.env['CRTR_PROFILE_ID'];
-    previousCwd = process.cwd();
-});
-beforeEach(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-human-actions-home-'));
-    cwd = join(home, 'work', 'outer', 'nested', 'src');
-    mkdirSync(cwd, { recursive: true });
-    process.env['HOME'] = home;
-    delete process.env['CRTR_PROFILE_ID'];
-    process.chdir(cwd);
-    resetScopeCache();
-    ensureScopeInitialized('user', join(home, '.crouter'));
-});
-afterEach(() => {
-    process.chdir(previousCwd);
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    resetScopeCache();
-});
-after(() => {
-    closeScopedStores();
-    process.chdir(previousCwd);
-    if (previousHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = previousHome;
-    if (previousProfile === undefined)
-        delete process.env['CRTR_PROFILE_ID'];
-    else
-        process.env['CRTR_PROFILE_ID'] = previousProfile;
-    resetScopeCache();
-});
-function writeAction(root, relativeExecutable, relativeCwd) {
-    const executable = join(root, relativeExecutable);
-    mkdirSync(join(executable, '..'), { recursive: true });
-    writeFileSync(executable, '');
-    chmodSync(executable, 0o755);
-    mkdirSync(join(root, relativeCwd), { recursive: true });
-}
-test('nearest project declaration wins and resolves paths from its authoring root', () => {
-    const userRoot = join(home, '.crouter');
-    writeAction(userRoot, 'user-bin', 'user-cwd');
-    writeRawConfig('user', {
-        humanActions: { release: { argv: ['user-bin'], cwd: 'user-cwd' }, 'user-only': { argv: ['user-bin'], cwd: 'user-cwd' } },
-    });
-    const outer = join(home, 'work', 'outer');
-    writeAction(outer, 'outer-bin', 'outer-cwd');
-    mkdirSync(join(outer, '.crouter'), { recursive: true });
-    writeFileSync(join(outer, '.crouter', 'config.json'), JSON.stringify({
-        humanActions: { release: { argv: ['outer-bin'], cwd: 'outer-cwd' } },
-    }));
-    const nearest = join(outer, 'nested');
-    writeAction(nearest, 'scripts/finish-release', 'work');
-    mkdirSync(join(nearest, '.crouter'), { recursive: true });
-    writeFileSync(join(nearest, '.crouter', 'config.json'), JSON.stringify({
-        humanActions: { release: { argv: ['scripts/finish-release', '--nearest'], cwd: 'work' } },
-    }));
-    resetScopeCache();
-    assert.deepEqual(resolveHumanAction('release', cwd), {
-        name: 'release',
-        configOrigin: join(nearest, '.crouter', 'config.json'),
-        argv: [join(nearest, 'scripts/finish-release'), '--nearest'],
-        cwd: join(nearest, 'work'),
-    });
-    assert.deepEqual(resolveHumanAction('user-only', cwd), {
-        name: 'user-only',
-        configOrigin: join(userRoot, 'config.json'),
-        argv: [join(userRoot, 'user-bin')],
-        cwd: join(userRoot, 'user-cwd'),
-    });
-    const profileProject = join(home, 'profile-project');
-    writeAction(profileProject, 'profile-bin', 'profile-cwd');
-    mkdirSync(join(profileProject, '.crouter'), { recursive: true });
-    writeFileSync(join(profileProject, '.crouter', 'config.json'), JSON.stringify({
-        humanActions: { 'profile-only': { argv: ['profile-bin'], cwd: 'profile-cwd' } },
-    }));
-    process.env['CRTR_PROFILE_ID'] = createProfile('human-actions-test', [{ path: profileProject, memory: 'content' }]).profileId;
-    resetScopeCache();
-    assert.deepEqual(resolveHumanAction('profile-only', cwd), { kind: 'unknown_action', name: 'profile-only' });
-});
-test('a malformed nearer humanActions block does not shadow a farther declaration', () => {
-    const outer = join(home, 'work', 'outer');
-    writeAction(outer, 'outer-bin', 'outer-cwd');
-    mkdirSync(join(outer, '.crouter'), { recursive: true });
-    writeFileSync(join(outer, '.crouter', 'config.json'), JSON.stringify({
-        humanActions: { release: { argv: ['outer-bin'], cwd: 'outer-cwd' } },
-    }));
-    const nearest = join(outer, 'nested');
-    mkdirSync(join(nearest, '.crouter'), { recursive: true });
-    writeFileSync(join(nearest, '.crouter', 'config.json'), JSON.stringify({ humanActions: [] }));
-    resetScopeCache();
-    assert.deepEqual(resolveHumanAction('release', cwd), {
-        name: 'release',
-        configOrigin: join(outer, '.crouter', 'config.json'),
-        argv: [join(outer, 'outer-bin')],
-        cwd: join(outer, 'outer-cwd'),
-    });
-});

package/dist/core/__tests__/inline-memory-refs.test.d.ts

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