@astrosheep/keiyaku 4.1.1 → 4.1.2

package/build/src/akuma/body-supervisor.js

@@ -0,0 +1,89 @@
+import { abortableDelay } from "./abort.js";
+import { heartExists, readHeart } from "./heart/index.js";
+const BODY_CONTROL_OBSERVATION_MS = 100;
+export const CONTROL_RESPONSE_MS = 1_000;
+export class BodySupervisor {
+    paths;
+    bodySequence;
+    leash;
+    signal;
+    controller = new AbortController();
+    finished = new AbortController();
+    observer;
+    waiter;
+    observation;
+    stopping;
+    constructor(paths, bodySequence, leash, observation) {
+        this.paths = paths;
+        this.bodySequence = bodySequence;
+        this.leash = leash;
+        this.signal = this.controller.signal;
+        this.observation = observation;
+        this.observer = this.observe();
+    }
+    static async open(paths, bodySequence, leash) {
+        return new BodySupervisor(paths, bodySequence, leash, await readHeart(paths));
+    }
+    get reason() {
+        return this.stopping;
+    }
+    current() {
+        return this.observation;
+    }
+    async recordHung(diagnostic, at) {
+        await this.leash.recordBodyHung(this.paths, { sequence: this.bodySequence, diagnostic, at });
+    }
+    async refresh() {
+        this.publish(await readHeart(this.paths));
+        return this.observation;
+    }
+    next(after) {
+        if (this.observation !== after)
+            return Promise.resolve(this.observation);
+        return new Promise((resolve) => {
+            this.waiter = resolve;
+        });
+    }
+    cancel(reason) {
+        if (this.stopping !== undefined)
+            return;
+        this.stopping = reason;
+        this.controller.abort(new Error(reason === "control" ? "Akuma Body interrupted by durable control" : "Akuma Heart disappeared"));
+        this.waiter?.(this.observation);
+        this.waiter = undefined;
+    }
+    async close() {
+        this.finished.abort();
+        await this.observer;
+        this.waiter = undefined;
+    }
+    publish(snapshot) {
+        this.observation = snapshot;
+        this.waiter?.(snapshot);
+        this.waiter = undefined;
+    }
+    async observe() {
+        for (;;) {
+            const snapshot = this.observation;
+            if (!(await heartExists(this.paths)))
+                return this.cancel("heart-gone");
+            if (snapshot.stop?.bodySequence === this.bodySequence || snapshot.pause?.bodySequence === this.bodySequence) {
+                return this.cancel("control");
+            }
+            try {
+                await abortableDelay(BODY_CONTROL_OBSERVATION_MS, this.finished.signal);
+            }
+            catch {
+                return;
+            }
+            try {
+                await this.refresh();
+            }
+            catch (error) {
+                if (await heartExists(this.paths))
+                    throw error;
+                return this.cancel("heart-gone");
+            }
+        }
+    }
+}

package/build/src/akuma/body.d.ts

@@ -4,7 +4,7 @@ import type { ProviderAdapter } from "./provider.js";
 import { type UpstreamExecutionPort, type RequestChildLaunch } from "./request-serve.js";
 import { type OwnedProcess, type RunLogReference } from "../runtime/proc/run.js";
 export declare const LEASH_HELD_EXIT = 75;
-export { CONTROL_RESPONSE_MS } from "./body-turn.js";
+export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 export type BodyLaunch = Readonly<{
     paths: AkumaPaths;
     seed?: Omit<Soul, "createdAt">;

package/build/src/akuma/body.js

@@ -1,13 +1,14 @@
 import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
-import { BodySupervisor, driveTurn, turnRecipe } from "./body-turn.js";
+import { BodySupervisor } from "./body-supervisor.js";
+import { driveTurn, turnRecipe } from "./turn-drive.js";
 import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, readNonterminalRequests, watchHeart, } from "./heart/index.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
 import { handoffProcess, spawnDetachedProcess, } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 100;
 export const LEASH_HELD_EXIT = 75;
-export { CONTROL_RESPONSE_MS } from "./body-turn.js";
+export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function missing(error) {
     return isHeartAbsent(error) || error.code === "ENOENT";
 }

package/build/src/akuma/projection-read.d.ts

