@north-light/crouter 0.3.301 → 0.3.303

package/dist/core/substrate/surface-match.js

@@ -10,6 +10,7 @@
 // container (its owning repo dir for `read`, its canonical routing anchor for
 // `memory-read`).
 import { basename, isAbsolute, matchesGlob, relative, sep } from 'node:path';
+import { commandSegments, stripHeredocs } from '../shell-segments.js';
 import { CRTR_DIR_NAME } from '../../types.js';
 import { realpathOrSelf } from '../fs-utils.js';
 import { evalCondition } from '../predicate.js';
@@ -102,129 +103,6 @@ export function matchesMemoryReadEntry(entry, routingAnchor, subject, name) {
         return false;
     return entry.match.some((g) => memoryReadGlobMatches(g, routingAnchor, name));
 }
-/** Split a command into shell segments on unquoted `;`, newline, `&&`, `||`,
- *  and `|`. A single `&`, subshell parentheses, and backticks are left inside
- *  their segment — this is a best-effort guardrail, not a shell parser.
- *  Heredoc bodies are a separate pre-match concern (see `stripHeredocs`). */
-function splitCommandSegments(command) {
-    const segments = [];
-    let current = '';
-    let quote = null;
-    let escaped = false;
-    const finish = () => {
-        segments.push(current);
-        current = '';
-    };
-    for (let i = 0; i < command.length; i += 1) {
-        const ch = command[i];
-        if (escaped) {
-            current += ch;
-            escaped = false;
-            continue;
-        }
-        if (ch === '\\' && quote !== "'") {
-            current += ch;
-            escaped = true;
-            continue;
-        }
-        if (quote !== null) {
-            current += ch;
-            if (ch === quote)
-                quote = null;
-            continue;
-        }
-        if (ch === "'" || ch === '"') {
-            current += ch;
-            quote = ch;
-            continue;
-        }
-        if (ch === '\n' || ch === ';') {
-            finish();
-            continue;
-        }
-        if ((ch === '&' || ch === '|') && command[i + 1] === ch) {
-            finish();
-            i += 1;
-            continue;
-        }
-        if (ch === '|') {
-            finish();
-            continue;
-        }
-        current += ch;
-    }
-    finish();
-    return segments;
-}
-/** Tokenize one segment into shell words, marking quoted spans opaque. */
-function tokenizeCommandSegment(segment) {
-    const tokens = [];
-    let text = '';
-    let opaque = false;
-    let started = false;
-    let quote = null;
-    let escaped = false;
-    const finish = () => {
-        if (started)
-            tokens.push({ text, opaque });
-        text = '';
-        opaque = false;
-        started = false;
-    };
-    for (let i = 0; i < segment.length; i += 1) {
-        const ch = segment[i];
-        if (escaped) {
-            text += ch;
-            started = true;
-            escaped = false;
-            continue;
-        }
-        if (ch === '\\' && quote !== "'") {
-            escaped = true;
-            started = true;
-            continue;
-        }
-        if (quote !== null) {
-            started = true;
-            if (ch === quote) {
-                quote = null;
-            }
-            else {
-                text += ch;
-            }
-            continue;
-        }
-        if (ch === "'" || ch === '"') {
-            quote = ch;
-            opaque = true;
-            started = true;
-            continue;
-        }
-        if (/\s/.test(ch)) {
-            finish();
-            continue;
-        }
-        text += ch;
-        started = true;
-    }
-    if (escaped)
-        text += '\\';
-    finish();
-    return tokens;
-}
-/** Every non-empty command segment as its env-stripped token list: leading
- *  `VAR=value` assignments are dropped so `tokens[0]` is the executable. */
-function commandSegments(command) {
-    return splitCommandSegments(command)
-        .map(tokenizeCommandSegment)
-        .map((tokens) => {
-        let first = 0;
-        while (first < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[first].text))
-            first += 1;
-        return tokens.slice(first);
-    })
-        .filter((tokens) => tokens.length > 0);
-}
 function commandGlobPattern(glob) {
     const words = glob.trim().split(/\s+/);
     if (words.length === 1 && words[0] === '')
@@ -275,7 +153,9 @@ function commandGlobMatches(glob, command) {
     const pattern = commandGlobPattern(glob);
     if (pattern === null)
         return false;
-    return commandSegments(command).some((tokens) => segmentMatches(pattern, tokens));
+    return commandSegments(command)
+        .filter(({ tokens }) => tokens.length > 0)
+        .some(({ tokens }) => segmentMatches(pattern, tokens));
 }
 /** Does a `command` entry fit the executed command string? */
 export function matchesCommandEntry(entry, subject, command) {
@@ -283,42 +163,6 @@ export function matchesCommandEntry(entry, subject, command) {
         return false;
     return entry.match.some((g) => commandGlobMatches(g, command));
 }
-const HEREDOC_OPEN = /<<(-?)\s*(["']?)([A-Za-z_][A-Za-z0-9_]*)\2/g;
-/** Remove heredoc BODIES (the stdin data between `<<DELIM` and its closing
- *  `DELIM` line) from a command before it is matched. The opening line is kept
- *  — `crtr push final <<'EOF'` is still a real `push final` invocation — but the
- *  body lines, which are data fed on stdin and never executed as commands, are
- *  dropped. Without this a doc-writing command whose body merely MENTIONS a
- *  matched invocation would have its whole call held. Post-execution `command`
- *  delivery does not need this (a spurious late injection costs a paragraph);
- *  a `pre-command` block costs the agent a turn, so it does. */
-export function stripHeredocs(command) {
-    const lines = command.split('\n');
-    const out = [];
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        out.push(line);
-        i += 1;
-        // Every heredoc opened on this line, left to right; their bodies stack and
-        // are consumed in that order.
-        const delims = [];
-        HEREDOC_OPEN.lastIndex = 0;
-        let m;
-        while ((m = HEREDOC_OPEN.exec(line)) !== null)
-            delims.push({ name: m[3], dash: m[1] === '-' });
-        for (const d of delims) {
-            while (i < lines.length) {
-                // `<<-` strips leading TABS from the body and the closing delimiter.
-                const probe = d.dash ? lines[i].replace(/^\t+/, '') : lines[i];
-                i += 1;
-                if (probe === d.name)
-                    break; // closing delimiter line — drop it, stop
-            }
-        }
-    }
-    return out.join('\n');
-}
 /** Does a `pre-command` entry fit a command that is ABOUT to run? The same
  *  glob machinery `command` uses — one matcher, one semantics — applied to the
  *  command with its heredoc bodies stripped. Subshell parentheses, backticks,

package/dist/core/worktree.js

@@ -954,12 +954,9 @@ export function autoDropCleanManagedWorktreeLocked(nodeId, wt, proof) {
  *  `open_managed_worktree` guard then still applies unchanged — real
  *  commits, real uncommitted changes, and a lost race all require the
  *  explicit path. */
-function cleanCurrentBranchTip(wt) {
+function cleanCurrentCheckoutTip(wt) {
     if (wt.state !== 'open' || !existsSync(wt.path) || isRebaseInProgress(wt.path))
         return null;
-    const branch = gitSync(['rev-parse', '--abbrev-ref', 'HEAD'], wt.path);
-    if (branch.status !== 0 || branch.stdout.trim() !== wt.branch)
-        return null;
     const status = gitSync(['status', '--porcelain'], wt.path);
     if (status.status !== 0 || status.stdout.trim() !== '')
         return null;
@@ -967,7 +964,7 @@ function cleanCurrentBranchTip(wt) {
     return head.status === 0 ? head.stdout.trim() : null;
 }
 export async function branchIsPushedAtCurrentTip(wt) {
-    const initialTip = cleanCurrentBranchTip(wt);
+    const initialTip = cleanCurrentCheckoutTip(wt);
     if (initialTip === null)
         return false;
     // A cached origin branch can be stale in either direction. Query origin's
@@ -989,7 +986,7 @@ export async function branchIsPushedAtCurrentTip(wt) {
         return false;
     // The remote proof is useful only if the local checkout is still the exact
     // clean tip it inspected when finalization begins.
-    return cleanCurrentBranchTip(wt) === initialTip;
+    return cleanCurrentCheckoutTip(wt) === initialTip;
 }
 export function autoDropCleanManagedWorktree(nodeId) {
     const wt = openManagedWorktreeForNode(nodeId);

package/dist/daemon/api/__tests__/seam/leaf-api-parity.test.js

@@ -29,7 +29,7 @@ import { CrtrClient } from '../../../../api/index.js';
 import { registerPush } from '../../../../commands/push.js';
 import { registerNode } from '../../../../commands/node.js';
 import { createNode, getNode } from '../../../../core/canvas/canvas.js';
-import { createManagedWorktree } from '../../../../core/worktree.js';
+import { branchIsPushedAtCurrentTip, createManagedWorktree } from '../../../../core/worktree.js';
 import { readInboxSince } from '../../../../core/feed/inbox.js';
 import { gitSync } from '../../../../core/git.js';
 import { InputError } from '../../../../core/io.js';
@@ -187,28 +187,38 @@ test('re-homed guard: `crtr push final` on a node with a managed worktree holdin
         rmSync(repo, { recursive: true, force: true });
     }
 });
-test('`crtr push final` concludes a clean managed worktree whose tip exists on origin only under a different branch name (#912)', async () => {
+test('`crtr push final` retains a clean managed worktree checked out on a pushed PR branch (#1109, #1061)', async () => {
     const repo = initRepo();
     const remote = mkdtempSync(join(tmpdir(), 'crtr-leafparity-remote-'));
     try {
         git(['init', '--bare'], remote);
         git(['remote', 'add', 'origin', remote], repo);
         git(['push', '-u', 'origin', 'main'], repo);
-        const id = 'wt-912-differently-named-remote-branch';
+        const id = 'wt-pushed-pr-branch-final';
         const wt = createManagedWorktree(repo, id);
         writeFileSync(join(wt.path, 'delivered-via-pr.txt'), 'delivered via a PR branch\n');
         git(['add', '.'], wt.path);
-        git(['commit', '-m', 'delivered via differently named branch'], wt.path);
+        git(['commit', '-m', 'delivered via PR branch'], wt.path);
         const tip = gitSync(['rev-parse', 'HEAD'], wt.path).stdout.trim();
-        const remoteBranch = 'fix/issue-912-worktree-final';
-        git(['push', 'origin', `HEAD:refs/heads/${remoteBranch}`], wt.path);
-        assert.equal(gitSync(['ls-remote', '--exit-code', '--heads', 'origin', `refs/heads/${wt.branch}`], wt.path).status, 2, 'the recorded crtr branch is absent from origin');
-        assert.equal(gitSync(['ls-remote', '--exit-code', '--heads', 'origin', `refs/heads/${remoteBranch}`], wt.path).stdout.split('\t')[0], tip, 'origin carries the exact tip under the PR branch name');
+        const prBranch = 'fix/pushed-pr-worktree-final';
+        git(['switch', '-c', prBranch], wt.path);
+        git(['push', 'origin', `HEAD:refs/heads/${wt.branch}`], wt.path);
+        git(['push', 'origin', `HEAD:refs/heads/${prBranch}`], wt.path);
+        assert.equal(gitSync(['rev-parse', `refs/heads/${wt.branch}`], wt.path).stdout.trim(), tip, 'the recorded branch remains at the checkout tip');
+        assert.equal(gitSync(['rev-parse', '--abbrev-ref', 'HEAD'], wt.path).stdout.trim(), prBranch, 'the checkout uses the PR branch instead of the recorded branch');
+        assert.equal(gitSync(['ls-remote', '--exit-code', '--heads', 'origin', `refs/heads/${wt.branch}`], wt.path).stdout.split('\t')[0], tip, 'origin carries the recorded branch tip');
+        assert.equal(gitSync(['ls-remote', '--exit-code', '--heads', 'origin', `refs/heads/${prBranch}`], wt.path).stdout.split('\t')[0], tip, 'origin carries the PR branch tip');
+        const untracked = join(wt.path, 'generated.uid');
+        writeFileSync(untracked, 'untracked generated file\n');
+        assert.equal(await branchIsPushedAtCurrentTip(wt), false, 'an untracked file still rejects the origin-retention proof');
+        rmSync(untracked);
         createNode(worktreeNode(id, wt.path, wt));
-        const out = await runPushAs(id, 'final', 'delivered through a differently named PR branch');
+        const out = await runPushAs(id, 'final', 'delivered through a PR branch');
         assert.equal(out['worktree_auto_dropped'], undefined, 'the remote-tip allowance retains the open worktree');
-        assert.equal(getNode(id)?.managed_worktree?.state, 'open', 'the remote-tip allowance does not close the worktree');
-        assert.equal(getNode(id)?.status, 'done', 'the node finalizes when origin carries its exact tip under the PR branch name');
+        assert.equal(getNode(id)?.managed_worktree?.state, 'open', 'the remote-tip allowance does not close the worktree record');
+        assert.equal(getNode(id)?.managed_worktree?.branch, wt.branch, 'the retained record keeps its recorded branch');
+        assert.equal(gitSync(['rev-parse', '--abbrev-ref', 'HEAD'], wt.path).stdout.trim(), prBranch, 'finalization does not change the checked-out PR branch');
+        assert.equal(getNode(id)?.status, 'done', 'the node finalizes when both pushed branches have its exact tip');
     }
     finally {
         rmSync(repo, { recursive: true, force: true });

package/dist/daemon/api/handlers/reports.js

@@ -100,7 +100,7 @@ async function guardFinalWorktree(id) {
     // command-local mapper needed (plan C-5).
     throw new InputError({
         error: 'open_managed_worktree',
-        message: 'This node still owns an open managed worktree — `push final` is blocked until it is closed.',
+        message: 'This node still owns an open managed worktree that is neither clean and locally landed nor clean with its exact tip on origin — `push final` cannot finish.',
         next: (() => {
             const wt = getNode(id)?.managed_worktree;
             return wt !== null && wt !== undefined && wt.state === 'open' && !existsSync(wt.path)

package/dist/daemon/api/map.d.ts

@@ -1,7 +1,7 @@
 import type { ManagedWorktree, NodeMeta, NodeRow, NodeRuntime, SubscriptionRef } from '../../core/canvas/types.js';
 import type { OutcomeDeliveryRecord } from '../../core/canvas/node-outcome-deliveries.js';
 import type { ReviewComment, ReviewCommentEvent, ReviewErrorCode, ReviewRecord, ReviewResult } from '../../core/review/types.js';
-import type { Cron, CronRunRecord } from '../../core/canvas/crons.js';
+import { type Cron, type CronRunRecord } from '../../core/canvas/crons.js';
 import type { ProfileEntry } from '../../core/profiles/manifest.js';
 import type { ReviveResult } from '../../core/runtime/revive.js';
 import type { CloseNodeResult } from '../../core/runtime/close.js';

package/dist/daemon/api/map.js

@@ -12,6 +12,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { outputResultPath } from '../../core/runtime/structured-output.js';
 import { ReviewOperationError as ReviewOperationErrorClass } from '../../core/review/types.js';
+import { cronSinkDisplay } from '../../core/canvas/crons.js';
 import { isProfilePaused, sanitizeProfileMetadata } from '../../core/profiles/manifest.js';
 import { contextDir, inboxPath, nodeDir, nodeMetaPath, reportsDir, reviewResultPath, transcriptPath, viewSocketPath, } from '../../core/canvas/paths.js';
 import { FinalizationError } from '../../core/feed/feed.js';
@@ -21,7 +22,6 @@ import { CrtrError } from '../../core/errors.js';
 import { WorktreeError } from '../../core/worktree.js';
 import { ApiError } from '../../api/errors.js';
 import { ExitCode } from '../../types.js';
-import { sinkDisplay } from '../cron-sink.js';
 import { responsePath } from '../../core/human/convention.js';
 import { ticketDir } from '../../core/human/root.js';
 // Node projections
@@ -314,7 +314,7 @@ export function toCronDTO(c, lastRun) {
         run_timeout_s: c.run_timeout_s,
         overlap: c.overlap,
         on_output: c.on_output,
-        sink: sinkDisplay(c.sink),
+        sink: cronSinkDisplay(c.sink),
         tier: c.tier,
         state: c.state,
         held: c.held,

package/dist/daemon/cron/sinks.d.ts

@@ -1,2 +1,2 @@
-import type { Cron } from '../../core/canvas/crons.js';
+import { type Cron } from '../../core/canvas/crons.js';
 export declare function deliverToSink(c: Cron, stdout: string): Promise<string>;

package/dist/daemon/cron/sinks.js

@@ -13,7 +13,7 @@ import { reviveNode } from '../../core/runtime/revive.js';
 import { isBrokerLive } from '../../core/runtime/model-swap.js';
 import { spawnChild } from '../../core/runtime/spawn.js';
 import { cronWakeOrigin } from '../../core/runtime/bearings.js';
-import { parseSink } from '../cron-sink.js';
+import { parseCronSink } from '../../core/canvas/crons.js';
 import { resolveLiveProfile, resolveLiveProfileName } from './armed-context.js';
 async function deliverNodeSink(c, target, stdout) {
     const meta = getNode(target);
@@ -89,7 +89,7 @@ function deliverHumanSink(c, stdout) {
     publishPage(ticketDir(id), prepared);
 }
 export async function deliverToSink(c, stdout) {
-    const sink = parseSink(c.sink);
+    const sink = parseCronSink(c.sink);
     if (sink === null)
         return 'no sink armed — nothing delivered';
     if (sink.kind === 'node') {

package/dist/daemon/reconcilers/live-obligation.js

@@ -1,4 +1,4 @@
-import { newestReportRef, hasActiveLiveSubscription, hasLiveMessageWait, hasLiveSubscriber, hasPendingCancelOnWakeCron, subscribersOf, } from '../../core/canvas/index.js';
+import { newestReportRef, hasActiveLiveSubscription, hasLiveMessageWait, hasLiveSubscriber, hasPendingCronWake, subscribersOf, } from '../../core/canvas/index.js';
 import { fullName } from '../../core/canvas/labels.js';
 import { countTickets } from '../../core/canvas/attention.js';
 import { hasUnseenWakeMail, readCursor, readInboxSince } from '../../core/feed/inbox.js';
@@ -12,7 +12,7 @@ import { transition } from '../../core/runtime/lifecycle.js';
 export function hasLiveObligation(nodeId) {
     return hasActiveLiveSubscription(nodeId)
         || hasLiveMessageWait(nodeId)
-        || hasPendingCancelOnWakeCron(nodeId)
+        || hasPendingCronWake(nodeId)
         || countTickets(nodeId) > 0
         || readOutputRequest(nodeId).state !== 'absent';
 }

package/dist/pi-extensions/canvas-bash-valve.d.ts

@@ -1,8 +1,5 @@
 import { createBashToolDefinition, type BashOperations } from '@earendil-works/pi-coding-agent';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-/** Seconds a leading `sleep ...` will block for, or null when the command does
- *  not open with a sleep (or its duration isn't statically knowable). */
-export declare function leadingSleepSeconds(command: string): number | null;
 /** The valve's BashOperations backend. Each tool execution closes over its own
  * `takePurpose` and its own preview-result path, so concurrent calls cannot
  * exchange labels or result mirrors. The purpose is consumed even when the

package/dist/pi-extensions/canvas-bash-valve.js

@@ -31,6 +31,7 @@ import { homedir } from 'node:os';
 import { dirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { backgroundBashJob, bashJobPaths, formatBashElapsed, newBashJobId, normalizeBashJobPurpose, readBashNiceness, writeJobDeadlineMs } from '../core/bash-jobs.js';
+import { bashCommandRefusal } from '../core/bash-guard.js';
 import { readConfig } from '../core/config.js';
 import { PREVIEW_RESULT_PATH_ENV, previewResultPath } from '../core/preview-result-path.js';
 import { resolveAdmittedHostCommand } from '../core/runtime/spawn-env.js';
@@ -164,39 +165,6 @@ function readExitCode(path) {
         return null;
     }
 }
-// Long-sleep guard. A command that opens with `sleep <long>` is a node burning
-// a live window to wait on a clock — the runtime already has waiting primitives
-// that cost nothing (`crtr cron` for a scheduled wake, `crtr node wait deadline`
-// for an inbox-vs-deadline race). Anything over 10s is refused before it runs.
-const MAX_INLINE_SLEEP_SECONDS = 10;
-const SLEEP_UNIT_SECONDS = { s: 1, m: 60, h: 3600, d: 86400 };
-/** Seconds a leading `sleep ...` will block for, or null when the command does
- *  not open with a sleep (or its duration isn't statically knowable). */
-export function leadingSleepSeconds(command) {
-    const match = /^\s*sleep(\s+[^;&|\n]+)/.exec(command);
-    if (!match)
-        return null;
-    // `sleep 1 2m 3` sums its operands.
-    let total = 0;
-    for (const operand of match[1].trim().split(/\s+/)) {
-        const parsed = /^([0-9]*\.?[0-9]+)([smhd]?)$/.exec(operand);
-        if (!parsed)
-            return null; // variable/expansion/flag — not statically knowable
-        total += Number(parsed[1]) * SLEEP_UNIT_SECONDS[parsed[2] || 's'];
-    }
-    return total;
-}
-function longSleepRefusal(command) {
-    const seconds = leadingSleepSeconds(command);
-    if (seconds === null || seconds <= MAX_INLINE_SLEEP_SECONDS)
-        return null;
-    return (`Refused: this command starts by sleeping ${seconds}s, over the ${MAX_INLINE_SLEEP_SECONDS}s inline limit.\n` +
-        `Holding a live window on a clock is never how you wait here. Instead:\n` +
-        `  - schedule the wake and end your turn: crtr cron -h (one-shot at a time, or recurring)\n` +
-        `  - race an inbox message against a deadline: crtr node wait deadline -h\n` +
-        `  - waiting on a child, a reply from the user, or any spine event: just stop — the runtime wakes you.\n` +
-        `If you truly need a short pause inline, sleep ${MAX_INLINE_SLEEP_SECONDS}s or less.`);
-}
 /** A node can legitimately remove its own merged worktree. Never recreate that
  *  path: it would look like a valid checkout but no longer be one. Run later
  *  commands from a durable directory instead, and make the changed semantics
@@ -228,7 +196,7 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     reject(new Error('aborted'));
                     return;
                 }
-                const refusal = longSleepRefusal(command);
+                const refusal = bashCommandRefusal(command, cwd);
                 if (refusal !== null) {
                     reject(new Error(refusal));
                     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.301",
+  "version": "0.3.303",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.301",
+  "version": "0.3.303",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.301",
+      "version": "0.3.303",
       "hasInstallScript": true,
       "license": "MIT",
       "workspaces": [
@@ -5206,17 +5206,17 @@
     },
     "packages/crouter-api": {
       "name": "@north-light/crouter-api",
-      "version": "0.3.301",
+      "version": "0.3.303",
       "license": "UNLICENSED"
     },
     "packages/crouter-env-docker": {
       "name": "@north-light/crouter-env-docker",
-      "version": "0.3.301",
+      "version": "0.3.303",
       "license": "UNLICENSED"
     },
     "packages/crouter-sdk": {
       "name": "@north-light/crouter-sdk",
-      "version": "0.3.301",
+      "version": "0.3.303",
       "license": "UNLICENSED",
       "dependencies": {
         "@north-light/crouter-api": "^0.3.295"

package/dist/daemon/cron-sink.d.ts

@@ -1,26 +0,0 @@
-/** The one decoder for a cron's stored sink JSON.
- *
- *  A sink is armed as a CLI spec string (`node:<id>` | `spawn:<kind>` |
- *  `human`), validated and encoded to JSON once at arm time
- *  (`api/handlers/crons.ts`), and thereafter read back in exactly two places:
- *  the runner, which dispatches a delivery on it, and the DTO mapper, which
- *  renders it. Both go through here so the stored shape has a single reader.
- *
- *  A malformed stored value decodes as no-sink rather than throwing: a cron
- *  that cannot deliver must still run, and must still list.
- */
-export type ParsedSink = {
-    kind: 'node';
-    node: string;
-} | {
-    kind: 'spawn';
-    spawn: string;
-} | {
-    kind: 'human';
-} | null;
-/** Stored JSON → typed shape. `{}`, malformed JSON, and an unrecognised shape
- *  all read as null (no sink). */
-export declare function parseSink(sinkJson: string): ParsedSink;
-/** Stored JSON → the display spec the CLI armed with, or null when the cron
- *  never delivers. The exact inverse of the arm-time encoding. */
-export declare function sinkDisplay(sinkJson: string): string | null;

package/dist/daemon/cron-sink.js

@@ -1,43 +0,0 @@
-/** The one decoder for a cron's stored sink JSON.
- *
- *  A sink is armed as a CLI spec string (`node:<id>` | `spawn:<kind>` |
- *  `human`), validated and encoded to JSON once at arm time
- *  (`api/handlers/crons.ts`), and thereafter read back in exactly two places:
- *  the runner, which dispatches a delivery on it, and the DTO mapper, which
- *  renders it. Both go through here so the stored shape has a single reader.
- *
- *  A malformed stored value decodes as no-sink rather than throwing: a cron
- *  that cannot deliver must still run, and must still list.
- */
-/** Stored JSON → typed shape. `{}`, malformed JSON, and an unrecognised shape
- *  all read as null (no sink). */
-export function parseSink(sinkJson) {
-    try {
-        const s = JSON.parse(sinkJson);
-        if (typeof s['node'] === 'string')
-            return { kind: 'node', node: s['node'] };
-        if (typeof s['spawn'] === 'string')
-            return { kind: 'spawn', spawn: s['spawn'] };
-        if (s['human'] === true)
-            return { kind: 'human' };
-    }
-    catch {
-        // malformed stored sink reads as no-sink; callers report it in their own terms
-    }
-    return null;
-}
-/** Stored JSON → the display spec the CLI armed with, or null when the cron
- *  never delivers. The exact inverse of the arm-time encoding. */
-export function sinkDisplay(sinkJson) {
-    const sink = parseSink(sinkJson);
-    if (sink === null)
-        return null;
-    switch (sink.kind) {
-        case 'node':
-            return `node:${sink.node}`;
-        case 'spawn':
-            return `spawn:${sink.spawn}`;
-        case 'human':
-            return 'human';
-    }
-}