@north-light/crouter 0.3.317 → 0.3.319

package/dist/daemon/__tests__/daemon-ownership.test.js

@@ -1,27 +0,0 @@
-// Regression (issue #518): `crtr sys daemon stop` under an isolated
-// CRTR_HOME/HOME ran a machine-wide `sweepStrayDaemons()` — findDaemonPids()
-// matched every `daemon/crtrd` process on the host with zero scoping to the
-// invoking process's own canvas home — so it SIGTERM/SIGKILL'd a real,
-// unrelated daemon elsewhere on the same machine. Ownership is now DECLARED
-// at spawn — `crtrd-cli.js --canvas-home <home>` (spawnDaemon) — and the
-// stray scan matches exactly the invoking process's own canvas home;
-// untagged or foreign-home daemons are invisible to it. Mirrors the sibling
-// broker-ownership fix (daemon/__tests__/broker-ownership.test.ts).
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { daemonCommandDeclaresCanvasHome } from '../manage.js';
-const HOME = '/Users/u/.crouter/canvas';
-const CMD = `1234 /Users/u/.crouter/host/crouter /Users/u/.crouter/runtime/generations/abc/dist/daemon/crtrd-cli.js --canvas-home ${HOME}`;
-test('matches a daemon declaring this canvas home', () => {
-    assert.equal(daemonCommandDeclaresCanvasHome(CMD, HOME), true);
-});
-test('rejects a daemon declaring a different canvas home', () => {
-    assert.equal(daemonCommandDeclaresCanvasHome(CMD, '/tmp/crtr-test-xyz/canvas'), false);
-});
-test('rejects an untagged (pre-tag or externally-launched, e.g. launchd) daemon', () => {
-    const untagged = '1234 node /repo/dist/daemon/crtrd-cli.js';
-    assert.equal(daemonCommandDeclaresCanvasHome(untagged, HOME), false);
-});
-test('rejects a home that is a prefix of the declared home', () => {
-    assert.equal(daemonCommandDeclaresCanvasHome(CMD, '/Users/u'), false);
-});

package/dist/daemon/__tests__/helpers/source-daemon.d.ts

@@ -1,30 +0,0 @@
-import { type ChildProcess } from 'node:child_process';
-export interface SourceDaemonFixture {
-    root: string;
-    home: string;
-    cwd: string;
-    canvasHome: string;
-    pidfile: string;
-    socket: string;
-    tcpPort: number;
-    dispose(): void;
-}
-export interface SourceDaemonProcess {
-    child: ChildProcess;
-    exited: Promise<{
-        code: number | null;
-        signal: NodeJS.Signals | null;
-    }>;
-    stdout(): string;
-    stderr(): string;
-    stop(): Promise<{
-        code: number | null;
-        signal: NodeJS.Signals | null;
-    }>;
-}
-export declare function createSourceDaemonFixture(opts?: Partial<Pick<SourceDaemonFixture, 'root' | 'home' | 'cwd' | 'canvasHome'>>): Promise<SourceDaemonFixture>;
-export declare function startSourceDaemon(fixture: SourceDaemonFixture, envOverrides?: NodeJS.ProcessEnv): SourceDaemonProcess;
-export declare function healthRequest(port: number, timeoutMs?: number): Promise<boolean>;
-export declare function waitForHealth(process: SourceDaemonProcess, port: number, timeoutMs?: number): Promise<void>;
-export declare function healthWasReadyBeforeExit(process: SourceDaemonProcess, port: number): Promise<boolean>;
-export declare function brokerPidsForCanvas(canvasHome: string): number[];

package/dist/daemon/__tests__/helpers/source-daemon.js