@@ -0,0 +1,17 @@
+import type { ActivitySnapshot, TurnLedger } from "./projection.js";
+import type { HistoryCursor, HistoryPage } from "./projection.js";
+export declare function ordinarySnapshotBudget(ordinaryBudget?: number): Readonly<{
+    tail: number;
+    voice: number;
+}>;
+export declare function selectSnapshot(ledger: TurnLedger, input: Readonly<{
+    aperture: "monitoring" | "receipt";
+    budget?: Readonly<{
+        tail: number;
+        voice?: number;
+    }>;
+}>): Readonly<{
+    snapshot: ActivitySnapshot;
+    ordinaryCount: number;
+}>;
+export declare function selectHistory(ledger: TurnLedger, cursor: HistoryCursor): HistoryPage;

package/build/src/akuma/projection-read.js

@@ -0,0 +1,135 @@
+const DEFAULT_TAIL = 3;
+const DEFAULT_VOICE = 3;
+const REPORTED_CHANGE_LIMIT = 5;
+const EMPTY_REPORTED = { reportedChanges: [], reportedChangesOmitted: 0 };
+function assembleEntries(ledger, window, selected) {
+    const windowRows = new Set(window);
+    const result = [];
+    let hidden = 0;
+    const flushGap = () => {
+        if (hidden === 0)
+            return;
+        result.push({ kind: "gap", count: hidden });
+        hidden = 0;
+    };
+    for (const row of ledger.rows) {
+        if (windowRows.has(row) && !selected.has(row)) {
+            hidden += 1;
+            continue;
+        }
+        if (!selected.has(row))
+            continue;
+        flushGap();
+        if (row.kind !== "turn" && row.kind !== "outcome" && !(row.kind === "tool" && row.state === "unsettled")) {
+            result.push({ kind: "row", row: row });
+        }
+    }
+    flushGap();
+    return result;
+}
+const DEFAULT_ORDINARY = DEFAULT_TAIL + DEFAULT_VOICE;
+export function ordinarySnapshotBudget(ordinaryBudget = DEFAULT_ORDINARY) {
+    const tail = Math.min(DEFAULT_TAIL, Math.max(0, ordinaryBudget));
+    return { tail, voice: Math.min(DEFAULT_VOICE, Math.max(0, ordinaryBudget) - tail) };
+}
+function isSuccessfulFileChange(row) {
+    return (row.kind === "tool" && typeof row.state === "object" && row.state.status === "ok" && row.call.kind === "fileChange");
+}
+function flattenReportedChanges(rows) {
+    return rows.flatMap((row) => {
+        if (!isSuccessfulFileChange(row))
+            return [];
+        return row.call.changes.map((change) => ({
+            sequence: row.sequence,
+            at: row.at,
+            op: change.op,
+            path: change.path,
+            ...(change.diffstat === undefined ? {} : { diffstat: change.diffstat }),
+        }));
+    });
+}
+function summarizeReportedChanges(rows) {
+    const eligible = flattenReportedChanges(rows);
+    return {
+        reportedChanges: eligible.slice(-REPORTED_CHANGE_LIMIT),
+        reportedChangesOmitted: Math.max(0, eligible.length - REPORTED_CHANGE_LIMIT),
+    };
+}
+function frontierReportedChanges(ledger) {
+    if (ledger.openTurn !== undefined)
+        return summarizeReportedChanges(ledger.openTurn.rows);
+    const closed = ledger.turns.findLast((turn) => turn.kind === "closed");
+    return closed === undefined ? EMPTY_REPORTED : summarizeReportedChanges(closed.rows);
+}
+function isPendingTell(row) {
+    return row.kind === "tell" && row.state === "pending";
+}
+function isToldTell(row) {
+    return row.kind === "tell" && row.state === "told";
+}
+function isActiveTool(row) {
+    return row.kind === "tool" && row.state === "active";
+}
+export function selectSnapshot(ledger, input) {
+    const budget = input.budget ?? { tail: DEFAULT_TAIL, voice: DEFAULT_VOICE };
+    if (ledger.turns.length === 0 && !ledger.rows.some((row) => row.kind === "tell"))
+        return { snapshot: { kind: "unborn", entries: [], omitted: 0, ...EMPTY_REPORTED }, ordinaryCount: 0 };
+    const pending = ledger.rows.filter(isPendingTell);
+    const latestTold = input.aperture === "monitoring" ? ledger.rows.findLast(isToldTell) : undefined;
+    const pins = latestTold === undefined ? pending : [...pending, latestTold];
+    const reported = frontierReportedChanges(ledger);
+    if (ledger.openTurn !== undefined) {
+        const window = ledger.openTurn.rows;
+        const pinSet = new Set([...window.filter(isActiveTool), ...pins]);
+        const ordinary = window.filter((row) => !pinSet.has(row));
+        const tailCount = Math.max(0, budget.tail);
+        const tail = tailCount === 0 ? [] : ordinary.slice(-tailCount);
+        const tailSet = new Set(tail);
+        const voiceCount = Math.max(0, budget.voice ?? DEFAULT_VOICE);
+        const voiceCandidates = ordinary.filter((row) => !tailSet.has(row) && (row.kind === "said" || row.kind === "thought"));
+        const voice = voiceCount === 0 ? [] : voiceCandidates.slice(-voiceCount);
+        const selected = new Set([...pinSet, ...tail, ...voice]);
+        const omitted = window.filter((row) => !selected.has(row)).length;
+        return {
+            snapshot: {
+                kind: "open",
+                turn: ledger.openTurn.turn,
+                entries: assembleEntries(ledger, window, selected),
+                omitted,
+                ...reported,
+            },
+            ordinaryCount: tail.length + voice.length,
+        };
+    }
+    return {
+        snapshot: {
+            kind: "idle",
+            ...(ledger.latestOutcome === undefined ? {} : { outcome: ledger.latestOutcome }),
+            entries: assembleEntries(ledger, [], new Set(pins)),
+            omitted: 0,
+            ...reported,
+        },
+        ordinaryCount: 0,
+    };
+}
+export function selectHistory(ledger, cursor) {
+    const eligible = ledger.rows.filter((row) => cursor.before !== undefined
+        ? row.sequence < cursor.before
+        : cursor.since !== undefined
+            ? row.sequence > cursor.since
+            : true);
+    const rows = cursor.since !== undefined ? eligible.slice(0, cursor.limit) : eligible.slice(-cursor.limit);
+    const omitted = Math.max(0, eligible.length - rows.length);
+    const historyLost = cursor.since !== undefined
+        ? ledger.rows[0] !== undefined && ledger.rows[0].sequence > cursor.since + 1
+        : ledger.retained.lowestRetained !== null && ledger.retained.lowestRetained > 1 && omitted === 0;
+    return {
+        rows,
+        omitted,
+        hasEarlier: cursor.since === undefined && eligible.length > rows.length,
+        hasLater: cursor.since !== undefined && eligible.length > rows.length,
+        historyLost,
+        lowestRetained: ledger.retained.lowestRetained,
+        highest: ledger.retained.highest,
+    };
+}

