@parcha/agentrun-kernel 0.0.0-stage → 0.1.0-beta.29

package/dist/kernel/types.d.ts

@@ -0,0 +1,120 @@
+import type { JsonValue, SessionWriter, ToolImage } from "../types.js";
+export type ReplayPolicy = "safe" | "never";
+export type SubmissionKind = "prompt" | "steer" | "followUp" | "withdraw";
+/** One input a person sent the session, as the host recorded it. */
+export interface Submission {
+    id: string;
+    kind: SubmissionKind;
+    text?: string;
+    /** For a withdraw: the submission it withdraws. */
+    target?: string;
+    receivedAt: Date;
+}
+export type EffectStatus = "pending" | "running" | "completed" | "failed";
+export interface EffectError {
+    message: string;
+    /** The effect's drive went away before it reported an outcome: it may or may not have taken effect. */
+    interrupted?: boolean;
+    /** What it reported before it was interrupted. */
+    partial?: unknown[];
+}
+/** One effect as the session's records hold it: its intent, then at most one outcome. */
+export interface EffectRecord {
+    key: string;
+    stepId: string;
+    name: string;
+    replay: ReplayPolicy;
+    input: unknown;
+    status: EffectStatus;
+    output?: unknown;
+    error?: EffectError;
+    /** 0 for the first run; one more each time a `safe` effect a crash cut off is run again. */
+    attempt: number;
+    startedAt?: Date;
+    /** Submissions this effect placed: taken out of `pending()` at its intent. */
+    placed: string[];
+}
+/** The session as its records fold. */
+export interface SessionState {
+    runId: string;
+    status: "running";
+    submissions: Submission[];
+    placed: Set<string>;
+    withdrawn: Set<string>;
+    /** By key: the first intent for a key wins. */
+    effects: Map<string, EffectRecord>;
+    /** In the order their intents were written. */
+    effectOrder: EffectRecord[];
+}
+export interface EffectOptions {
+    name: string;
+    replay: ReplayPolicy;
+    input: unknown;
+    placed?: string[];
+    /** Where the effect must run and what it needs; recorded with the intent, not acted on by this kernel. */
+    requires?: string;
+    needs?: string[];
+}
+export interface EffectIO {
+    signal: AbortSignal;
+    progress(chunk: unknown): void;
+    stepId: string;
+}
+/** A blob store for records too large to keep inline: pieces of text, content-addressed, kept in the session's own
+ *  records, written through its writer. */
+export interface KernelWorld {
+    readonly store: SessionWriter;
+}
+/** What a copied harness drive gets: its session's state, effects that run at most once (or again, when `safe`, after a
+ *  crash), its pending input, and its signal. One drive holds a session at a time: its writer is fenced once a newer
+ *  drive opens, and the stale drive's next write is a `Restart`. */
+export interface DriveContext {
+    readonly runId: string;
+    readonly world: KernelWorld;
+    readonly config: unknown;
+    state(): SessionState;
+    effect<T>(key: string, options: EffectOptions, fn: (io: EffectIO) => Promise<T>): Promise<T>;
+    isMemoized(key: string): boolean;
+    pending(): Submission[];
+    /** Re-folds this drive's records; it reads nothing. This drive is the session's only writer (a newer `open` fences
+     *  it), and door input is already folded by `submit`, which also wakes `onHint`. A fenced drive learns it on its
+     *  next append, not here. */
+    refresh(): Promise<void>;
+    live(event: unknown): void;
+    /** Called when new input may be waiting (a submission was recorded through this drive); returns the unsubscribe. */
+    onHint?(listener: (hint: {
+        eventType: "hook_received" | "reconnect";
+    }) => void): () => void;
+    readonly signal: AbortSignal;
+    halt?(reason: unknown): void;
+    /** How many times this session's drive has been rebuilt in this process (0 first). */
+    readonly attempt: number;
+    /** When this drive must have let go, on Date.now()'s clock, if it has a deadline. */
+    readonly deadline?: number;
+}
+/** A tool the host runs for the harness, as the copied tool bridge calls it. */
+export interface HostTool<Input = any> {
+    name: string;
+    label?: string;
+    description: string;
+    inputSchema: object;
+    replay: ReplayPolicy;
+    /** Where the tool must run, and what it needs: passed to the effect's intent. */
+    requires?: string;
+    needs?: string[];
+    /** Its answer: the text, or the text with the images it shows. Recorded as the call's outcome, so a call answered
+     *  from the record answers with the same images. */
+    execute(input: Input, io: HostToolIO): Promise<string | ToolOutput>;
+}
+/** A tool's answer with images. */
+export interface ToolOutput {
+    text: string;
+    images?: readonly ToolImage[];
+}
+export interface HostToolIO {
+    signal: AbortSignal;
+    progress(chunk: unknown): void;
+    ctx: DriveContext;
+    stepId?: string;
+}
+export type { JsonValue };