@@ -1,176 +0,0 @@
-import { spawn, execFileSync } from 'node:child_process';
-import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
-import { createServer } from 'node:net';
-import { request } from 'node:http';
-import { join } from 'node:path';
-import { createRequire } from 'node:module';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function reserveTcpPort() {
-    const server = createServer();
-    await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(0, '127.0.0.1', resolve);
-    });
-    const address = server.address();
-    if (address === null || typeof address === 'string')
-        throw new Error('test TCP listener did not receive a port');
-    await new Promise((resolve, reject) => server.close((error) => error === undefined ? resolve() : reject(error)));
-    return address.port;
-}
-export async function createSourceDaemonFixture(opts = {}) {
-    const root = opts.root ?? mkdtempSync('/tmp/crtr-migration-daemon-');
-    const home = opts.home ?? join(root, 'home');
-    const cwd = opts.cwd ?? join(home, 'work');
-    const canvasHome = opts.canvasHome ?? join(root, 'canvas');
-    const pidfile = join(canvasHome, 'ready.pid');
-    const socket = join(canvasHome, 'crtrd.sock');
-    mkdirSync(cwd, { recursive: true });
-    mkdirSync(canvasHome, { recursive: true });
-    const tcpPort = await reserveTcpPort();
-    return {
-        root,
-        home,
-        cwd,
-        canvasHome,
-        pidfile,
-        socket,
-        tcpPort,
-        dispose: () => rmSync(root, { recursive: true, force: true }),
-    };
-}
-export function startSourceDaemon(fixture, envOverrides = {}) {
-    const require = createRequire(import.meta.url);
-    const tsxLoader = pathToFileURL(require.resolve('tsx/esm')).href;
-    const entry = fileURLToPath(new URL('../../crtrd-cli.ts', import.meta.url));
-    const env = {
-        ...process.env,
-        HOME: fixture.home,
-        CRTR_HOME: fixture.canvasHome,
-        CRTR_PIDFILE: fixture.pidfile,
-        CRTRD_TCP: `127.0.0.1:${fixture.tcpPort}`,
-        XDG_CACHE_HOME: join(fixture.root, 'cache'),
-        XDG_CONFIG_HOME: join(fixture.root, 'config'),
-        XDG_DATA_HOME: join(fixture.root, 'data'),
-    };
-    for (const key of [
-        'CRTR_NODE_ID',
-        'CRTR_SUBTREE',
-        'CRTR_KIND',
-        'CRTR_MODE',
-        'CRTR_LIFECYCLE',
-        'CRTR_NODE_CWD',
-        'CRTR_CONTEXT_DIR',
-        'CRTR_CYCLES',
-        'CRTR_PROFILE_ID',
-        'CRTR_PARENT_NODE_ID',
-        'CRTR_FRONT_DOOR',
-        'CRTR_BROKER_ENGINE',
-        'CRTR_PI_BINARY',
-        'NODE_OPTIONS',
-    ])
-        delete env[key];
-    Object.assign(env, envOverrides);
-    const child = spawn(process.execPath, [
-        '--conditions=crtr-src',
-        '--import', tsxLoader,
-        entry,
-        '--canvas-home', fixture.canvasHome,
-    ], {
-        cwd: fixture.cwd,
-        env,
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    let stdout = '';
-    let stderr = '';
-    child.stdout.setEncoding('utf8');
-    child.stderr.setEncoding('utf8');
-    child.stdout.on('data', (chunk) => { stdout += chunk; });
-    child.stderr.on('data', (chunk) => { stderr += chunk; });
-    const exited = new Promise((resolve, reject) => {
-        child.once('error', reject);
-        child.once('close', (code, signal) => resolve({ code, signal }));
-    });
-    return {
-        child,
-        exited,
-        stdout: () => stdout,
-        stderr: () => stderr,
-        stop: async () => {
-            if (child.exitCode === null && child.signalCode === null)
-                child.kill('SIGTERM');
-            const timeout = setTimeout(() => {
-                if (child.exitCode === null && child.signalCode === null)
-                    child.kill('SIGKILL');
-            }, 10_000);
-            try {
-                return await exited;
-            }
-            finally {
-                clearTimeout(timeout);
-            }
-        },
-    };
-}
-export function healthRequest(port, timeoutMs = 200) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const finish = (ready) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve(ready);
-        };
-        const req = request({ host: '127.0.0.1', port, path: '/healthz', method: 'GET', agent: false }, (response) => {
-            response.resume();
-            response.once('end', () => finish(response.statusCode === 200));
-        });
-        req.once('error', () => finish(false));
-        req.setTimeout(timeoutMs, () => {
-            req.destroy();
-            finish(false);
-        });
-        req.end();
-    });
-}
-export async function waitForHealth(process, port, timeoutMs = 20_000) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (await healthRequest(port))
-            return;
-        if (process.child.exitCode !== null || process.child.signalCode !== null) {
-            const result = await process.exited;
-            throw new Error(`source daemon exited before health readiness (${JSON.stringify(result)}):\n${process.stderr()}`);
-        }
-        await delay(10);
-    }
-    throw new Error(`source daemon did not answer /healthz within ${timeoutMs}ms:\n${process.stderr()}`);
-}
-export async function healthWasReadyBeforeExit(process, port) {
-    let exited = false;
-    void process.exited.then(() => { exited = true; });
-    while (!exited) {
-        if (await healthRequest(port, 50))
-            return true;
-        await delay(2);
-    }
-    return false;
-}
-export function brokerPidsForCanvas(canvasHome) {
-    let table;
-    try {
-        table = execFileSync('ps', ['-ax', '-o', 'pid=,command='], { encoding: 'utf8', timeout: 2_000 });
-    }
-    catch {
-        return [];
-    }
-    const declaration = `--canvas-home ${canvasHome}`;
-    return table.split('\n').flatMap((line) => {
-        if (!line.includes('broker-cli') || !line.includes(declaration))
-            return [];
-        const pid = Number.parseInt(line.trim().split(/\s+/, 1)[0] ?? '', 10);
-        return Number.isInteger(pid) ? [pid] : [];
-    });
-}