package/build/src/akuma/projection.d.ts

@@ -172,21 +172,4 @@ export type TurnLedger = Readonly<{
 }>;
 /** Fold the retained fact timeline into Turn-owned rows without inventing provider facts. */
 export declare function projectTurns(facts: readonly TimelineFact[], retained?: RetainedWindow): TurnLedger;
-/** Split one nonnegative ordinary allowance into newest tail first, then pre-tail voice. */
-export declare function ordinarySnapshotBudget(ordinaryBudget?: number): Readonly<{
-    tail: number;
-    voice: number;
-}>;
-/** Select one current Turn, one latest outcome, or no focus; pending tells stay actionable. */
-export declare function selectSnapshot(ledger: TurnLedger, input: Readonly<{
-    aperture: "monitoring" | "receipt";
-    budget?: Readonly<{
-        tail: number;
-        voice?: number;
-    }>;
-}>): Readonly<{
-    snapshot: ActivitySnapshot;
-    ordinaryCount: number;
-}>;
-export declare function selectHistory(ledger: TurnLedger, cursor: HistoryCursor): HistoryPage;
-export {};
+export { ordinarySnapshotBudget, selectHistory, selectSnapshot } from "./projection-read.js";

package/build/src/akuma/projection.js

@@ -1,8 +1,4 @@
 import { decodeAgentEvent } from "./provider.js";