package/dist/kernel/types.js

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

package/dist/process/builtins.d.ts

@@ -0,0 +1,142 @@
+import { type DriveContext, type HostToolIO, type ReplayPolicy } from '../kernel/index.js';
+import { type ToolResult } from './tools.js';
+/**
+ * A harness's own (built-in) tools, in the log.
+ *
+ * With its built-in tools on, a harness runs tools the drive never sees run:
+ * Codex's shell and `apply_patch` run inside app-server. The drive sees
+ * them through the harness's own hooks: one before a call runs (a Codex
+ * approval request), one after it (`item/completed`). `BuiltinCalls` makes that pair the kernel's effect
+ * sandwich for the call, keyed by the harness's own call id
+ * (`tool:<callId>`, step name `tool.<name>`, like a bridged tool):
+ *
+ * - `begin` commits the call's intent and resolves once it is committed
+ *   (for a `never` call: durable, after the harness's own record of the call
+ *   is in the log, `beforeNever`). Only then does the hook let the call run.
+ * - `end` commits its outcome: the result the harness reports (clipped: the
+ *   full result is in the harness's own transcript, which the log carries).
+ *
+ * What that buys, and what it does not:
+ *
+ * - Every built-in call that ran has an intent in the log first. After a
+ *   crash, the recovery note lists each call of the turn with what the log
+ *   knows: completed (its result), failed, or interrupted, "may or may not
+ *   have taken effect" (`never`) / "safe to repeat" (`safe`).
+ * - Nothing reruns a built-in call by itself. The harness resumes its own
+ *   session, which answers a call that was in flight "interrupted, outcome
+ *   unknown" (Codex gets it injected).
+ *   A harness that dispatches the same call id again gets the log's answer
+ *   (`begin` returns it) and must not run it. For a built-in, `safe` only
+ *   changes the note's wording: the model decides what to repeat.
+ * - What a call did is not in the log. The working directory is a disk on
+ *   the machine that drives the session (see `LocalWorkspace`), and a
+ *   process a tool started does not outlive the drive (`ProcessHost`'s
+ *   group registry kills it).
+ */
+export interface BuiltinCall {
+    /** The harness's own id for the call (stable across a resume of its session: it is the memo key). */
+    callId: string;
+    /** The harness's tool name (`Bash`, `shell`, `edit`, ...). */
+    name: string;
+    input: unknown;
+    /** Default: `BuiltinCallsOptions.replay(name)`. */
+    replay?: ReplayPolicy;
+}
+export interface BuiltinCallsOptions {
+    /** A built-in's replay policy, by name. Default `never`. */
+    replay?: (name: string) => ReplayPolicy;
+    /**
+     * Runs before the intent of a `never` call: the native journal's barrier,
+     * so the harness's own record of the call is in the log before its intent.
+     */
+    beforeNever?: (call: BuiltinCall) => Promise<void>;
+    /** Publish `tool_start` / `tool_end` on `ctx.live`. Default true. */
+    live?: boolean;
+    /** How much of a result the step records. Default 8000 characters. */
+    outputChars?: number;
+    /**
+     * Run each call's effect body inside this wrapper: `run` lets the call go
+     * (`begin` resolves once the wrapper calls it) and resolves with the
+     * result the harness reports (`end`), or rejects with its failure. What
+     * the wrapper returns is the call's recorded outcome, and what it throws
+     * its failure. For a harness whose built-ins work on files the drive
+     * keeps: sync the files in before `run`, and commit what the call changed
+     * with its outcome. A wrapper that throws before
+     * calling `run` fails the call: `begin` answers with that failure, and the
+     * call never runs. One that returns without calling `run` decides the
+     * outcome itself: `begin` answers with it, and the call never runs either
+     * (nothing on the live stream). One that throws after `run` fails the call
+     * although the harness ran it (the step records the failure, `end`
+     * resolves). Calling `run` again returns the first call's promise. Default:
+     * none (the call runs as soon as its intent is committed).
+     */
+    around?: (call: BuiltinCall, run: () => Promise<string>, io: HostToolIO) => Promise<string>;
+}
+/** What `begin` says the hook should do. */
+export type BuiltinStart = 
+/** The intent is committed: let the call run. */
+{
+    run: true;
+}
+/** The log already has an outcome for this call id: do not run it, answer with this. */
+ | {
+    run: false;
+    result: ToolResult;
+};
+/**
+ * The built-in calls of one drive. Build one per `drive(ctx)`.
+ *
+ * A call the drive leaves open (the harness's process died mid-call, the
+ * drive stopped) is dealt with by `close`: interrupted if the drive is
+ * still live, else left to the kernel (a stopped drive's intent is released
+ * or recovered as interrupted by the next delivery).
+ */
+export declare class BuiltinCalls {
+    private readonly ctx;
+    private readonly options;
+    private readonly open;
+    /** Each call id's first `begin`, reserved before it awaits anything. */
+    private readonly begun;
+    private readonly replay;
+    private readonly live;
+    private readonly outputChars;
+    constructor(ctx: DriveContext, options?: BuiltinCallsOptions);
+    /** Calls begun and not ended. */
+    get size(): number;
+    /** Whether this call is open in this drive. */
+    has(callId: string): boolean;
+    /**
+     * The harness is about to run `call`: commit its intent. Resolves once the
+     * intent is committed (`{ run: true }`), or at once with the log's answer
+     * when the call id already has an outcome (`{ run: false }`). Rejects if
+     * the intent cannot be committed (the drive lost the session, a write
+     * failed): the drive is halted, and the hook must refuse the call.
+     */
+    begin(call: BuiltinCall): Promise<BuiltinStart>;
+    /** The same call begun again: never run it twice. Wait for the first begin, then for its outcome, from the log. */
+    private again;
+    private beginOnce;
+    /**
+     * The call ended: commit its outcome. `isError` (the tool reported a
+     * failure) commits a failed step with `text` as its error. Resolves once
+     * the outcome is committed (or the drive stopped first). A call this
+     * drive never began (a hook that fired without its `begin`) is begun and
+     * ended here: recorded after the fact.
+     */
+    end(callId: string, result: {
+        name?: string;
+        input?: unknown;
+        text: string;
+        isError?: boolean;
+    }): Promise<void>;
+    /**
+     * The harness can no longer report these calls (its process exited mid-call):
+     * commit each open call as interrupted, "may or may not have taken effect".
+     * A no-op once the drive stopped (the kernel resolves its intents).
+     */
+    interruptAll(reason?: string): Promise<void>;
+    /** Wait for every open call to settle, or `ms` to pass. */
+    settled(ms: number): Promise<void>;
+}
+/** A tool name list as a replay classifier: these are `safe`, the rest `never`. */
+export declare function replayBy(safe: Iterable<string>): (name: string) => ReplayPolicy;