package/dist/daemon/__tests__/integration/api-startup-readiness.test.d.ts

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

package/dist/daemon/__tests__/integration/api-startup-readiness.test.js

@@ -1,83 +0,0 @@
-// Regression for NL-159 / #571: the daemon's pidfile/ownership claim must not
-// survive a failed mandatory Unix API bind. A directory at the socket path
-// deterministically makes `listen()` emit EADDRINUSE without touching crtrd's
-// real canvas or runtime homes.
-import assert from 'node:assert/strict';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import test from 'node:test';
-import { closeDb } from '../../../core/canvas/db.js';
-import { claimDaemonOwnership, releaseDaemonOwnership } from '../../../core/canvas/daemon-owner.js';
-import { resetEventSourceForTests } from '../../../core/events/source.js';
-import { resetFleetForTests } from '../../../core/runtime/fleet.js';
-import { runDaemon } from '../../crtrd.js';
-import { spawnDaemon } from '../../manage.js';
-const isolatedEnvKeys = [
-    'HOME',
-    'CRTR_HOME',
-    'CRTR_PIDFILE',
-    'CRTR_RUNTIME_HOME',
-    'XDG_CACHE_HOME',
-    'XDG_CONFIG_HOME',
-    'XDG_DATA_HOME',
-    'PI_CODING_AGENT_DIR',
-];
-test('a Unix socket bind failure rejects readiness and releases daemon ownership', async () => {
-    const root = mkdtempSync('/tmp/crtr-api-bind-failure-');
-    const home = join(root, 'home');
-    const canvasHome = join(root, 'canvas');
-    const socketPath = join(canvasHome, 'crtrd.sock');
-    const previousCwd = process.cwd();
-    const previousEnv = new Map(isolatedEnvKeys.map((key) => [key, process.env[key]]));
-    mkdirSync(home, { recursive: true });
-    mkdirSync(socketPath, { recursive: true });
-    try {
-        process.chdir(home);
-        process.env['HOME'] = home;
-        process.env['CRTR_HOME'] = canvasHome;
-        process.env['CRTR_PIDFILE'] = join(canvasHome, 'crtrd.pid');
-        process.env['CRTR_RUNTIME_HOME'] = join(root, 'runtime');
-        process.env['XDG_CACHE_HOME'] = join(root, 'cache');
-        process.env['XDG_CONFIG_HOME'] = join(root, 'config');
-        process.env['XDG_DATA_HOME'] = join(root, 'data');
-        process.env['PI_CODING_AGENT_DIR'] = join(home, '.pi', 'agent');
-        closeDb();
-        resetEventSourceForTests();
-        resetFleetForTests();
-        await assert.rejects(() => runDaemon(), (error) => error.code === 'EADDRINUSE', 'the mandatory API socket bind must reject startup');
-        const pidfile = process.env['CRTR_PIDFILE'];
-        assert.equal(existsSync(pidfile), false, 'failed readiness removes the pidfile mirror');
-        assert.equal(existsSync(socketPath), true, 'the pre-existing directory was never mistaken for a serving socket');
-        assert.match(readFileSync(join(canvasHome, 'crtrd.log'), 'utf8'), /api\.server\.failed/, 'the bind failure is recorded for cold-start diagnostics');
-        rmSync(socketPath, { recursive: true, force: true });
-        writeFileSync(pidfile, String(process.pid));
-        try {
-            const result = await spawnDaemon();
-            assert.deepEqual({ started: result.started, existing_pid: result.existing_pid, running: result.running, serving: result.serving }, { started: false, existing_pid: process.pid, running: true, serving: false }, 'a live owner with an unavailable socket remains in place');
-            assert.match(result.probe_error ?? '', /ENOENT|ECONNREFUSED/, 'the result retains the actual failed probe');
-            process.kill(process.pid, 0);
-        }
-        finally {
-            rmSync(pidfile, { force: true });
-        }
-        const retryClaim = claimDaemonOwnership('post-api-bind-failure');
-        assert.equal(retryClaim.claimed, true, 'failed readiness releases the authoritative ownership claim');
-        if (retryClaim.claimed) {
-            assert.equal(releaseDaemonOwnership(retryClaim.claim).released, true, 'the test-only retry claim releases cleanly');
-        }
-    }
-    finally {
-        closeDb();
-        resetEventSourceForTests();
-        resetFleetForTests();
-        process.chdir(previousCwd);
-        for (const key of isolatedEnvKeys) {
-            const previous = previousEnv.get(key);
-            if (previous === undefined)
-                delete process.env[key];
-            else
-                process.env[key] = previous;
-        }
-        rmSync(root, { recursive: true, force: true });
-    }
-});

