@plitzi/sdk-server 0.37.2 → 0.37.4

package/dist/modules/actions/transport/stream.js

@@ -1,7 +1,5 @@
+import { openEventStream } from "../../../core/http/sse.js";
 //#region src/modules/actions/transport/stream.ts
-/** How often a comment frame goes out. Short enough that a dead peer is noticed in seconds, long enough that an
-*  idle stream costs nothing worth counting. */
-var HEARTBEAT_MS = 15e3;
 /**
 * How long a hand-rolled `EventSource` waits before reconnecting, if one ever gets here.
 *
@@ -11,84 +9,22 @@ var HEARTBEAT_MS = 15e3;
 */
 var RETRY_MS = 864e5;
 /**
-* How much unread body may pile up before the run is stopped.
+* Opens a run's Server-Sent Events response.
 *
-* A `write` that answers `false` has been buffered rather than sent, which is normal for a moment and a leak
-* forever: a peer that stopped reading — a phone that slept, a proxy that wedged — otherwise has the whole run's
-* output accumulated for it in memory. The socket says nothing, so the only signal is this one.
-*/
-var MAX_BUFFERED_BYTES = 1e6;
-var encode = (frame) => `event: ${frame.event}\ndata: ${JSON.stringify(frame.data)}\n\n`;
-/** What the host has written but not yet handed to the socket. Node's own response reports it; the minimum raw
-*  response this server accepts does not have to, and a host that cannot say simply never trips the cap. */
-var bufferedBytes = (raw) => {
-	const { writableLength } = raw;
-	return typeof writableLength === "number" ? writableLength : 0;
-};
-/**
-* Opens a Server-Sent Events response.
-*
-* Written straight to the RAW response, never through the response helpers: those compress the body, set a
-* Content-Length and end it in one go, which is precisely what a stream cannot do. `no-transform` says the same
-* thing to every proxy in between, and `X-Accel-Buffering: no` says it to nginx, which otherwise holds frames
-* until its buffer fills and turns a live stream into one late burst.
+* The run's id travels on the response head rather than in a frame: a streaming step returns as soon as the stream
+* OPENS — that is what makes it a stream — so anything it learns from a frame arrives after the flow has already
+* carried on. The head is the one place a caller can read the id in time to cancel the run it just started.
 */
 var openStream = (raw, onAbort, runId) => {
-	let open = true;
-	raw.writeHead(200, {
-		"Content-Type": "text/event-stream; charset=utf-8",
-		"Cache-Control": "no-cache, no-transform",
-		Connection: "keep-alive",
-		"X-Accel-Buffering": "no",
-		/**
-		* The run's id, on the response head rather than in a frame.
-		*
-		* A streaming step returns as soon as the stream OPENS — that is what makes it a stream — so anything it
-		* learns from a frame arrives after the flow has already carried on. The head is the one place a caller can
-		* read the id in time to cancel the run it just started.
-		*/
-		"X-Plitzi-Run-Id": runId
+	const stream = openEventStream(raw, {
+		onAbort,
+		headers: { "X-Plitzi-Run-Id": runId },
+		retryMs: RETRY_MS
 	});
-	raw.write(`retry: ${RETRY_MS}\n\n`);
-	const heartbeat = setInterval(() => {
-		if (!open) return;
-		try {
-			raw.write(": ping\n\n");
-		} catch {
-			open = false;
-			clearInterval(heartbeat);
-			onAbort();
-		}
-	}, HEARTBEAT_MS);
-	const close = () => {
-		if (!open) return;
-		open = false;
-		clearInterval(heartbeat);
-		try {
-			raw.end();
-		} catch {}
-	};
 	return {
-		send: (frame) => {
-			if (!open) return;
-			try {
-				raw.write(encode(frame));
-				if (bufferedBytes(raw) > MAX_BUFFERED_BYTES) {
-					open = false;
-					clearInterval(heartbeat);
-					onAbort();
-					try {
-						raw.end();
-					} catch {}
-				}
-			} catch {
-				open = false;
-				clearInterval(heartbeat);
-				onAbort();
-			}
-		},
-		close,
-		isOpen: () => open
+		send: (frame) => stream.send(frame.event, frame.data),
+		close: stream.close,
+		isOpen: stream.isOpen
 	};
 };
 /** Whether this caller asked for a stream. The negotiation is the client's, so a page that cannot read one never

package/dist/modules/actions/transport/webhookHandler.js

@@ -1,3 +1,4 @@
+import { serverLog } from "../../../helpers/serverLog.js";
 import { findTriggerNode, triggerParams } from "../runtime/triggers.js";
 import { ActionRunError } from "../runtime/errors.js";
 import { precheckRun } from "../runtime/precheck.js";
@@ -75,7 +76,7 @@ var handleActionWebhook = async (deps) => {
 	* one without a single line of it changing. Fail closed, and say which document to fix.
 	*/
 	if (triggerHasStaleVerify(stepParams)) {
-		console.error(`[Actions] webhook "${actionId}" in space ${spaceId} carries a signature check in a format nothing reads any more, so it is refused. Name the signing credential on the trigger step.`);
+		serverLog.error("Actions", `webhook "${actionId}" in space ${spaceId} carries a signature check in a format nothing reads any more, so it is refused. Name the signing credential on the trigger step.`);
 		await reject("unverifiable", "The signature check is in a format nothing reads any more; name the signing credential on the trigger step");
 		send(res, 503, { error: "Unavailable" });
 		return;
@@ -99,7 +100,7 @@ var handleActionWebhook = async (deps) => {
 		const secret = await resolveSecret(verify, spaceId, config.action?.lookups?.getCredential);
 		const check = verifySignature(verify, secret, req.headers, rawBody);
 		if (!check.ok) {
-			console.warn(`[Actions] webhook "${actionId}" rejected: ${check.reason}`);
+			serverLog.warn("Actions", `webhook "${actionId}" rejected: ${check.reason}`);
 			await reject("invalid_signature", check.reason);
 			send(res, 401, { error: "Invalid signature" });
 			return;
@@ -182,7 +183,7 @@ var handleActionWebhook = async (deps) => {
 			status: result.status
 		});
 	} catch (error) {
-		console.error("[Actions] webhook run failed:", error);
+		serverLog.error("Actions", "webhook run failed", error);
 		send(res, 500, { accepted: false });
 	} finally {
 		releaseAbort();

package/dist/modules/actions/types.d.ts

@@ -1,4 +1,9 @@
 import { ActionEmailSender } from './runtime/email';
+import { FunctionsConfig } from '../functions/config';
+import { SpaceFunctions } from '../functions/protocol';
+import { KvChangeLifetime } from './runtime/kvChange';
+import { KvListEntry, KvListPut, KvListPutOptions, KvListRange } from './runtime/kvList';
+import { SpaceSigning } from './runtime/signing';
 import { ActionEmailConfig, ActionJobQueue, ActionEntry, ActionLimits, ActionRejectRecord, ActionRunRecord, ActionRunStatus, ActionRunStep, ActionTriggerType, ConnectorManifest, Environment, InteractionCallbackParam, InteractionNode, InteractionNodeStatus, SpaceRevision, SSRUser } from '@plitzi/sdk-shared';
 /** Resolved secret material, as the connector engine already models it. */
 export type ActionCredential = Record<string, string>;
@@ -31,7 +36,7 @@ export type ActionDbDriver = {
 /**
  * Where a deployment keeps the `kv` tasks' data — Redis, Memcached, a table, whatever it already runs.
  *
- * Deliberately the DUMBEST possible surface: five operations over strings, with no rule to obey. Everything that
+ * Deliberately the DUMBEST possible surface: six operations over strings, with no rule to obey. Everything that
  * decides how a counter behaves — the key prefixing, the JSON round trip, and the one rule a rate limit lives or
  * dies by — is `createKvStore`'s, above this. An adapter that had to remember "extend the TTL only when the
  * counter did not exist" would be an adapter each deployment gets to write that rule wrongly in.
@@ -48,6 +53,12 @@ export type ActionKvAdapter = {
     increment: (key: string, amount: number) => Promise<number>;
     /** Sets a lifetime on a key that already exists. When to call it is decided above, never here. */
     expire: (key: string, ttlSeconds: number) => Promise<void>;
+    /**
+     * Writes `next` only if the key still holds `expected` — or, with `expected` undefined, only if it holds nothing (a
+     * key past its lifetime holds nothing). Answers whether it wrote. Must be atomic: it is what lets two writers
+     * read, change and write the same value without one of them silently undoing the other.
+     */
+    swap: (key: string, expected: string | undefined, next: string, ttlSeconds?: number) => Promise<boolean>;
 };
 /**
  * The `kv` tasks' own view: values rather than strings, and a TTL that means what a caller expects.
@@ -60,6 +71,27 @@ export type ActionKvStore = {
     set: (key: string, value: unknown, ttlSeconds?: number) => Promise<void>;
     delete: (key: string) => Promise<void>;
     increment: (key: string, amount: number, ttlSeconds?: number) => Promise<number>;
+    /**
+     * Writes `next` only if the key still holds `expected` — the value `get` answered — or, with `expected` undefined,
+     * only if it holds nothing. Answers whether it wrote: read, change, and write back with this, and a writer that
+     * lost the race is told so instead of undoing the other.
+     */
+    swap: (key: string, expected: unknown, next: unknown, ttlSeconds?: number) => Promise<boolean>;
+    /**
+     * Puts `entry` in the list — replacing the one with its id — keeping the highest `keep` by score, and answers what
+     * that dropped, for whatever it named to be let go of too. A list has no lifetime: it lives until its entries are
+     * removed.
+     */
+    listPut: (list: string, entry: KvListEntry, options?: KvListPutOptions) => Promise<KvListPut>;
+    listRange: (list: string, range?: KvListRange) => Promise<KvListEntry[]>;
+    /** Takes the entry with `id` out of the list, and answers whether it was there. */
+    listRemove: (list: string, id: string) => Promise<boolean>;
+    /**
+     * Reads the key, hands its value to `change` and writes back what that answers — reading and asking again when
+     * somebody wrote in between, so no writer undoes another. `change` answering `undefined` writes nothing. Answers what
+     * was written. `lifetime` is seconds, or worked out from the value written.
+     */
+    change: <T>(key: string, change: (current: unknown) => T | undefined | Promise<T | undefined>, lifetime?: KvChangeLifetime<T>) => Promise<T | undefined>;
 };
 /** Re-exported so the module's files import one place. One type for actions and connectors: it is one concept. */
 export type { SpaceRevision } from '@plitzi/sdk-shared';
@@ -82,6 +114,12 @@ export type ActionLookups = {
     listScheduledSpaces?: () => Promise<number[]>;
     getCredential?: (spaceId: number, identifier: string) => Promise<ActionCredential | undefined>;
     getConnector?: (spaceId: number, connectorId: string, at?: SpaceRevision) => Promise<ConnectorManifest | undefined>;
+    /**
+     * The space's own functions as of that revision — the bundle and what it declared when saved, run by the deployment's
+     * sandbox (`functions.runner`), or by the space's own runtime when it answers one with a `runner` of its own. Only
+     * asked when a run names a task the deployment does not have, or a request a path under `/api/`.
+     */
+    getFunctions?: (spaceId: number, at?: SpaceRevision) => Promise<SpaceFunctions | undefined>;
 };
 /**
  * The only door a task has to the outside world.
@@ -123,6 +161,41 @@ export type ActionTaskContext = {
     email: ActionEmailSender;
     /** Pushes a `data` frame to a streaming caller. A no-op when nobody negotiated a stream. */
     emit: (chunk: unknown) => void;
+    /**
+     * A line for whoever reads the run: kept on the step that said it (`logs`), redacted like the rest of it, and shown
+     * wherever the run is — the builder's Try, the run history.
+     */
+    log: (line: string) => void;
+    /**
+     * Publishes on one of this space's realtime channels, as the server — `undefined` when the server has none. What
+     * the `realtime.publish` task sends through.
+     */
+    publish?: (topic: string, type: string, data: unknown) => Promise<void>;
+    /**
+     * A grant for one topic of a `grant: true` channel of this space — what `realtime.grant` hands the page, once the
+     * flow has decided the visitor may be there. `undefined` when the server has no realtime channels.
+     */
+    grant?: (topic: string, ttlSeconds?: number) => Promise<string>;
+    /** Revokes `grant` for `topic` — or every grant for it, naming none — and lets go whoever is on it with one. */
+    revoke?: (topic: string, grant?: string) => Promise<void>;
+    /** Signs with the space's own key (`ActionsConfig.signingSecret`) — `undefined` when the deployment gave none. */
+    sign?: SpaceSigning['sign'];
+    verify?: SpaceSigning['verify'];
+};
+/** How the actions module reaches the server's realtime channels. Set by `createServer`, never by a deployment. */
+export type ActionRealtime = {
+    publish: (space: {
+        spaceId: number;
+        environment: string;
+    }, topic: string, type: string, data: unknown) => Promise<void>;
+    grant: (space: {
+        spaceId: number;
+        environment: string;
+    }, topic: string, ttlSeconds?: number) => Promise<string>;
+    revoke: (space: {
+        spaceId: number;
+        environment: string;
+    }, topic: string, grant?: string) => Promise<void>;
 };
 /**
  * One step a server action can take.
@@ -156,8 +229,8 @@ export type ActionTaskRegistry = {
 /** What a deployment hands to `createServer` under `actions`. Absent → the module is never constructed. */
 export type ActionsConfig = {
     lookups: ActionLookups;
-    /** Deployment-owned tasks, validated at boot against the built-ins. */
-    tasks?: ActionTask<never>[];
+    /** Code of the server's own, and the sandbox for the spaces' — see `FunctionsConfig`. */
+    functions?: FunctionsConfig;
     /** Ceilings a per-action document may tighten but never exceed. */
     limits?: ActionLimits;
     /** How many runs may be in flight at once. Counted per space and for the process as a whole. */
@@ -217,6 +290,14 @@ export type ActionsConfig = {
         replayTtlMs?: number;
     };
     fetchImpl?: typeof fetch;
+    /** The server's realtime channels, for the `realtime.publish` task. Set by `createServer`. */
+    realtime?: ActionRealtime;
+    /**
+     * What each space's signatures are made from (`ctx.sign` / `ctx.verify` in its functions): at least 32 characters,
+     * the SAME on every replica — a key one signed is checked by whichever the next request reaches. Each space and
+     * environment signs with a key derived from it, so none can vouch for another. Absent, spaces sign nothing.
+     */
+    signingSecret?: string;
 };
 /**
  * Scheduled runs: how they are produced, how many run at once, and where they are kept while they wait.
@@ -316,4 +397,6 @@ export type ActionRunResult = {
      * anybody allowed to debug the page. The trace above is for authoring and development servers alone.
      */
     steps: ActionRunStep[];
+    /** Why the run failed, when a step said so for the caller (`ActionRefusal`). Absent for every other failure. */
+    error?: string;
 };

package/dist/modules/connectors/engine.js

@@ -1,4 +1,4 @@
-import { assertOutboundAllowed } from "../../helpers/outboundGuard.js";
+import { fetchOutbound } from "../../helpers/outboundGuard.js";
 import { getByPath } from "./getByPath.js";
 import { processTwig } from "@plitzi/sdk-shared/helpers/twigWrapper";
 import { BODYLESS_METHODS, DEFAULT_READ_ENDPOINT, EMPTY_RESPONSE_METHODS } from "@plitzi/sdk-shared/connectors";
@@ -150,7 +150,6 @@ var fetchConnectorRecords = async ({ manifest, endpoint = DEFAULT_READ_ENDPOINT,
 		...renderEntries(read.query ?? {}, variables),
 		...renderFilters(resolved, connection.operators, variables)
 	}).forEach(([key, value]) => url.searchParams.set(key, value));
-	await assertOutboundAllowed(url);
 	const method = read.method ?? "GET";
 	const headers = {
 		...applyAuth(connection, variables, url),
@@ -158,7 +157,7 @@ var fetchConnectorRecords = async ({ manifest, endpoint = DEFAULT_READ_ENDPOINT,
 	};
 	const sendsBody = !BODYLESS_METHODS.includes(method);
 	if (sendsBody) headers["Content-Type"] = "application/json";
-	const response = await fetchImpl(url.toString(), {
+	const response = await fetchOutbound(fetchImpl, url, {
 		method,
 		headers,
 		body: sendsBody ? JSON.stringify(renderEntries(read.body ?? {}, variables)) : void 0
@@ -202,13 +201,12 @@ var writeConnectorRecord = async ({ manifest, credential = {}, action, resource,
 	};
 	const url = new URL(render(operation.path, variables), connection.baseUrl);
 	Object.entries(renderEntries(operation.query ?? {}, variables)).forEach(([key, value]) => url.searchParams.set(key, value));
-	await assertOutboundAllowed(url);
 	const headers = {
 		...applyAuth(connection, variables, url),
 		...renderEntries(operation.headers ?? {}, variables)
 	};
 	headers["Content-Type"] = "application/json";
-	const response = await fetchImpl(url.toString(), {
+	const response = await fetchOutbound(fetchImpl, url, {
 		method: operation.method,
 		headers,
 		body: BODYLESS_METHODS.includes(operation.method) ? void 0 : JSON.stringify(wrapBody(values, operation.bodyPath))

package/dist/modules/functions/build.d.ts

@@ -0,0 +1,22 @@
+import { FunctionsProblem } from '@plitzi/sdk-shared';
+/** A space's functions source: its files under `functions/`, by path (`index.ts`, `lib/feed.ts`). */
+export type FunctionsSource = Record<string, string>;
+/** One bundle, built from a source: a single web-standard ES module whose default export is the definition. */
+export type FunctionsBuild = {
+    code: string;
+    bytes: number;
+};
+export declare class FunctionsBuildError extends Error {
+    readonly problems: FunctionsProblem[];
+    constructor(problems: FunctionsProblem[]);
+}
+/** The file a space's functions start from. */
+export declare const FUNCTIONS_ENTRY = "index.ts";
+/** The most a bundle may weigh: well under the smallest provider a runner may be (Workers take 3 MB compressed). */
+export declare const MAX_FUNCTIONS_BYTES = 1000000;
+/**
+ * Builds a space's functions into one bundle — the only way code reaches a runner, so what runs is always what the
+ * source says. Web-standard and self-contained: the space's own files, and the contract; a Node built-in or any other
+ * package is refused with where it was imported, because no runner could provide it.
+ */
+export declare const buildFunctions: (source: FunctionsSource) => Promise<FunctionsBuild>;

package/dist/modules/functions/build.js

@@ -0,0 +1,122 @@
+import { ActionRefusal } from "../actions/runtime/errors.js";
+import { defineFunctions } from "./contract.js";
+import { isFunctionsSourcePath } from "@plitzi/sdk-shared/actions";
+import path from "node:path";
+import esbuild from "esbuild";
+//#region src/modules/functions/build.ts
+var FunctionsBuildError = class extends Error {
+	problems;
+	constructor(problems) {
+		super(problems.map(({ file, line, message }) => file ? `${file}:${String(line ?? 0)} ${message}` : message).join("\n"));
+		this.name = "FunctionsBuildError";
+		this.problems = problems;
+	}
+};
+/** The file a space's functions start from. */
+var FUNCTIONS_ENTRY = "index.ts";
+/** The most a bundle may weigh: well under the smallest provider a runner may be (Workers take 3 MB compressed). */
+var MAX_FUNCTIONS_BYTES = 1e6;
+/** The one package a space's code may import: the contract, which is all it needs of the platform. */
+var CONTRACT_SPECIFIER = "@plitzi/sdk-server/functions";
+/**
+* What that import is inside a bundle: the contract's own `defineFunctions` and `ActionRefusal`, each printed from
+* itself so there is one definition of it — an identity, and the class a refusal is told apart by (its name).
+*/
+var CONTRACT_MODULE = [`export const defineFunctions = ${defineFunctions.toString()};`, `export const ActionRefusal = ${ActionRefusal.toString()};`].join("\n");
+var normalize = (file) => path.posix.normalize(file).replace(/^\.\//, "");
+var sourceProblems = (source) => {
+	const problems = [];
+	for (const file of Object.keys(source)) if (!isFunctionsSourcePath(file)) problems.push({
+		file,
+		message: "A file is a relative path under functions/, ending in .ts, .js, .mjs or .json"
+	});
+	if (!("index.ts" in source)) problems.push({ message: `Functions start from ${FUNCTIONS_ENTRY}, which exports the definition by default` });
+	return problems;
+};
+var loaderOf = (file) => {
+	if (file.endsWith(".json")) return "json";
+	return file.endsWith(".ts") ? "ts" : "js";
+};
+/** Resolves every import against the space's own files, and the contract; nothing on the disk is ever read. */
+var sourcePlugin = (files) => ({
+	name: "plitzi-functions-source",
+	setup: (build) => {
+		build.onResolve({ filter: /.*/ }, (args) => {
+			if (args.path === CONTRACT_SPECIFIER) return {
+				path: CONTRACT_SPECIFIER,
+				namespace: "contract"
+			};
+			if (args.kind !== "entry-point" && !args.path.startsWith(".")) return { errors: [{ text: `"${args.path}" cannot be imported: functions import their own files and ${CONTRACT_SPECIFIER}, nothing else` }] };
+			const base = args.kind === "entry-point" ? "." : path.posix.dirname(args.importer);
+			const wanted = normalize(path.posix.join(base, args.path));
+			const found = [
+				wanted,
+				`${wanted}.ts`,
+				`${wanted}.js`,
+				`${wanted}/index.ts`
+			].find((candidate) => files.has(candidate));
+			return found ? {
+				path: found,
+				namespace: "functions"
+			} : { errors: [{ text: `"${args.path}" is not a file of this space's functions` }] };
+		});
+		build.onLoad({
+			filter: /.*/,
+			namespace: "contract"
+		}, () => ({
+			contents: CONTRACT_MODULE,
+			loader: "js"
+		}));
+		build.onLoad({
+			filter: /.*/,
+			namespace: "functions"
+		}, (args) => ({
+			contents: files.get(args.path) ?? "",
+			loader: loaderOf(args.path),
+			resolveDir: "."
+		}));
+	}
+});
+var isMessage = (value) => typeof value === "object" && value !== null && "text" in value && typeof value.text === "string";
+var failureMessages = (error) => typeof error === "object" && error !== null && "errors" in error && Array.isArray(error.errors) ? error.errors.filter(isMessage) : [];
+var problemOf = ({ location, text }) => location ? {
+	file: location.file.replace(/^functions:/, ""),
+	line: location.line,
+	column: location.column,
+	message: text
+} : { message: text };
+/**
+* Builds a space's functions into one bundle — the only way code reaches a runner, so what runs is always what the
+* source says. Web-standard and self-contained: the space's own files, and the contract; a Node built-in or any other
+* package is refused with where it was imported, because no runner could provide it.
+*/
+var buildFunctions = async (source) => {
+	const problems = sourceProblems(source);
+	if (problems.length) throw new FunctionsBuildError(problems);
+	const files = new Map(Object.entries(source).map(([file, text]) => [normalize(file), text]));
+	let result;
+	try {
+		result = await esbuild.build({
+			entryPoints: [FUNCTIONS_ENTRY],
+			bundle: true,
+			write: false,
+			format: "esm",
+			platform: "neutral",
+			target: "es2022",
+			logLevel: "silent",
+			plugins: [sourcePlugin(files)]
+		});
+	} catch (error) {
+		const messages = failureMessages(error);
+		throw new FunctionsBuildError(messages.length ? messages.map(problemOf) : [{ message: error instanceof Error ? error.message : "The build failed" }]);
+	}
+	const code = result.outputFiles[0]?.text ?? "";
+	const bytes = Buffer.byteLength(code);
+	if (bytes > 1e6) throw new FunctionsBuildError([{ message: `Functions are at most ${String(MAX_FUNCTIONS_BYTES)} bytes built, and these are ${String(bytes)}` }]);
+	return {
+		code,
+		bytes
+	};
+};
+//#endregion
+export { FUNCTIONS_ENTRY, FunctionsBuildError, MAX_FUNCTIONS_BYTES, buildFunctions };

package/dist/modules/functions/build.test.d.ts

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

package/dist/modules/functions/capabilities.d.ts

@@ -0,0 +1,22 @@
+import { FunctionContext } from './contract';
+import { FunctionCall, WireBody, WireRequest, WireResponse } from './protocol';
+/** A body as the wire carries it: as text when its type says it is text, base64 otherwise. */
+export declare const wireBodyOf: (body: Body, contentType: string | null) => Promise<WireBody | null>;
+export declare const bodyOf: (body: WireBody | null) => string | Uint8Array<ArrayBuffer> | null;
+export declare const wireResponseOf: (response: Response) => Promise<WireResponse>;
+export declare const wireRequestOf: (request: Request) => Promise<WireRequest>;
+export declare const responseOf: ({ status, statusText, headers, body }: WireResponse) => Response;
+/** An answer that crossed a boundary as a wire response — from a space's code, or from the platform — read, not trusted. */
+export declare const wireResponseFrom: (value: unknown) => WireResponse;
+/** A request that crossed as a wire request, as a web `Request` again — what a route handler outside the sandbox takes. */
+export declare const requestFromWire: (value: unknown) => Request;
+/**
+ * A call as the code sent it, read into what it claims to be — every field checked, because it was written by the
+ * space's code and carried by a runner, and neither is trusted here. The only place a call is read.
+ */
+export declare const readCall: (value: unknown) => FunctionCall;
+/**
+ * Answers one call from a space's code with the run's own {@link FunctionContext} — the same object a self-hosted
+ * server hands its functions, so the sandbox can do exactly what native code can and not one thing more.
+ */
+export declare const answerCall: (ctx: FunctionContext, call: FunctionCall) => Promise<unknown>;