package/dist/process/builtins.js

@@ -0,0 +1,207 @@
+// Copyright 2026 Vercel Inc. Licensed under the Apache License, Version 2.0; see LICENSE in this package.
+// From github.com/vercel-labs/durable-harness, packages/harness-process/src/builtins.ts at ea8aa4060c (UPSTREAM.json records its blob and sha256).
+// Changed by Parcha, imports rewritten for AgentRun; patches: 001-begin-reservation, 002-message-prefix, 003-comments-name-this-host
+import { EffectFailure, EffectInterrupted, Fatal, hostToolIO } from '../kernel/index.js';
+import { clip, failureText, toolKey } from './tools.js';
+/**
+ * The built-in calls of one drive. Build one per `drive(ctx)`.
+ *
+ * A call the drive leaves open (the harness's process died mid-call, the
+ * drive stopped) is dealt with by `close`: interrupted if the drive is
+ * still live, else left to the kernel (a stopped drive's intent is released
+ * or recovered as interrupted by the next delivery).
+ */
+export class BuiltinCalls {
+    ctx;
+    options;
+    open = new Map();
+    /** Each call id's first `begin`, reserved before it awaits anything. */
+    begun = new Map();
+    replay;
+    live;
+    outputChars;
+    constructor(ctx, options = {}) {
+        this.ctx = ctx;
+        this.options = options;
+        this.replay = options.replay ?? (() => 'never');
+        this.live = options.live ?? true;
+        this.outputChars = options.outputChars ?? 8000;
+    }
+    /** Calls begun and not ended. */
+    get size() {
+        return this.open.size;
+    }
+    /** Whether this call is open in this drive. */
+    has(callId) {
+        return this.open.has(callId);
+    }
+    /**
+     * The harness is about to run `call`: commit its intent. Resolves once the
+     * intent is committed (`{ run: true }`), or at once with the log's answer
+     * when the call id already has an outcome (`{ run: false }`). Rejects if
+     * the intent cannot be committed (the drive lost the session, a write
+     * failed): the drive is halted, and the hook must refuse the call.
+     */
+    begin(call) {
+        if (!call.callId)
+            return Promise.reject(new TypeError(`agentrun-kernel: a built-in ${call.name} call has no call id`));
+        const first = this.begun.get(call.callId);
+        if (first)
+            return this.again(call.callId, first);
+        const start = this.beginOnce(call);
+        this.begun.set(call.callId, start);
+        // A call that will not run is done with now; one that runs is, once its outcome is in (beginOnce's `done`).
+        start.then((s) => { if (!s.run)
+            this.begun.delete(call.callId); }, () => this.begun.delete(call.callId));
+        return start;
+    }
+    /** The same call begun again: never run it twice. Wait for the first begin, then for its outcome, from the log. */
+    async again(callId, first) {
+        const start = await first;
+        if (!start.run)
+            return start;
+        await this.open.get(callId)?.done;
+        // The first call's outcome could not be written: the drive stopped, and this caller stops with it.
+        if (this.ctx.signal.aborted)
+            throw this.ctx.signal.reason;
+        const known = this.ctx.state().effects.get(toolKey(callId));
+        if (known?.status === 'completed')
+            return { run: false, result: { text: String(known.output ?? ''), isError: false } };
+        if (known?.status === 'failed' && known.error)
+            return { run: false, result: { text: failureText(known.error), isError: true, ...(known.error.interrupted ? { interrupted: true } : {}) } };
+        throw new Fatal(`agentrun-kernel: built-in call ${callId} has no recorded outcome`);
+    }
+    async beginOnce(call) {
+        const key = toolKey(call.callId);
+        const known = this.ctx.state().effects.get(key);
+        if (known?.status === 'completed')
+            return { run: false, result: { text: String(known.output ?? ''), isError: false } };
+        if (known?.status === 'failed' && known.error)
+            return { run: false, result: { text: failureText(known.error), isError: true, ...(known.error.interrupted ? { interrupted: true } : {}) } };
+        const replay = call.replay ?? this.replay(call.name);
+        try {
+            if (replay === 'never')
+                await this.options.beforeNever?.(call);
+        }
+        catch (err) {
+            this.ctx.halt?.(err);
+            throw err;
+        }
+        let started;
+        const committed = new Promise((r) => (started = r));
+        let settle;
+        const outcome = new Promise((r) => (settle = r));
+        let failed;
+        let ran = false;
+        const around = this.options.around;
+        const effect = this.ctx.effect(key, { name: `tool.${call.name}`, replay, input: call.input }, async (io) => {
+            let running;
+            // The call itself, once: a wrapper that calls `run` again gets the same promise.
+            const body = () => (running ??= (async () => {
+                ran = true;
+                started();
+                if (this.live)
+                    this.ctx.live({ type: 'tool_start', name: call.name, args: call.input, callId: call.callId });
+                const result = await new Promise((resolve, reject) => {
+                    const stop = () => reject(io.signal.reason ?? new Error('the drive stopped'));
+                    if (io.signal.aborted)
+                        return stop();
+                    io.signal.addEventListener('abort', stop, { once: true });
+                    void outcome.then((o) => {
+                        io.signal.removeEventListener('abort', stop);
+                        resolve(o);
+                    });
+                });
+                if (!result.ok)
+                    throw result.error;
+                return result.text;
+            })());
+            return around ? around(call, body, hostToolIO(io, this.ctx)) : body();
+        });
+        const done = effect.then(() => {
+            // A call its wrapper settled without letting it run never started, on the live stream either.
+            if (this.live && (ran || !around))
+                this.ctx.live({ type: 'tool_end', name: call.name, callId: call.callId });
+        }, (err) => {
+            if (err instanceof EffectFailure) {
+                // Nor one its wrapper failed before it ran.
+                if (this.live && (ran || !around))
+                    this.ctx.live({ type: 'tool_end', name: call.name, callId: call.callId, isError: true });
+                return;
+            }
+            // Not this call's outcome: the drive stopped, or a write failed. Stop the drive.
+            failed = err;
+            this.ctx.halt?.(err);
+        });
+        this.open.set(call.callId, { settle, done });
+        void done.finally(() => { this.open.delete(call.callId); this.begun.delete(call.callId); });
+        await Promise.race([committed, done]);
+        if (failed !== undefined)
+            throw failed;
+        // Settled before its intent (replayed from the log by a concurrent read), or by a wrapper that never let it run: answer from the log.
+        const after = this.ctx.state().effects.get(key);
+        if (!this.open.has(call.callId) && after?.status === 'completed')
+            return { run: false, result: { text: String(after.output ?? ''), isError: false } };
+        // The wrapper failed the call before letting it run: answer with that failure.
+        if (around && !ran) {
+            const error = after?.status === 'failed' && after.error ? failureText(after.error) : 'the tool failed before it ran';
+            return { run: false, result: { text: error, isError: true } };
+        }
+        return { run: true };
+    }
+    /**
+     * The call ended: commit its outcome. `isError` (the tool reported a
+     * failure) commits a failed step with `text` as its error. Resolves once
+     * the outcome is committed (or the drive stopped first). A call this
+     * drive never began (a hook that fired without its `begin`) is begun and
+     * ended here: recorded after the fact.
+     */
+    async end(callId, result) {
+        let open = this.open.get(callId);
+        // Its begin is still committing the intent: end that call, not a second one.
+        if (!open && this.begun.has(callId)) {
+            await this.begun.get(callId).catch(() => undefined);
+            open = this.open.get(callId);
+        }
+        if (!open) {
+            if (this.ctx.isMemoized(toolKey(callId)))
+                return;
+            const started = await this.begin({ callId, name: result.name ?? 'builtin', input: result.input ?? null, replay: 'safe' }).catch(() => undefined);
+            if (!started?.run)
+                return;
+            open = this.open.get(callId);
+            if (!open)
+                return;
+        }
+        const text = clip(result.text, this.outputChars);
+        open.settle(result.isError ? { ok: false, error: new Error(text || 'the tool failed') } : { ok: true, text });
+        await open.done;
+    }
+    /**
+     * The harness can no longer report these calls (its process exited mid-call):
+     * commit each open call as interrupted, "may or may not have taken effect".
+     * A no-op once the drive stopped (the kernel resolves its intents).
+     */
+    async interruptAll(reason = 'the harness stopped before this call reported its result: it may or may not have taken effect') {
+        const open = [...this.open.values()];
+        if (this.ctx.signal.aborted)
+            return;
+        for (const o of open)
+            o.settle({ ok: false, error: new EffectInterrupted(reason) });
+        await Promise.all(open.map((o) => o.done));
+    }
+    /** Wait for every open call to settle, or `ms` to pass. */
+    async settled(ms) {
+        const open = [...this.open.values()].map((o) => o.done);
+        if (!open.length)
+            return;
+        let timer;
+        await Promise.race([Promise.all(open), new Promise((r) => (timer = setTimeout(r, ms)))]);
+        clearTimeout(timer);
+    }
+}
+/** A tool name list as a replay classifier: these are `safe`, the rest `never`. */
+export function replayBy(safe) {
+    const set = new Set(safe);
+    return (name) => (set.has(name) ? 'safe' : 'never');
+}