package/dist/daemon/__tests__/integration/migration-startup.test.d.ts

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

package/dist/daemon/__tests__/integration/migration-startup.test.js

@@ -1,127 +0,0 @@
-import assert from 'node:assert/strict';
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import test from 'node:test';
-import { onDiskMigrationIdentity } from '../../../migrations/registry.js';
-import { brokerPidsForCanvas, createSourceDaemonFixture, startSourceDaemon, waitForHealth, } from '../helpers/source-daemon.js';
-const PRE_MIGRATION_DOC = `---
-kind: knowledge
-name: daemon-ordering
-system-prompt-visibility: preview
-file-read-visibility: content
-applies-to:
-  - "**/*.ts"
-read-when:
-  language: typescript
----
-# Daemon ordering
-
-This document begins in the pre-surfaces schema.
-`;
-function writeUserMemory(home, name, source) {
-    const path = join(home, '.crouter', 'memory', name);
-    mkdirSync(join(home, '.crouter', 'memory'), { recursive: true });
-    writeFileSync(path, source, 'utf8');
-    return path;
-}
-async function requestJson(port, path, init = {}) {
-    const response = await fetch(`http://127.0.0.1:${port}${path}`, init);
-    return { status: response.status, body: await response.json() };
-}
-test('source daemon migrates the pre-migration corpus before full readiness', { timeout: 30_000 }, async () => {
-    const fixture = await createSourceDaemonFixture();
-    const docPath = writeUserMemory(fixture.home, 'daemon-ordering.md', PRE_MIGRATION_DOC);
-    const markerPath = join(fixture.canvasHome, 'on-disk-migrations.json');
-    const dbPath = join(fixture.canvasHome, 'canvas.db');
-    assert.equal(existsSync(markerPath), false, 'fixture starts without a migration marker');
-    assert.equal(existsSync(dbPath), false, 'fixture starts without canvas.db');
-    assert.match(readFileSync(docPath, 'utf8'), /system-prompt-visibility:/, 'fixture is genuinely pre-migration');
-    const daemon = startSourceDaemon(fixture);
-    try {
-        const markerDeadline = Date.now() + 20_000;
-        while (!existsSync(markerPath) && Date.now() < markerDeadline) {
-            await new Promise((resolve) => setTimeout(resolve, 1));
-        }
-        assert.equal(existsSync(markerPath), true, `marker was not written; stderr:\n${daemon.stderr()}`);
-        const migratedAtMarker = readFileSync(docPath, 'utf8');
-        assert.doesNotMatch(migratedAtMarker, /system-prompt-visibility:|file-read-visibility:|applies-to:|read-when:/);
-        assert.equal(existsSync(fixture.pidfile), true, 'the live owner mirror is published at the restricted repair boundary');
-        assert.equal(existsSync(fixture.socket), true, 'the repair listener is bound before corpus activation completes');
-        await waitForHealth(daemon, fixture.tcpPort);
-        const migrated = readFileSync(docPath, 'utf8');
-        assert.doesNotMatch(migrated, /system-prompt-visibility:|file-read-visibility:|applies-to:|read-when:/);
-        assert.match(migrated, /surfaces:/);
-        assert.match(migrated, /on: boot/);
-        assert.match(migrated, /on: read/);
-        assert.deepEqual(JSON.parse(readFileSync(markerPath, 'utf8')), onDiskMigrationIdentity());
-        assert.equal(existsSync(fixture.pidfile), true, 'health readiness follows the pidfile readiness mirror');
-        assert.equal(existsSync(fixture.socket), true, 'the unique unix API listener is bound at readiness');
-        assert.equal(existsSync(dbPath), true, 'daemon ownership has opened canvas.db by readiness');
-        assert.ok(statSync(fixture.pidfile).mtimeMs <= statSync(markerPath).mtimeMs, 'the pidfile is written before the completion marker');
-        assert.ok(statSync(fixture.socket).mtimeMs <= statSync(markerPath).mtimeMs, 'the repair listener is bound before the completion marker');
-    }
-    finally {
-        const exit = await daemon.stop();
-        fixture.dispose();
-        assert.deepEqual(exit, { code: 0, signal: null }, `daemon must stop cleanly; stderr:\n${daemon.stderr()}`);
-    }
-});
-test('a real migration blocker keeps a restricted daemon alive for repair', { timeout: 30_000 }, async () => {
-    const fixture = await createSourceDaemonFixture();
-    const blockerPath = writeUserMemory(fixture.home, 'blocked.md', `---\nkind: knowledge\nbroken: [\n---\n# Blocked\n`);
-    const daemon = startSourceDaemon(fixture);
-    try {
-        const deadline = Date.now() + 20_000;
-        let health;
-        while (Date.now() < deadline) {
-            try {
-                const response = await requestJson(fixture.tcpPort, '/healthz');
-                if (response.status === 503) {
-                    health = response;
-                    break;
-                }
-            }
-            catch {
-                // The repair listener has not bound yet.
-            }
-            await new Promise((resolve) => setTimeout(resolve, 10));
-        }
-        assert.ok(health, `source daemon did not reach restricted startup:\n${daemon.stderr()}`);
-        assert.equal(daemon.child.exitCode, null, `blocker must keep daemon alive; stderr:\n${daemon.stderr()}`);
-        assert.deepEqual(health.body, {
-            ok: false,
-            daemon_up: true,
-            store_accessible: true,
-            brokers_reconciled: false,
-            startup_phase: 'blocked',
-            startup_blocked: health.body.startup_blocked,
-        });
-        assert.match(health.body.startup_blocked, new RegExp(blockerPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-        assert.match(health.body.startup_blocked, /Repair: crtr sys migrate/);
-        const status = await requestJson(fixture.tcpPort, '/v1/status');
-        assert.equal(status.status, 200, 'restricted startup keeps daemon status diagnostic available');
-        const refused = await requestJson(fixture.tcpPort, '/v1/nodes', { method: 'POST', body: '{}' });
-        assert.equal(refused.status, 503, 'normal node creation is refused during restricted startup');
-        assert.deepEqual(refused.body, {
-            error: { code: 'startup_blocked', message: health.body.startup_blocked },
-        });
-        const repair = await requestJson(fixture.tcpPort, '/v1/daemon/migrate', {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ dry_run: true }),
-        });
-        assert.equal(repair.status, 200, 'the restricted daemon serves a repair preview');
-        assert.equal(repair.body.blocked, true);
-        assert.equal(repair.body.dryRun, true);
-        assert.equal(repair.body.resumed, false);
-        assert.equal(existsSync(fixture.pidfile), true, 'the live owner mirror remains while startup is blocked');
-        assert.equal(existsSync(fixture.socket), true, 'the repair socket remains while startup is blocked');
-        assert.equal(existsSync(join(fixture.canvasHome, 'on-disk-migrations.json')), false, 'blocker never gets a completion marker');
-        assert.deepEqual(brokerPidsForCanvas(fixture.canvasHome), [], 'no broker process declares the isolated canvas');
-    }
-    finally {
-        const exit = await daemon.stop();
-        fixture.dispose();
-        assert.deepEqual(exit, { code: 0, signal: null }, `daemon must stop cleanly; stderr:\n${daemon.stderr()}`);
-    }
-});