-const DEFAULT_TAIL = 3;
-const DEFAULT_VOICE = 3;
-const REPORTED_CHANGE_LIMIT = 5;
-const EMPTY_REPORTED = { reportedChanges: [], reportedChangesOmitted: 0 };
 function duration(startedAt, completedAt) {
     const start = Date.parse(startedAt);
     const end = Date.parse(completedAt);
@@ -124,6 +120,25 @@ function finishTurn(turn) {
     }
     return { kind: "open", turn: turn.turn, rows: rows };
 }
+function finishLedger(state, retained) {
+    const turns = state.turns.map(finishTurn);
+    const rows = [
+        ...turns.flatMap((turn) => [turn.turn, ...turn.rows, ...(turn.kind === "closed" ? [turn.outcome] : [])]),
+        ...state.tells,
+        ...state.orphanRows,
+        ...state.orphanOutcomes,
+    ].sort((left, right) => left.sequence - right.sequence);
+    const frontier = turns.at(-1);
+    const openTurn = frontier?.kind === "open" ? frontier : undefined;
+    const latestOutcome = rows.findLast((row) => row.kind === "outcome");
+    return {
+        rows,
+        turns,
+        retained,
+        ...(openTurn === undefined ? {} : { openTurn }),
+        ...(latestOutcome === undefined ? {} : { latestOutcome }),
+    };
+}
 /** Fold the retained fact timeline into Turn-owned rows without inventing provider facts. */
 export function projectTurns(facts, retained = {
     lowestRetained: facts[0]?.sequence ?? null,
@@ -196,155 +211,6 @@ export function projectTurns(facts, retained = {
             projectActivityEvent(state, fact);
         }
     }
-    const turns = state.turns.map(finishTurn);
-    const rows = [
-        ...turns.flatMap((turn) => [turn.turn, ...turn.rows, ...(turn.kind === "closed" ? [turn.outcome] : [])]),
-        ...state.tells,
-        ...state.orphanRows,
-        ...state.orphanOutcomes,
-    ].sort((left, right) => left.sequence - right.sequence);
-    const frontier = turns.at(-1);
-    const openTurn = frontier?.kind === "open" ? frontier : undefined;
-    const latestOutcome = rows.findLast((row) => row.kind === "outcome");
-    return {
-        rows,
-        turns,
-        retained,
-        ...(openTurn === undefined ? {} : { openTurn }),
-        ...(latestOutcome === undefined ? {} : { latestOutcome }),
-    };
-}
-function assembleEntries(ledger, window, selected) {
-    const windowRows = new Set(window);
-    const result = [];
-    let hidden = 0;
-    const flushGap = () => {
-        if (hidden === 0)
-            return;
-        result.push({ kind: "gap", count: hidden });
-        hidden = 0;
-    };
-    for (const row of ledger.rows) {
-        if (windowRows.has(row) && !selected.has(row)) {
-            hidden += 1;
-            continue;
-        }
-        if (!selected.has(row))
-            continue;
-        flushGap();
-        if (row.kind !== "turn" && row.kind !== "outcome" && !(row.kind === "tool" && row.state === "unsettled")) {
-            result.push({ kind: "row", row: row });
-        }
-    }
-    flushGap();
-    return result;
-}
-const DEFAULT_ORDINARY = DEFAULT_TAIL + DEFAULT_VOICE;
-/** Split one nonnegative ordinary allowance into newest tail first, then pre-tail voice. */
-export function ordinarySnapshotBudget(ordinaryBudget = DEFAULT_ORDINARY) {
-    const tail = Math.min(DEFAULT_TAIL, Math.max(0, ordinaryBudget));
-    return { tail, voice: Math.min(DEFAULT_VOICE, Math.max(0, ordinaryBudget) - tail) };
-}
-function isSuccessfulFileChange(row) {
-    return (row.kind === "tool" && typeof row.state === "object" && row.state.status === "ok" && row.call.kind === "fileChange");
-}
-function flattenReportedChanges(rows) {
-    return rows.flatMap((row) => {
-        if (!isSuccessfulFileChange(row))
-            return [];
-        return row.call.changes.map((change) => ({
-            sequence: row.sequence,
-            at: row.at,
-            op: change.op,
-            path: change.path,
-            ...(change.diffstat === undefined ? {} : { diffstat: change.diffstat }),
-        }));
-    });
-}
-function summarizeReportedChanges(rows) {
-    const eligible = flattenReportedChanges(rows);
-    return {
-        reportedChanges: eligible.slice(-REPORTED_CHANGE_LIMIT),
-        reportedChangesOmitted: Math.max(0, eligible.length - REPORTED_CHANGE_LIMIT),
-    };
-}
-function frontierReportedChanges(ledger) {
-    if (ledger.openTurn !== undefined)
-        return summarizeReportedChanges(ledger.openTurn.rows);
-    const closed = ledger.turns.findLast((turn) => turn.kind === "closed");
-    return closed === undefined ? EMPTY_REPORTED : summarizeReportedChanges(closed.rows);
-}
-function isPendingTell(row) {
-    return row.kind === "tell" && row.state === "pending";
-}
-function isToldTell(row) {
-    return row.kind === "tell" && row.state === "told";
-}
-function isActiveTool(row) {
-    return row.kind === "tool" && row.state === "active";
-}
-/** Select one current Turn, one latest outcome, or no focus; pending tells stay actionable. */
-export function selectSnapshot(ledger, input) {
-    const budget = input.budget ?? { tail: DEFAULT_TAIL, voice: DEFAULT_VOICE };
-    if (ledger.turns.length === 0 && !ledger.rows.some((row) => row.kind === "tell")) {
-        return { snapshot: { kind: "unborn", entries: [], omitted: 0, ...EMPTY_REPORTED }, ordinaryCount: 0 };
-    }
-    const pending = ledger.rows.filter(isPendingTell);
-    const latestTold = input.aperture === "monitoring" ? ledger.rows.findLast(isToldTell) : undefined;
-    const pins = latestTold === undefined ? pending : [...pending, latestTold];
-    const reported = frontierReportedChanges(ledger);
-    if (ledger.openTurn !== undefined) {
-        const window = ledger.openTurn.rows;
-        const pinSet = new Set([...window.filter(isActiveTool), ...pins]);
-        const ordinary = window.filter((row) => !pinSet.has(row));
-        const tailCount = Math.max(0, budget.tail);
-        const tail = tailCount === 0 ? [] : ordinary.slice(-tailCount);
-        const tailSet = new Set(tail);
-        const voiceCount = Math.max(0, budget.voice ?? DEFAULT_VOICE);
-        const voiceCandidates = ordinary.filter((row) => !tailSet.has(row) && (row.kind === "said" || row.kind === "thought"));
-        const voice = voiceCount === 0 ? [] : voiceCandidates.slice(-voiceCount);
-        const selected = new Set([...pinSet, ...tail, ...voice]);
-        const omitted = window.filter((row) => !selected.has(row)).length;
-        return {
-            snapshot: {
-                kind: "open",
-                turn: ledger.openTurn.turn,
-                entries: assembleEntries(ledger, window, selected),
-                omitted,
-                ...reported,
-            },
-            ordinaryCount: tail.length + voice.length,
-        };
-    }
-    return {
-        snapshot: {
-            kind: "idle",
-            ...(ledger.latestOutcome === undefined ? {} : { outcome: ledger.latestOutcome }),
-            entries: assembleEntries(ledger, [], new Set(pins)),
-            omitted: 0,
-            ...reported,
-        },
-        ordinaryCount: 0,
-    };
-}
-export function selectHistory(ledger, cursor) {
-    const eligible = ledger.rows.filter((row) => cursor.before !== undefined
-        ? row.sequence < cursor.before
-        : cursor.since !== undefined
-            ? row.sequence > cursor.since
-            : true);
-    const rows = cursor.since !== undefined ? eligible.slice(0, cursor.limit) : eligible.slice(-cursor.limit);
-    const omitted = Math.max(0, eligible.length - rows.length);
-    const historyLost = cursor.since !== undefined
-        ? ledger.rows[0] !== undefined && ledger.rows[0].sequence > cursor.since + 1
-        : ledger.retained.lowestRetained !== null && ledger.retained.lowestRetained > 1 && omitted === 0;
-    return {
-        rows,
-        omitted,
-        hasEarlier: cursor.since === undefined && eligible.length > rows.length,
-        hasLater: cursor.since !== undefined && eligible.length > rows.length,
-        historyLost,
-        lowestRetained: ledger.retained.lowestRetained,
-        highest: ledger.retained.highest,
-    };
+    return finishLedger(state, retained);
 }
+export { ordinarySnapshotBudget, selectHistory, selectSnapshot } from "./projection-read.js";

package/build/src/akuma/request-execution.d.ts

@@ -0,0 +1,6 @@
+import type { UpstreamRequestService } from "./heart/index.js";
+import type { ServeInput, UpstreamFact } from "./request-serve.js";
+export declare function executeRequest(input: ServeInput, request: UpstreamFact): Promise<Readonly<{
+    result: unknown;
+    service?: UpstreamRequestService;
+}>>;

package/build/src/akuma/request-execution.js

@@ -0,0 +1,86 @@
+export async function executeRequest(input, request) {
+    if (input.upstream === undefined)
+        throw new Error("upstream execution port is unavailable");
+    if (request.action === "akuma.wait")
+        return {
+            result: await input.upstream.wait({
+                targets: request.targets,
+                completion: request.completion,
+                ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
+                signal: input.signal,
+            }),
+            service: { action: request.action },
+        };
+    if (request.action === "akuma.tell")
+        return {
+            result: await input.upstream.tell({
+                target: request.target,
+                body: request.body,
+                tellId: request.id,
+                recordedAt: request.admittedAt,
+                signal: input.signal,
+            }),
+            service: { action: request.action, target: request.target, tellId: request.id },
+        };
+    if (request.action === "akuma.kill") {
+        const served = await input.upstream.kill({ targets: request.targets, signal: input.signal });
+        return { result: served.result, service: { action: request.action, results: served.service } };
+    }
+    if (request.action === "contract.deliver") {
+        const served = await input.upstream.deliver({
+            repoRoot: request.repoRoot,
+            contractId: request.contractId,
+            ...(request.message === undefined ? {} : { message: request.message }),
+            includeDirty: request.includeDirty,
+            materializeConflict: request.materializeConflict,
+            requester: request.requester,
+            signal: input.signal,
+        });
+        return {
+            result: served.result,
+            ...(served.deliveryFactId === undefined
+                ? {}
+                : {
+                    service: {
+                        action: request.action,
+                        repoRoot: request.repoRoot,
+                        contractId: request.contractId,
+                        deliveryFactId: served.deliveryFactId,
+                    },
+                }),
+        };
+    }
+    if (request.action === "contract.review") {
+        const served = await input.upstream.review({
+            repoRoot: request.repoRoot,
+            contractId: request.contractId,
+            verdict: request.verdict,
+            ...(request.summary === undefined ? {} : { summary: request.summary }),
+            requester: request.requester,
+            signal: input.signal,
+        });
+        return {
+            result: served.result,
+            ...(served.reviewFactId === undefined
+                ? {}
+                : {
+                    service: {
+                        action: request.action,
+                        repoRoot: request.repoRoot,
+                        contractId: request.contractId,
+                        reviewFactId: served.reviewFactId,
+                    },
+                }),
+        };
+    }
+    const task = request;
+    return {
+        result: await input.upstream.task({
+            world: task.world,
+            request: task.request,
+            requester: task.requester,
+            signal: input.signal,
+        }),
+        service: { action: task.action },
+    };
+}

package/build/src/akuma/request-serve.d.ts

@@ -1,5 +1,6 @@
-import { type KillEvidence, type Soul } from "./heart/index.js";
+import { type KillEvidence, type RequestFact, type Soul } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
+import { type StructuralRequestClaim } from "./request-wire.js";
 import { type TaskMutationRequest } from "../task/mutation.js";
 export type RequestChildLaunch = Readonly<{
     paths: AkumaPaths;
@@ -67,6 +68,16 @@ type PumpInput = Readonly<{
     upstream?: UpstreamExecutionPort;
     signal: AbortSignal;
 }>;
+export type ServeInput = Omit<PumpInput, "bodySequence"> & Readonly<{
+    directory: string;
+    claim: StructuralRequestClaim;
+    admissionOpen(): boolean;
+}>;
+export type UpstreamFact = Exclude<Extract<RequestFact, {
+    state: "admitted";
+}>, Extract<RequestFact, {
+    action: "akuma.call";
+}>>;
 export declare class BodyRequestPump {
     private readonly input;
     readonly directory: string;