package/dist/process/inbox.d.ts

@@ -0,0 +1,29 @@
+import type { DriveContext, Submission } from '../kernel/index.js';
+/**
+ * Place submissions before the harness's runtime sees them: one record-only
+ * effect `place:<first id>` whose `placed` names them. Placement is what
+ * takes a submission off `ctx.pending()` and what a withdraw races (a
+ * withdraw committed first wins, and this throws `Restart`: the drive
+ * rebuilds without the withdrawn submission). Sending only after placing
+ * means the kernel's withdraw rule is exact, and a crash between the two
+ * re-sends instead of losing the message.
+ *
+ * The demo's transcript shows a placed submission where its placement is in
+ * the log, so a harness that places right before sending gets its prompts
+ * in the right place for free.
+ */
+export declare function placeSubmissions(ctx: DriveContext, submissions: Submission[], name?: string): Promise<void>;
+export interface WaitOptions {
+    /** How often to read the inbox when the kernel offers no hints. Default 500 ms (5 s with hints). */
+    pollMs?: number;
+    /** Stop waiting (resolves `[]`). `ctx.signal` always stops it too. */
+    signal?: AbortSignal;
+}
+/**
+ * The submissions waiting to be placed, as soon as there are any: refreshes
+ * the log on every hint (`ctx.onHint`) and on a poll. Resolves `[]` when
+ * `ctx.signal` or `options.signal` aborts. A drive that has nothing left to
+ * do should return instead of waiting; this is for a harness that keeps its
+ * runtime up while a turn runs (steers) or for a short idle grace.
+ */
+export declare function waitForSubmissions(ctx: DriveContext, options?: WaitOptions): Promise<Submission[]>;