package/dist/daemon/__tests__/node-deadline-lane.test.d.ts

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

package/dist/daemon/__tests__/node-deadline-lane.test.js

@@ -1,77 +0,0 @@
-import { after, afterEach, beforeEach, test } 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 { closeDb, migrate, openDb } from '../../core/canvas/db.js';
-import { createNode, dueNodeDeadlines, getRow } from '../../core/canvas/canvas.js';
-import { pushFinal } from '../../core/feed/feed.js';
-import { transition } from '../../core/runtime/lifecycle.js';
-import { NodeDeadlineReconciler } from '../reconcilers/node-deadline.js';
-let home;
-const priorHome = process.env['CRTR_HOME'];
-const now = Date.parse('2026-08-31T00:00:10.000Z');
-const pastDeadline = '2026-08-31T00:00:00.000Z';
-const futureDeadline = '2026-08-31T00:01:00.000Z';
-function node(nodeId, opts = {}) {
-    return {
-        node_id: nodeId,
-        name: nodeId,
-        created: new Date(now - 1_000).toISOString(),
-        cwd: home,
-        kind: opts.kind ?? 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: opts.status ?? 'active',
-        deadline_at: opts.deadlineAt ?? null,
-    };
-}
-beforeEach(() => {
-    closeDb();
-    home = mkdtempSync(join(tmpdir(), 'crtr-node-deadline-'));
-    process.env['CRTR_HOME'] = home;
-    migrate(openDb());
-});
-afterEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    if (priorHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = priorHome;
-});
-test('due node deadlines select only live, non-human, un-outcomed past-due rows', () => {
-    createNode(node('active-due', { deadlineAt: pastDeadline }));
-    createNode(node('idle-due', { status: 'idle', deadlineAt: pastDeadline }));
-    createNode(node('human-due', { kind: 'human', deadlineAt: pastDeadline }));
-    createNode(node('future', { deadlineAt: futureDeadline }));
-    createNode(node('outcomed', { deadlineAt: pastDeadline }));
-    transition('outcomed', 'crash');
-    transition('outcomed', 'revive');
-    createNode(node('done', { status: 'done', deadlineAt: pastDeadline }));
-    assert.deepEqual(dueNodeDeadlines(new Date(now).toISOString()).map((row) => row.node_id), ['active-due', 'idle-due']);
-});
-test('expiry commits cancellation and outcome before its asynchronous teardown request', async () => {
-    createNode(node('expired', { deadlineAt: pastDeadline }));
-    new NodeDeadlineReconciler().run(now);
-    const expired = getRow('expired');
-    assert.deepEqual({ status: expired.status, reason: expired.outcome_reason, kind: expired.outcome_kind }, {
-        status: 'canceled', reason: 'deadline_exceeded', kind: 'failure',
-    });
-    assert.equal(expired.outcome_at === null, false, 'the durable outcome is committed before the queued teardown can run');
-    await new Promise((resolve) => setImmediate(resolve));
-});
-test('a canonical final that wins after deadline selection is not overwritten', async () => {
-    createNode(node('finalized', { deadlineAt: pastDeadline }));
-    const staleCandidate = dueNodeDeadlines(new Date(now).toISOString()).find((row) => row.node_id === 'finalized');
-    assert.ok(staleCandidate, 'the row was eligible when the deadline lane selected it');
-    await pushFinal('finalized', 'finished before the deadline cancellation committed');
-    new NodeDeadlineReconciler().expire(staleCandidate, now);
-    const finalized = getRow('finalized');
-    assert.deepEqual({ status: finalized.status, reason: finalized.outcome_reason, kind: finalized.outcome_kind }, {
-        status: 'done', reason: 'finalized', kind: 'result',
-    });
-});

package/dist/daemon/__tests__/node-outcome-birth-invariants.test.d.ts

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