@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/akuma/requests.js

@@ -1,16 +1,10 @@
 import { randomUUID } from "node:crypto";
-import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
-import { isAbsolute, join, resolve } from "node:path";
-import { HeldAkumaLeash, admitRequest, readNonterminalRequests, readRequest, readSoul, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
-import { parseAkuId, pathsForAkuId, archetypeName, worldRootForAkumaPaths, } from "./identity.js";
-import { BIRTH_TIMEOUT_MS, publishAkuma } from "./publication.js";
+import { access, readFile } from "node:fs/promises";
 import { abortableDelay } from "./abort.js";
 import { AKUMA_REQUESTS_ENV } from "./provider.js";
-import { decodeProviderOptions, decodeReadonlyRestraint } from "./provider-recipe.js";
-import { resolveProviderExecution } from "./providers/index.js";
-import { decodeAllowedActions } from "./allowed.js";
+import { absolute, atomicJson, decodeReceipt, receiptPath, requestPath, requestPayload, } from "./request-wire.js";
+import { isTaskMutationAction } from "../task/mutation.js";
 const POLL_MS = 25;
-const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 export class AkumaBodyRequestError extends Error {
     outcome;
     diagnostic;
@@ -22,268 +16,6 @@ export class AkumaBodyRequestError extends Error {
         this.name = "AkumaBodyRequestError";
     }
 }
-function diagnostic(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function exactKeys(value, expected) {
-    const actual = Object.keys(value).sort();
-    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
-}
-function absolute(value) {
-    return typeof value === "string" && isAbsolute(value) && resolve(value) === value;
-}
-function decodeRecipe(value, cwd) {
-    const recipe = object(value);
-    if (recipe === null)
-        return null;
-    const expectedKeys = [
-        ...(recipe.description === undefined ? [] : ["description"]),
-        "allowed",
-        "options",
-        "provider",
-        ...(recipe.readonly === undefined ? [] : ["readonly"]),
-    ];
-    if (!exactKeys(recipe, expectedKeys))
-        return null;
-    if (recipe.description !== undefined
-        && (typeof recipe.description !== "string" || recipe.description.trim().length === 0))
-        return null;
-    try {
-        const selected = resolveProviderExecution(recipe.provider);
-        const provider = selected.execution;
-        const adapter = selected.adapter;
-        const decodedOptions = decodeProviderOptions(recipe.options);
-        const readonly = recipe.readonly === undefined ? undefined : decodeReadonlyRestraint(recipe.readonly);
-        if ((decodedOptions.readonly === true) !== (readonly !== undefined))
-            return null;
-        const confinement = adapter.confinement({ cwd, options: decodedOptions });
-        return Object.freeze({
-            ...(recipe.description === undefined ? {} : { description: recipe.description }),
-            allowed: decodeAllowedActions(recipe.allowed),
-            provider,
-            options: decodedOptions,
-            ...(readonly === undefined ? {} : { readonly }),
-            confinement,
-        });
-    }
-    catch {
-        return null;
-    }
-}
-function canonicalAkuId(value) {
-    if (typeof value !== "string")
-        return null;
-    try {
-        const id = parseAkuId(value).id;
-        return id === value ? id : null;
-    }
-    catch {
-        return null;
-    }
-}
-function canonicalTargets(value) {
-    if (!Array.isArray(value) || value.length === 0)
-        return null;
-    const ids = [];
-    for (const item of value) {
-        const id = canonicalAkuId(item);
-        if (id === null)
-            return null;
-        if (ids.length > 0 && Buffer.compare(Buffer.from(ids.at(-1)), Buffer.from(id)) >= 0)
-            return null;
-        ids.push(id);
-    }
-    return ids;
-}
-function decodeCallClaim(id, payload) {
-    const expected = [
-        "archetype",
-        "body",
-        ...(payload.cwd === undefined ? [] : ["cwd"]),
-        "recipe",
-        "world",
-    ];
-    if (!exactKeys(payload, expected)
-        || typeof payload.body !== "string"
-        || !absolute(payload.world))
-        return null;
-    if (payload.cwd !== undefined && !absolute(payload.cwd))
-        return null;
-    try {
-        archetypeName(payload.archetype);
-    }
-    catch {
-        return null;
-    }
-    return {
-        id,
-        action: "akuma.call",
-        world: payload.world,
-        archetype: payload.archetype,
-        body: payload.body,
-        recipe: payload.recipe,
-        ...(payload.cwd === undefined ? {} : { cwd: payload.cwd }),
-    };
-}
-function decodeWaitClaim(id, payload) {
-    const expected = [
-        "completion",
-        "targets",
-        ...(payload.timeoutMs === undefined ? [] : ["timeoutMs"]),
-    ];
-    const targets = canonicalTargets(payload.targets);
-    if (!exactKeys(payload, expected)
-        || targets === null
-        || (payload.completion !== "any" && payload.completion !== "all"))
-        return null;
-    if (payload.timeoutMs !== undefined
-        && (!Number.isSafeInteger(payload.timeoutMs) || payload.timeoutMs < 0))
-        return null;
-    return {
-        id,
-        action: "akuma.wait",
-        targets,
-        completion: payload.completion,
-        ...(payload.timeoutMs === undefined ? {} : { timeoutMs: payload.timeoutMs }),
-    };
-}
-function decodeTellClaim(id, payload) {
-    const target = canonicalAkuId(payload.target);
-    if (!exactKeys(payload, ["body", "target"])
-        || target === null
-        || typeof payload.body !== "string")
-        return null;
-    return { id, action: "akuma.tell", target, body: payload.body };
-}
-function decodeKillClaim(id, payload) {
-    const targets = canonicalTargets(payload.targets);
-    return exactKeys(payload, ["targets"]) && targets !== null
-        ? { id, action: "akuma.kill", targets }
-        : null;
-}
-function decodeClaim(bytes, fileId) {
-    let decoded;
-    try {
-        decoded = JSON.parse(bytes);
-    }
-    catch {
-        return null;
-    }
-    const value = object(decoded);
-    if (value === null
-        || !exactKeys(value, ["action", "id", "payload"])
-        || value.id !== fileId
-        || typeof value.id !== "string"
-        || !UUID.test(value.id))
-        return null;
-    const payload = object(value.payload);
-    if (payload === null)
-        return null;
-    if (value.action === "akuma.call")
-        return decodeCallClaim(value.id, payload);
-    if (value.action === "akuma.wait")
-        return decodeWaitClaim(value.id, payload);
-    if (value.action === "akuma.tell")
-        return decodeTellClaim(value.id, payload);
-    if (value.action === "akuma.kill")
-        return decodeKillClaim(value.id, payload);
-    return null;
-}
-function decodeUpstreamFailure(value) {
-    const failure = object(value);
-    if (failure === null)
-        return null;
-    if (failure.kind === "akuma-not-born" && exactKeys(failure, ["id", "kind"])) {
-        const id = canonicalAkuId(failure.id);
-        return id === null ? null : { kind: failure.kind, id };
-    }
-    if (failure.kind === "failed"
-        && exactKeys(failure, ["diagnostic", "kind"])
-        && typeof failure.diagnostic === "string") {
-        return { kind: failure.kind, diagnostic: failure.diagnostic };
-    }
-    return null;
-}
-function decodeUpstreamOutcome(value) {
-    const outcome = object(value);
-    if (outcome?.kind === "returned" && exactKeys(outcome, ["kind", "result"])) {
-        return { kind: outcome.kind, result: outcome.result };
-    }
-    if (outcome?.kind !== "failed" || !exactKeys(outcome, ["failure", "kind"]))
-        return null;
-    const failure = decodeUpstreamFailure(outcome.failure);
-    return failure === null ? null : { kind: outcome.kind, failure };
-}
-function decodeReceipt(bytes, requestId, action) {
-    let decoded;
-    try {
-        decoded = JSON.parse(bytes);
-    }
-    catch {
-        return null;
-    }
-    const value = object(decoded);
-    if (value === null || value.id !== requestId || value.action !== action)
-        return null;
-    if (action === "akuma.call"
-        && value.state === "served"
-        && exactKeys(value, ["action", "child", "id", "state"])) {
-        const child = canonicalAkuId(value.child);
-        return child === null ? null : { id: requestId, action, state: value.state, child };
-    }
-    if (action !== "akuma.call"
-        && value.state === "served"
-        && exactKeys(value, ["action", "id", "outcome", "state"])) {
-        const outcome = decodeUpstreamOutcome(value.outcome);
-        return outcome === null ? null : { id: requestId, action, state: value.state, outcome };
-    }
-    if (value.state === "refused"
-        && exactKeys(value, ["action", "diagnostic", "id", "state"])
-        && typeof value.diagnostic === "string") {
-        return { id: requestId, action, state: value.state, diagnostic: value.diagnostic };
-    }
-    if (value.state === "voided"
-        && exactKeys(value, ["action", "evidence", "id", "state"])
-        && typeof value.evidence === "string") {
-        return { id: requestId, action, state: value.state, evidence: value.evidence };
-    }
-    return null;
-}
-async function atomicJson(path, value) {
-    const temporary = `${path}.${randomUUID()}.tmp`;
-    try {
-        await writeFile(temporary, `${JSON.stringify(value)}\n`, { flag: "wx" });
-        await rename(temporary, path);
-    }
-    finally {
-        await rm(temporary, { force: true });
-    }
-}
-function receiptFor(fact) {
-    if (fact.action === "akuma.call" && fact.state === "served") {
-        return { id: fact.id, action: fact.action, state: fact.state, child: fact.child };
-    }
-    if (fact.state === "refused") {
-        return { id: fact.id, action: fact.action, state: fact.state, diagnostic: fact.diagnostic };
-    }
-    if (fact.state === "voided")
-        return { id: fact.id, action: fact.action, state: fact.state, evidence: fact.evidence };
-    return null;
-}
-async function projectReceipt(directory, fact, outcome) {
-    const receipt = outcome === undefined
-        ? receiptFor(fact)
-        : fact.action === "akuma.call" || fact.state !== "served"
-            ? null
-            : { id: fact.id, action: fact.action, state: fact.state, outcome };
-    if (receipt !== null)
-        await atomicJson(join(directory, `${fact.id}.receipt.json`), receipt);
-}
 export function injectedBodyRequests() {
     const directory = process.env[AKUMA_REQUESTS_ENV];
     if (directory === undefined)
@@ -293,14 +25,18 @@ export function injectedBodyRequests() {
     return directory;
 }
 async function requestBody(input) {
-    const { id, action, ...payload } = input.claim;
-    await atomicJson(join(input.directory, `${id}.request.json`), { id, action, payload });
-    const receiptPath = join(input.directory, `${id}.receipt.json`);
+    input.signal?.throwIfAborted();
+    await atomicJson(requestPath(input.directory, input.claim.id), {
+        id: input.claim.id,
+        action: input.claim.action,
+        payload: requestPayload(input.claim),
+    });
+    const path = receiptPath(input.directory, input.claim.id);
     for (;;) {
         try {
-            const receipt = decodeReceipt(await readFile(receiptPath, "utf8"), id, action);
+            const receipt = decodeReceipt(await readFile(path, "utf8"), input.claim.id, input.claim.action);
             if (receipt === null)
-                throw new Error(`Akuma body request ${id} has an invalid receipt`);
+                throw new Error(`Akuma body request ${input.claim.id} has an invalid receipt`);
             if (receipt.state === "refused")
                 throw new AkumaBodyRequestError("refused", receipt.diagnostic);
             if (receipt.state === "voided")
@@ -314,7 +50,7 @@ async function requestBody(input) {
         if (!await access(input.directory).then(() => true, () => false)) {
             throw new AkumaBodyRequestError("voided", "parent request channel closed before a receipt");
         }
-        await abortableDelay(POLL_MS);
+        await abortableDelay(POLL_MS, input.signal);
     }
 }
 export async function requestBodyCall(input) {
@@ -325,13 +61,30 @@ export async function requestBodyCall(input) {
     }
     return receipt.child;
 }
-async function requestUpstream(directory, claim) {
-    const receipt = await requestBody({ directory, claim });
-    if (receipt.action === "akuma.call" || receipt.state !== "served") {
+async function requestUpstream(directory, claim, signal) {
+    const receipt = await requestBody({ directory, claim, ...(signal === undefined ? {} : { signal }) });
+    if (receipt.action === "akuma.call" || receipt.state !== "served" || !("outcome" in receipt)) {
         throw new Error(`Akuma body request ${claim.id} returned the wrong action`);
     }
     return receipt.outcome;
 }
+export async function requestBodyTask(input) {
+    const id = input.id ?? randomUUID();
+    const receipt = await requestBody({
+        directory: input.directory,
+        claim: { id, action: input.request.action, world: input.world, request: input.request },
+    });
+    if (!isTaskMutationAction(receipt.action) || receipt.action !== input.request.action || receipt.state !== "served") {
+        throw new Error(`Akuma body request ${id} returned the wrong action`);
+    }
+    if ("reference" in receipt)
+        return receipt.reference;
+    if (receipt.outcome.kind === "returned")
+        return receipt.outcome.result;
+    throw new Error(receipt.outcome.failure.kind === "failed"
+        ? receipt.outcome.failure.diagnostic
+        : "Akuma body request parent is not born");
+}
 export async function requestBodyWait(input) {
     const { directory, id = randomUUID(), ...claim } = input;
     return await requestUpstream(directory, { ...claim, id, action: "akuma.wait" });
@@ -344,286 +97,23 @@ export async function requestBodyKill(input) {
     const { directory, id = randomUUID(), ...claim } = input;
     return await requestUpstream(directory, { ...claim, id, action: "akuma.kill" });
 }
-async function serveCallClaim(input) {
-    input.signal.throwIfAborted();
-    const cwd = input.claim.cwd ?? input.parent.cwd;
-    const recipe = decodeRecipe(input.claim.recipe, cwd);
-    if (recipe === null)
-        return;
-    let fact = await admitRequest(input.paths, { ...input.claim, recipe, admittedAt: input.now() });
-    const existing = receiptFor(fact);
-    if (existing !== null) {
-        if (!input.signal.aborted)
-            await projectReceipt(input.directory, fact);
-        return;
-    }
-    if (fact.action !== "akuma.call" || fact.state !== "admitted") {
-        throw new Error(`Akuma request ${fact.id} cannot be replayed from ${fact.state}`);
-    }
-    const request = fact;
-    const servingWorld = worldRootForAkumaPaths(input.paths);
-    if (request.world !== servingWorld) {
-        fact = await refuseRequest(input.paths, request.id, `request world ${request.world} does not match ${servingWorld}`);
-        await projectReceipt(input.directory, fact);
-        return;
-    }
-    let child;
-    try {
-        input.signal.throwIfAborted();
-        const published = await publishAkuma({
-            worldPath: servingWorld,
-            archetype: request.archetype,
-            reserve: async (allocated) => { fact = await reserveRequest(input.paths, request.id, allocated.id); },
-            signal: input.signal,
-            launch: async (allocated) => await input.spawn({
-                paths: allocated.paths,
-                seed: {
-                    id: allocated.id,
-                    archetype: allocated.archetype,
-                    ...(request.recipe.description === undefined ? {} : { description: request.recipe.description }),
-                    provider: request.recipe.provider,
-                    options: request.recipe.options,
-                    ...(request.recipe.readonly === undefined ? {} : { readonly: request.recipe.readonly }),
-                    allowed: request.recipe.allowed,
-                    cwd,
-                    origin: { kind: "request", parent: input.parent.id, requestId: request.id },
-                    confinement: request.recipe.confinement,
-                },
-                initialBody: request.body,
-            }),
-        });
-        child = published.id;
-    }
-    catch (error) {
-        if (input.signal.aborted)
-            return;
-        const current = await readRequest(input.paths, request.id);
-        if (current === null)
-            throw error;
-        fact = current.state === "admitted" || current.state === "reserved"
-            ? await voidRequest(input.paths, request.id, diagnostic(error))
-            : current;
-        await projectReceipt(input.directory, fact);
-        return;
-    }
-    fact = await serveRequest(input.paths, request.id, child);
-    await projectReceipt(input.directory, fact);
-}
-function upstreamFailure(error) {
-    const value = object(error);
-    if (value?.kind === "akuma-not-born") {
-        const id = canonicalAkuId(value.id);
-        if (id !== null)
-            return { kind: "akuma-not-born", id };
-    }
-    return { kind: "failed", diagnostic: diagnostic(error) };
-}
-async function serveUpstreamClaim(input) {
-    input.signal.throwIfAborted();
-    let fact = await admitRequest(input.paths, { ...input.claim, admittedAt: input.now() });
-    const existing = receiptFor(fact);
-    if (existing !== null) {
-        if (!input.signal.aborted)
-            await projectReceipt(input.directory, fact);
-        return;
-    }
-    if (fact.state === "served") {
-        await projectReceipt(input.directory, fact, {
-            kind: "failed",
-            failure: { kind: "failed", diagnostic: "served request receipt is no longer available" },
-        });
-        return;
-    }
-    if (fact.state !== "admitted" || fact.action === "akuma.call") {
-        throw new Error(`Akuma request ${fact.id} cannot be served from ${fact.state}`);
-    }
-    const request = fact;
-    let outcome;
-    let killService = [];
-    try {
-        if (input.upstream === undefined)
-            throw new Error("upstream execution port is unavailable");
-        let result;
-        if (request.action === "akuma.wait") {
-            const waitRequest = request;
-            result = await input.upstream.wait({
-                targets: waitRequest.targets,
-                completion: waitRequest.completion,
-                ...(waitRequest.timeoutMs === undefined ? {} : { timeoutMs: waitRequest.timeoutMs }),
-                signal: input.signal,
-            });
-        }
-        else if (request.action === "akuma.tell") {
-            const tellRequest = request;
-            result = await input.upstream.tell({
-                target: tellRequest.target,
-                body: tellRequest.body,
-                tellId: tellRequest.id,
-                recordedAt: tellRequest.admittedAt,
-                signal: input.signal,
-            });
-        }
-        else {
-            const killRequest = request;
-            const served = await input.upstream.kill({ targets: killRequest.targets, signal: input.signal });
-            killService = served.service;
-            result = served.result;
-        }
-        outcome = { kind: "returned", result };
-    }
-    catch (error) {
-        if (input.signal.aborted)
-            return;
-        outcome = { kind: "failed", failure: upstreamFailure(error) };
-    }
-    input.signal.throwIfAborted();
-    const service = request.action === "akuma.wait"
-        ? { action: request.action }
-        : request.action === "akuma.tell"
-            ? { action: request.action, target: request.target, tellId: request.id }
-            : { action: request.action, results: killService };
-    fact = await serveUpstreamRequest(input.paths, request.id, service);
-    await projectReceipt(input.directory, fact, outcome);
-}
-async function serveClaim(input) {
-    return input.claim.action === "akuma.call"
-        ? await serveCallClaim({ ...input, claim: input.claim })
-        : await serveUpstreamClaim({ ...input, claim: input.claim });
-}
-async function requestFiles(directory) {
-    try {
-        return (await readdir(directory))
-            .filter((name) => name.endsWith(".request.json"))
-            .sort();
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-}
-export class BodyRequestPump {
-    input;
-    directory;
-    failure;
-    closeSignal = new AbortController();
-    handled = new Set();
-    running;
-    cancelAdmission;
-    constructor(input) {
-        this.input = input;
-        this.directory = join(input.paths.directory, "requests", String(input.bodySequence));
-        this.cancelAdmission = () => this.stopAdmission();
-        input.signal.addEventListener("abort", this.cancelAdmission, { once: true });
-        if (input.signal.aborted)
-            this.cancelAdmission();
-        this.running = this.run();
-        this.failure = this.running.then(() => new Promise(() => { }), (error) => Promise.reject(error));
-    }
-    static async open(input) {
-        const directory = join(input.paths.directory, "requests", String(input.bodySequence));
-        await mkdir(directory, { recursive: true });
-        return new BodyRequestPump(input);
-    }
-    async run() {
-        while (!this.closeSignal.signal.aborted) {
-            for (const name of await requestFiles(this.directory)) {
-                if (this.closeSignal.signal.aborted)
-                    return;
-                const id = name.slice(0, -".request.json".length);
-                if (this.handled.has(id))
-                    continue;
-                const claim = decodeClaim(await readFile(join(this.directory, name), "utf8"), id);
-                if (claim === null) {
-                    this.handled.add(id);
-                    continue;
-                }
-                await serveClaim({ directory: this.directory, claim, ...this.input, signal: this.closeSignal.signal });
-                this.handled.add(id);
-            }
-            try {
-                await abortableDelay(POLL_MS, this.closeSignal.signal);
-            }
-            catch {
-                return;
-            }
-        }
-    }
-    async close() {
-        this.stopAdmission();
-        try {
-            await this.running;
-        }
-        finally {
-            this.input.signal.removeEventListener("abort", this.cancelAdmission);
-            await rm(this.directory, { recursive: true, force: true });
-        }
-    }
-    stopAdmission() {
-        if (!this.closeSignal.signal.aborted)
-            this.closeSignal.abort(new Error("Body request pump closed"));
-    }
-}
-export async function clearBodyRequestTransport(paths) {
-    await rm(join(paths.directory, "requests"), { recursive: true, force: true });
-}
-function matchingRequestOrigin(soul, parent, requestId) {
-    return soul.origin.kind === "request"
-        && soul.origin.parent === parent
-        && soul.origin.requestId === requestId;
-}
-async function settleObservedSoul(paths, parent, request, soul) {
-    if (matchingRequestOrigin(soul, parent.id, request.id))
-        await serveRequest(paths, request.id, request.child);
-    else
-        await voidRequest(paths, request.id, "reserved child origin does not match the request");
-}
-async function settleReserved(paths, parent, request, now, signal) {
-    const childPaths = pathsForAkuId(request.world, request.child);
-    const deadline = performance.now() + BIRTH_TIMEOUT_MS;
-    for (;;) {
-        signal?.throwIfAborted();
-        if (!await access(childPaths.directory).then(() => true, () => false)) {
-            await voidRequest(paths, request.id, "reserved child directory is absent");
-            return true;
-        }
-        const childSoul = await readSoul(childPaths);
-        if (childSoul !== null) {
-            await settleObservedSoul(paths, parent, request, childSoul);
-            return true;
-        }
-        const leash = await HeldAkumaLeash.try(childPaths);
-        if (leash !== null) {
-            try {
-                const settledSoul = await readSoul(childPaths);
-                if (settledSoul !== null) {
-                    await settleObservedSoul(paths, parent, request, settledSoul);
-                }
-                else {
-                    await leash.sealIfUnborn(childPaths, { evidence: "request settlement", at: now() });
-                    await voidRequest(paths, request.id, "reserved child was sealed unborn");
-                }
-            }
-            finally {
-                leash.release();
-            }
-            return true;
-        }
-        if (performance.now() >= deadline)
-            return false;
-        await abortableDelay(POLL_MS, signal);
-    }
-}
-export async function settleBodyRequests(paths, parent, now, signal) {
-    let pending = false;
-    for (const request of await readNonterminalRequests(paths)) {
-        signal?.throwIfAborted();
-        if (request.state === "admitted") {
-            await voidRequest(paths, request.id, "body died before serving the request");
-        }
-        else if (request.state === "reserved"
-            && !await settleReserved(paths, parent, request, now, signal))
-            pending = true;
-    }
-    return pending ? "pending" : "settled";
+async function requestContract(input, action) {
+    const { directory, id = randomUUID(), signal, ...claim } = input;
+    const receipt = await requestBody({
+        directory,
+        claim: { ...claim, id, action },
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (receipt.action !== action || receipt.state !== "served") {
+        throw new Error(`Akuma body request ${id} returned the wrong action`);
+    }
+    return "reference" in receipt
+        ? receipt.reference
+        : receipt.outcome;
+}
+export async function requestBodyDeliver(input) {
+    return await requestContract(input, "contract.deliver");
+}
+export async function requestBodyReview(input) {
+    return await requestContract(input, "contract.review");
 }

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

@@ -1 +1,8 @@
+import { type BodyLaunch } from "./akuma/body.js";
+import type { UpstreamExecutionPort } from "./akuma/request-serve.js";
+type BodyProcessConfiguration = Readonly<{
+    home?: string;
+    gitPath?: string;
+}>;
+export declare function upstreamFor(launch: BodyLaunch, processConfiguration: BodyProcessConfiguration): UpstreamExecutionPort;
 export {};