package/dist/process/inbox.js

@@ -0,0 +1,52 @@
+/**
+ * Place submissions before the harness's runtime sees them: one record-only
+ * effect `place:<first id>` whose `placed` names them. Placement is what
+ * takes a submission off `ctx.pending()` and what a withdraw races (a
+ * withdraw committed first wins, and this throws `Restart`: the drive
+ * rebuilds without the withdrawn submission). Sending only after placing
+ * means the kernel's withdraw rule is exact, and a crash between the two
+ * re-sends instead of losing the message.
+ *
+ * The demo's transcript shows a placed submission where its placement is in
+ * the log, so a harness that places right before sending gets its prompts
+ * in the right place for free.
+ */
+export async function placeSubmissions(ctx, submissions, name = 'place') {
+    if (submissions.length === 0)
+        return;
+    const ids = submissions.map((s) => s.id);
+    await ctx.effect(`place:${ids[0]}`, { name, replay: 'safe', input: { ids }, placed: ids }, async () => true);
+}
+/**
+ * The submissions waiting to be placed, as soon as there are any: refreshes
+ * the log on every hint (`ctx.onHint`) and on a poll. Resolves `[]` when
+ * `ctx.signal` or `options.signal` aborts. A drive that has nothing left to
+ * do should return instead of waiting; this is for a harness that keeps its
+ * runtime up while a turn runs (steers) or for a short idle grace.
+ */
+export async function waitForSubmissions(ctx, options = {}) {
+    const signals = [ctx.signal, options.signal].filter((s) => !!s);
+    const stop = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+    const pollMs = options.pollMs ?? (ctx.onHint ? 5000 : 500);
+    for (;;) {
+        if (stop.aborted)
+            return [];
+        const pending = ctx.pending();
+        if (pending.length > 0)
+            return pending;
+        await new Promise((resolve) => {
+            const timer = setTimeout(done, pollMs);
+            const off = ctx.onHint?.(() => done());
+            stop.addEventListener('abort', done, { once: true });
+            function done() {
+                clearTimeout(timer);
+                off?.();
+                stop.removeEventListener('abort', done);
+                resolve();
+            }
+        });
+        if (stop.aborted)
+            return [];
+        await ctx.refresh();
+    }
+}

package/dist/process/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./records.js";
+export * from "./recovery.js";
+export * from "./journal.js";
+export * from "./tools.js";
+export * from "./builtins.js";
+export * from "./inbox.js";
+export * from "./tail.js";
+export * from "./zod.js";
+export * from "./settle.js";

package/dist/process/index.js

@@ -0,0 +1,11 @@
+// The shared layer for harnesses that run as a child process, copied from another project (each file's header
+// says from where, and UPSTREAM.json records it), on AgentRun's kernel (../kernel).
+export * from "./records.js";
+export * from "./recovery.js";
+export * from "./journal.js";
+export * from "./tools.js";
+export * from "./builtins.js";
+export * from "./inbox.js";
+export * from "./tail.js";
+export * from "./zod.js";
+export * from "./settle.js";