cloving 1.1.0 → 1.3.0

package/dist/src/broker/actor/authority-queries.d.ts

@@ -1,6 +1,8 @@
 import type { Database } from "solid-objects";
-import type { AuthorityCommand, AuthorityEvent } from "../../authority/transitions.ts";
+import type { ExecutionManifest } from "../../workflow-admission.ts";
+import type { AuthorityCommand, AuthorityEvent, RunState } from "../../authority/transitions.ts";
 import { type SqlConnection } from "../../storage/domain-rows.ts";
+import { type RunLinks, type RunOrigins } from "../../authority/handoff-chain.ts";
 export interface CommandRecord {
     readonly commandId: string;
     readonly sequence: number;
@@ -28,14 +30,22 @@ export interface Sequences {
 export interface CompletionCursor {
     readonly runId: string;
     readonly atOrBefore: number;
+    readonly terminal?: boolean;
+}
+export interface RunRecord extends RunState {
+    readonly sequence: number;
 }
 export interface AuthorityQueries {
+    readonly run: (runId: string) => Promise<RunRecord | undefined>;
+    readonly manifest: (runId: string) => Promise<ExecutionManifest | undefined>;
     readonly document: (digest: string) => Promise<string | undefined>;
     readonly receipt: (commandId: string) => Promise<CommandRecord | undefined>;
     readonly eventsAfter: (cursor: EventCursor) => Promise<EventPage>;
     readonly latestCompletion: (cursor: CompletionCursor) => Promise<PublishedEvent | undefined>;
     readonly sequences: () => Promise<Sequences>;
     readonly workflowIds: () => Promise<Readonly<Record<string, string>>>;
+    readonly runOrigins: () => Promise<RunOrigins>;
+    readonly runLinks: () => Promise<Readonly<Record<string, RunLinks>>>;
 }
 export type Read = <Value>(query: (connection: SqlConnection) => Promise<Value>) => Promise<Value>;
 export declare function guardedRead(access: {

package/dist/src/broker/actor/authority-queries.js

@@ -1,8 +1,27 @@
+import { readExecutionManifest } from "../../execution-pin.js";
 import { parseCommand } from "../../authority/commands.js";
 import { documentBody } from "../../storage/decision-rows.js";
-import { integer, latestSequence, text, } from "../../storage/domain-rows.js";
-import { storedEvents } from "../authority-restore.js";
+import { integer, optionalText, latestSequence, runRow, text, } from "../../storage/domain-rows.js";
+import { storedEvents, storedRun } from "../authority-restore.js";
 import { documentDigest } from "../decision-restore.js";
+import { runLinks, } from "../../authority/handoff-chain.js";
+async function run(connection, runId) {
+    const row = await connection.get("SELECT run_id, status, revision, workflow, paused_from, gates, sequence FROM runs WHERE run_id = ?", [runId]);
+    if (row === undefined)
+        return undefined;
+    const record = runRow(row);
+    return { ...storedRun(record), sequence: record.sequence };
+}
+async function runOrigins(connection, cursor) {
+    const rows = await connection.all("SELECT run_id, json_extract(payload, '$.parentRunId') AS parent_run_id, coalesce(json_extract(payload, '$.chainId'), run_id) AS chain_id FROM events WHERE type = 'run.created' AND sequence > ? AND sequence <= ? ORDER BY sequence", [cursor.after, cursor.through]);
+    return Object.fromEntries(rows.map((row) => [
+        text(row, "run_id"),
+        {
+            parentRunId: optionalText(row, "parent_run_id"),
+            chainId: text(row, "chain_id"),
+        },
+    ]));
+}
 async function receipt(connection, commandId) {
     const row = await connection.get("SELECT c.request, c.sequence, e.run_id, e.recorded_at FROM commands c JOIN events e ON e.sequence = c.sequence WHERE c.command_id = ?", [commandId]);
     if (row === undefined)
@@ -51,7 +70,10 @@ function publishedEvents(rows) {
     }));
 }
 async function latestCompletion(connection, cursor) {
-    const row = await connection.get("SELECT sequence, type, run_id, command_id, recorded_at, payload FROM events WHERE run_id = ? AND type = 'run.completed' AND sequence <= ? ORDER BY sequence DESC LIMIT 1", [cursor.runId, cursor.atOrBefore]);
+    const types = cursor.terminal === true
+        ? "type IN ('run.completed', 'run.failed', 'run.cancelled')"
+        : "type = 'run.completed'";
+    const row = await connection.get(`SELECT sequence, type, run_id, command_id, recorded_at, payload FROM events WHERE run_id = ? AND ${types} AND sequence <= ? ORDER BY sequence DESC LIMIT 1`, [cursor.runId, cursor.atOrBefore]);
     return row === undefined ? undefined : publishedEvents([row])[0];
 }
 async function sequences(connection) {
@@ -66,6 +88,28 @@ async function workflowIds(connection) {
     const rows = await connection.all("SELECT d.run_id, json_extract(s.body, '$.workflowId') AS workflow_id FROM run_details d JOIN documents s ON s.digest = d.submission WHERE json_valid(s.body) AND json_type(s.body, '$.workflowId') = 'text'");
     return Object.fromEntries(rows.map((row) => [text(row, "run_id"), text(row, "workflow_id")]));
 }
+function cachedOrigins(read) {
+    let sequence = 0;
+    let origins = {};
+    let pending = Promise.resolve();
+    return () => {
+        const result = pending.then(() => read(async (connection) => {
+            const through = await latestSequence(connection);
+            if (through === sequence)
+                return origins;
+            const added = await runOrigins(connection, {
+                after: sequence,
+                through,
+            });
+            if (Object.keys(added).length > 0)
+                origins = { ...origins, ...added };
+            sequence = through;
+            return origins;
+        }));
+        pending = result.then(() => undefined, () => undefined);
+        return result;
+    };
+}
 export function guardedRead(access) {
     const { reader, ready } = access;
     return async (query) => {
@@ -74,12 +118,32 @@ export function guardedRead(access) {
     };
 }
 export function authorityQueries(read) {
+    const origins = cachedOrigins(read);
+    let linkedOrigins;
+    let links = {};
+    const currentLinks = async () => {
+        const current = await origins();
+        if (current !== linkedOrigins) {
+            links = runLinks(current);
+            linkedOrigins = current;
+        }
+        return links;
+    };
     return {
+        run: (runId) => read((connection) => run(connection, runId)),
+        manifest: (runId) => read(async (connection) => {
+            const row = await connection.get("SELECT d.manifest FROM runs r JOIN definitions d ON d.pin = r.workflow WHERE r.run_id = ?", [runId]);
+            return row === undefined
+                ? undefined
+                : readExecutionManifest(JSON.parse(text(row, "manifest")));
+        }),
         document: (digest) => read((connection) => documentBody(connection, digest)),
         receipt: (commandId) => read((connection) => receipt(connection, commandId)),
         eventsAfter: (cursor) => read((connection) => eventsAfter(connection, cursor)),
         latestCompletion: (cursor) => read((connection) => latestCompletion(connection, cursor)),
         sequences: () => read(sequences),
         workflowIds: () => read(workflowIds),
+        runOrigins: origins,
+        runLinks: currentLinks,
     };
 }

package/dist/src/broker/actor/authority-receipts.js

@@ -1,5 +1,6 @@
 import { integer, text } from "../../storage/domain-rows.js";
 import { intentKind } from "../authority-restore.js";
+import { commandLimits } from "../../command-settings.js";
 export const unserializable = {
     kind: "rejected",
     reason: "invalid-command",
@@ -16,7 +17,16 @@ export const tooLarge = {
     detail: `A request has at most ${String(maximumRequestBytes)} bytes.`,
 };
 export function oversized(request) {
-    return Buffer.byteLength(JSON.stringify(request)) > maximumRequestBytes;
+    const command = request["command"];
+    const report = typeof command === "object" &&
+        command !== null &&
+        !Array.isArray(command) &&
+        command["kind"] === "report-effect" &&
+        command["worker"] === "command";
+    const limit = report
+        ? maximumRequestBytes + commandLimits.stdoutBytes * 6
+        : maximumRequestBytes;
+    return Buffer.byteLength(JSON.stringify(request)) > limit;
 }
 export function failed(error) {
     const name = String(Reflect.get(Object(error), "name"));

package/dist/src/broker/actor/authority-session.js

@@ -1,5 +1,5 @@
 import { eligibleIntents, } from "../../authority/reducer.js";
-import { loadProjections, } from "../../storage/decision-snapshots.js";
+import { loadOperationSnapshot, loadProjections, } from "../../storage/decision-snapshots.js";
 import { loadEvents } from "../../storage/domain-rows.js";
 import { pinnedResumption } from "../authority-admission.js";
 import { currentState, intentKind, storedDefinitions, storedEvents, } from "../authority-restore.js";
@@ -40,7 +40,7 @@ export function authoritySession(parts) {
             return storedEvents(await parts.reader.connection(loadEvents));
         },
         eligibleIntents: async () => eligible(await projected(session)),
-        operations: async () => operationRecords(await projected(session)),
+        operations: async () => operationRecords(await read(loadOperationSnapshot)),
         resumePinned: async (runId, manifest) => {
             const snapshot = await projected(session);
             return pinnedResumption(currentState(snapshot), {

package/dist/src/broker/actor/authority-settings.js

@@ -1,5 +1,6 @@
 import { recoveryBound } from "../../authority/commands.js";
 import { lineLogger } from "./authority-logger.js";
+import { commandLimits } from "../../command-settings.js";
 export const authorityTiming = {
     leaseMilliseconds: 2_000,
     renewalMilliseconds: 500,
@@ -50,6 +51,9 @@ export function librarySettings(timing, log) {
     return {
         tableNamePrefix: "solid_",
         maxAttempts: 1,
+        maxActivationDurationMilliseconds: 50,
+        maxPayloadBytes: 900_000 + commandLimits.stdoutBytes * 6,
+        maxResultBytes: 900_000 + commandLimits.stdoutBytes * 6,
         logger: lineLogger(log ?? standardError),
         leaseDurationMilliseconds: timing.leaseMilliseconds,
         leaseRenewalIntervalMilliseconds: timing.renewalMilliseconds,

package/dist/src/broker/actor/delivery-intents.d.ts

@@ -18,6 +18,7 @@ export interface DeliveryIntent extends EffectIntent, Partial<DeliveryDecision>,
     readonly workflow: string;
     readonly inputDigest: string;
     readonly purpose: Purpose;
+    readonly commandDeadline?: string;
 }
 export type ProtectedIntent = DeliveryIntent & EffectArguments;
 export type Undigested = Omit<DeliveryIntent, "inputDigest" | "purpose">;
@@ -51,9 +52,10 @@ export interface Delivery {
         readonly worker?: string;
     } | AdapterOutcome>;
     readonly reconcile: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
+    readonly retry?: Delivery["reconcile"];
     readonly stop?: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
 }
-export type AvailableManifest = (pinned: ExecutionManifest) => ExecutionManifest | undefined;
+export type AvailableManifest = (pinned: ExecutionManifest) => ExecutionManifest | undefined | Promise<ExecutionManifest | undefined>;
 export declare function intentDigest(intent: Undigested): string;
 export declare function deliveryIntent(intent: Undigested): DeliveryIntent;
 export declare function protectedIntent(state: AuthorityState, attempt: {

package/dist/src/broker/actor/delivery-intents.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
-import { continues, isSettled } from "../../authority/gates.js";
+import { delivers, isSettled } from "../../authority/gates.js";
 import { eligibleIntents, } from "../../authority/reducer.js";
-import { gateContinuation } from "../../authority/reduction.js";
+import { gateDelivery } from "../../authority/reduction.js";
 export function intentDigest(intent) {
     const base = [intent.kind, intent.runId, intent.operationId, intent.workflow];
     const bound = intent.gateId === undefined
@@ -37,7 +37,7 @@ export function protectedIntent(state, attempt) {
     })));
 }
 export function gateDecision(gate) {
-    if (gate === undefined || gate.kind === "untyped" || !continues(gate))
+    if (gate === undefined || gate.kind === "untyped" || !delivers(gate))
         return null;
     return {
         gateId: gate.gateId,
@@ -51,7 +51,7 @@ function workflowOf(state, runId) {
 function decisionOf(state, intent) {
     return gateDecision(Object.values(state.gates).find((gate) => gate.runId === intent.runId &&
         isSettled(gate) &&
-        gateContinuation(gate).operationId === intent.operationId));
+        gateDelivery(gate).operationId === intent.operationId));
 }
 export function observingIntent(state, attempt) {
     const { intent, purpose } = attempt;

package/dist/src/broker/actor/effect-delivery.js

@@ -4,6 +4,7 @@ import { budgetRow } from "../../storage/effect-rows.js";
 import { effectInputDigest, storedBudget } from "../effect-restore.js";
 import { settlement } from "./adapter-outcomes.js";
 import { pinned } from "./pin-check.js";
+import { commandLimits } from "../../command-settings.js";
 const absent = {
     attempt: undefined,
     released: false,
@@ -51,7 +52,9 @@ async function called(parts, call) {
     const adapterCall = parts.delivery[name]?.bind(parts.delivery);
     if (adapterCall === undefined)
         return { kind: "unknown", reason: "stop-not-supported" };
-    return settlement(await parts.calls.call(intent.operationId, (signal) => adapterCall(intent, signal)), parts.effects.resultBytes);
+    return settlement(await parts.calls.call(intent.operationId, (signal) => adapterCall(intent, signal)), intent.capability === "command"
+        ? commandLimits.resultBytes
+        : parts.effects.resultBytes);
 }
 const confirmations = ["stopped", "completed", "failed"];
 async function stopRequested(parts, intent) {
@@ -69,9 +72,16 @@ function decided(parts, attempt) {
     }), {
         intent: { ...intent, computedDigest: effectInputDigest(intent) },
         now,
+        ...(attempt.mode === undefined ? {} : { mode: attempt.mode }),
     }));
 }
 const withheld = { kind: "withheld" };
+async function retryEffect(parts, attempt) {
+    const retry = await decided(parts, { ...attempt, mode: "retry" });
+    return retry === "send"
+        ? called(parts, { intent: attempt.intent, name: "retry" })
+        : attempt.known;
+}
 function unsent(decision) {
     return decision === "stale" ? withheld : { kind: decision };
 }
@@ -83,6 +93,8 @@ async function attempted(parts, attempt) {
     if (intent.purpose === "stop")
         return stopRequested(parts, intent);
     const known = await called(parts, { intent, name: "reconcile" });
+    if (known.kind === "unknown" && parts.delivery.retry !== undefined)
+        return retryEffect(parts, { ...attempt, known });
     if (known.kind !== "absent" || intent.purpose === "reconcile")
         return known;
     if (first !== "send")

package/dist/src/broker/actor/effect-queries.d.ts

@@ -16,6 +16,7 @@ export interface EffectQueries {
     readonly dueLeases: (instant: string) => Promise<readonly DueLease[]>;
     readonly stops: (runId: string) => Promise<readonly string[]>;
     readonly closure: (runId: string) => Promise<RunClosure>;
+    readonly settledAt: (runId: string) => Promise<number | null>;
 }
 export interface DueLease {
     readonly runId: string;

package/dist/src/broker/actor/effect-queries.js

@@ -3,6 +3,12 @@ import { integer, optionalInteger, optionalText, text, } from "../../storage/dom
 import { budgetColumns, budgetRow, evidenceColumns, evidenceRow, operationColumns, operationRow, } from "../../storage/effect-rows.js";
 import { storedBudget } from "../effect-restore.js";
 import { stopping } from "./stop-turn.js";
+async function settledAt(connection, runId) {
+    const rows = await connection.all("SELECT recorded_at FROM events WHERE sequence IN (SELECT settled_sequence FROM operations WHERE run_id = ? UNION ALL SELECT min(e.sequence) FROM events e JOIN stopped_operations s ON s.run_id = e.run_id AND s.operation_id = json_extract(e.payload, '$.operationId') WHERE e.run_id = ? AND (EXISTS (SELECT 1 FROM deliveries d WHERE d.operation_id = s.operation_id AND d.outcome = 'sent') OR (SELECT d.outcome FROM deliveries d WHERE d.operation_id = s.operation_id ORDER BY d.staged_sequence DESC, d.rowid DESC LIMIT 1) NOT IN ('withheld', 'blocked', 'absent')) AND ((e.type = 'run.observed' AND json_extract(e.payload, '$.condition') = 'stopped') OR (e.type = 'operation.reconciled' AND json_extract(e.payload, '$.outcome') = 'stopped')) GROUP BY s.operation_id)", [runId, runId]);
+    if (rows.length === 0)
+        return null;
+    return rows.reduce((latest, row) => Math.max(latest, Date.parse(text(row, "recorded_at"))), -Infinity);
+}
 async function storedClosure(connection, scope) {
     const { subjects, cancelledSequence } = await stopping(connection, scope.runId);
     return runClosure(subjects, {
@@ -70,6 +76,7 @@ export function effectQueries(read, settings) {
     return {
         stops: (runId) => read((connection) => stops(connection, runId)),
         closure: (runId) => read((connection) => storedClosure(connection, { runId, stopLimit: settings.stopLimit })),
+        settledAt: (runId) => read((connection) => settledAt(connection, runId)),
         budget: (runId) => read((connection) => budget(connection, runId)),
         dueLeases: (instant) => read((connection) => dueLeases(connection, instant)),
         operation: (operationId) => read((connection) => operation(connection, operationId)),

package/dist/src/broker/actor/pin-check.js

@@ -7,6 +7,6 @@ export async function pinned(connection, check) {
     const stored = readExecutionManifest(JSON.parse(text(await connection.get("SELECT manifest FROM definitions WHERE pin = ?", [
         workflow,
     ]), "manifest")));
-    const current = available(stored);
+    const current = await available(stored);
     return (current !== undefined && resumePinned(stored, current).kind === "admitted");
 }

package/dist/src/broker/actor/stop-plan.js

@@ -15,7 +15,7 @@ function present(state, planning) {
         stopped: subject.stopped || state.effects.stops[subject.operationId] !== undefined,
     };
 }
-const kinds = ["start-run", "continue-run"];
+const kinds = ["start-run", "continue-run", "resume-hook"];
 function intentOf(state, attempt) {
     const { runId, operationId, purpose } = attempt;
     const kind = kinds.find((candidate) => candidate === attempt.kind);

package/dist/src/broker/actor/turn-state.js

@@ -76,7 +76,7 @@ export async function adoptionTurn(connection) {
     return latest;
 }
 export async function recoverableIntents(connection) {
-    const rows = await connection.all("SELECT o.operation_id, o.kind, o.run_id, r.workflow FROM outbox o JOIN runs r ON r.run_id = o.run_id WHERE o.released_sequence IS NULL AND NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.operation_id = o.operation_id AND d.outcome IS NULL) AND ((o.kind = 'start-run' AND r.status = 'queued') OR (o.kind = 'continue-run' AND r.status = 'running') OR (o.kind = 'protected-effect' AND r.status = 'running' AND EXISTS (SELECT 1 FROM operations p WHERE p.operation_id = o.operation_id AND p.status = 'dispatch-pending'))) ORDER BY o.created_sequence, o.rowid LIMIT ?", [recoveryBatch]);
+    const rows = await connection.all("SELECT o.operation_id, o.kind, o.run_id, r.workflow FROM outbox o JOIN runs r ON r.run_id = o.run_id WHERE o.released_sequence IS NULL AND NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.operation_id = o.operation_id AND d.outcome IS NULL) AND ((o.kind = 'start-run' AND r.status = 'queued') OR (o.kind IN ('continue-run', 'resume-hook') AND r.status = 'running') OR (o.kind = 'protected-effect' AND r.status = 'running' AND EXISTS (SELECT 1 FROM operations p WHERE p.operation_id = o.operation_id AND p.status = 'dispatch-pending'))) ORDER BY o.created_sequence, o.rowid LIMIT ?", [recoveryBatch]);
     const intents = [];
     for (const row of rows) {
         const intent = {

package/dist/src/broker/authority-admission.js

@@ -1,5 +1,5 @@
 import { parseCommand } from "../authority/commands.js";
-import { readExecutionManifest, resumePinned } from "../execution-pin.js";
+import { executionCapabilities, readExecutionManifest, resumePinned, } from "../execution-pin.js";
 import { effectInputDigest } from "./effect-restore.js";
 import { workflowPin } from "./workflow-pin.js";
 const admissible = { kind: "admissible", definitions: new Map() };
@@ -15,7 +15,7 @@ const admission = (command, context) => {
     const pin = workflowPin(stored);
     if (command.workflow !== pin)
         return { kind: "rejected", reason: "workflow-pin-mismatch" };
-    const capabilities = JSON.stringify([...stored.capabilities].sort());
+    const capabilities = executionCapabilities(stored);
     if ((command.capabilities ?? capabilities) !== capabilities)
         return { kind: "rejected", reason: "capability-pin-mismatch" };
     return { kind: "admissible", definitions: new Map([[pin, stored]]) };
@@ -33,6 +33,25 @@ const resumption = (command, context) => {
         ? resumed
         : admissible;
 };
+const commandEffect = (command, context) => {
+    const pin = context.state.runs[command.runId]?.workflow ?? "";
+    const names = context.definitions.get(pin)?.commands ?? [];
+    const method = String(command.method);
+    if (!method.startsWith("run:") || !names.includes(method.slice(4)))
+        return { kind: "rejected", reason: "command-not-declared" };
+    return unpinned(command, context);
+};
+const handoffEffect = (command, context) => {
+    if (command.capability !== "handoff")
+        return unpinned(command, context);
+    const pin = context.state.runs[command.runId]?.workflow ?? "";
+    const declaration = context.definitions.get(pin);
+    if (!declaration?.handoffs?.includes(String(command.target)))
+        return { kind: "rejected", reason: "handoff-not-declared" };
+    if (command.units !== 1 || command.method !== "run")
+        return { kind: "rejected", reason: "invalid-handoff-request" };
+    return unpinned(command, context);
+};
 const effectRequest = (command, context) => {
     const computed = effectInputDigest({
         capability: String(command.capability),
@@ -40,9 +59,11 @@ const effectRequest = (command, context) => {
         target: String(command.target),
         payload: String(command.payload),
     });
-    return computed === command.inputDigest
-        ? unpinned(command, context)
-        : { kind: "rejected", reason: "input-digest-mismatch" };
+    if (computed !== command.inputDigest)
+        return { kind: "rejected", reason: "input-digest-mismatch" };
+    return command.capability === "command"
+        ? commandEffect(command, context)
+        : handoffEffect(command, context);
 };
 const rules = {
     "request-effect": effectRequest,

package/dist/src/broker/authority-restore.js

@@ -122,6 +122,7 @@ export function projectedState(snapshot) {
 const intentKinds = [
     "start-run",
     "continue-run",
+    "resume-hook",
     "protected-effect",
 ];
 export function intentKind(value) {

package/dist/src/broker/decision-restore.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
-import { continues, gateKey } from "../authority/gates.js";
-import { gateContinuation } from "../authority/reduction.js";
+import { delivers, gateKey } from "../authority/gates.js";
+import { gateDelivery } from "../authority/reduction.js";
 const kinds = ["question", "approval", "untyped"];
-const waits = ["registered", "pending"];
+const waits = ["registered", "pending", "hook"];
 export function documentDigest(body) {
     return `sha256:${createHash("sha256").update(body).digest("hex")}`;
 }
@@ -22,7 +22,7 @@ export function gateRecord(gate) {
         answer: gate.outcome?.answer ?? null,
         decidedSequence: gate.outcome?.sequence ?? null,
         openedSequence: gate.openedSequence,
-        continuation: continues(gate) ? gateContinuation(gate).operationId : null,
+        continuation: delivers(gate) ? gateDelivery(gate).operationId : null,
     };
 }
 const unobserved = {

package/dist/src/broker/socket-address.d.ts

@@ -6,4 +6,6 @@ export type SocketAddress = {
     readonly reason: "runtime-path-too-long";
     readonly detail: string;
 };
-export declare function socketAddress(path: string): SocketAddress;
+export declare function socketAddress(path: string, options?: {
+    readonly directory: string;
+}): SocketAddress;

package/dist/src/broker/socket-address.js

@@ -1,7 +1,7 @@
 import { relative } from "node:path";
 const maximumBytes = 103;
-export function socketAddress(path) {
-    const [shortest] = [path, relative(process.cwd(), path)]
+export function socketAddress(path, options = { directory: process.cwd() }) {
+    const [shortest] = [path, relative(options.directory, path)]
         .filter((candidate) => candidate.length > 0)
         .sort((left, right) => Buffer.byteLength(left) - Buffer.byteLength(right));
     if (shortest === undefined || Buffer.byteLength(shortest) > maximumBytes)

package/dist/src/cli/arguments.d.ts

@@ -1,23 +1,21 @@
+import { type ConfigInvocation } from "./config-arguments.ts";
+import { type PhoneInvocation } from "./phone-arguments.ts";
 import { type RuntimeInvocation } from "./runtime-arguments.ts";
 export type Invocation = {
+    readonly repository?: string;
+} & (PhoneInvocation | ConfigInvocation | {
+    readonly kind: "config-help";
+} | {
     readonly kind: "help";
 } | {
     readonly kind: "version";
 } | {
-    readonly kind: "validate-help";
-} | {
-    readonly kind: "chats-redact-help";
+    readonly kind: "doctor-help";
 } | {
-    readonly kind: "chats-redact";
-    readonly importId: string;
-} | {
-    readonly kind: "chats-import-help";
+    readonly kind: "doctor";
+    readonly json: boolean;
 } | {
-    readonly kind: "chats-import";
-    readonly paths: readonly string[];
-    readonly roots?: readonly string[];
-    readonly excludeProjects?: readonly string[];
-    readonly previousImportId?: string;
+    readonly kind: "validate-help";
 } | {
     readonly kind: "validate";
     readonly manifest: string;
@@ -27,5 +25,5 @@ export type Invocation = {
     readonly kind: "usage-error";
     readonly code: string;
     readonly json: boolean;
-};
+});
 export declare function parseInvocation(given: readonly string[]): Invocation;