@plitzi/sdk-server 0.37.2 → 0.37.4

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

@@ -0,0 +1,216 @@
+import { FunctionContext, FunctionFetchInit } from './contract';
+import { RateLimit } from '../actions/runtime/rateLimit';
+import { FunctionsManifest } from '@plitzi/sdk-shared';
+/**
+ * The messages between the platform and whatever runs a space's code — the one protocol every runner speaks, whether
+ * it is in the process, a service of ours or a provider's. Versioned, because a runner is deployed apart from the
+ * platform that calls it.
+ */
+export declare const FUNCTIONS_PROTOCOL = 1;
+/** A built bundle: `id` is its content digest, so a runner that has one never needs the code again. */
+export type FunctionsBundle = {
+    id: string;
+    code: string;
+};
+/**
+ * A bundle as a run knows it: its id, and how to fetch its code — which only a runner that has never seen that id asks
+ * for. A run carries no code of its own: up to a megabyte read and sent on every run would be the run's whole cost.
+ */
+export type FunctionsBundleRef = {
+    id: string;
+    load: () => Promise<string>;
+};
+/**
+ * What one invocation may spend — the portable subset every runner can enforce, each mapped to its own knobs. The
+ * platform sets them per space (its plan) and never above the deployment's ceilings.
+ */
+export type FunctionLimits = {
+    /** CPU time the code may use, awaits not counted. */
+    cpuMs: number;
+    /** Wall time, from the moment it starts: the run's remaining budget, at most. */
+    wallMs: number;
+    memoryMb: number;
+    /** The size of what it answers, as JSON. */
+    outputBytes: number;
+    /** Calls back to the platform: `kv`, `fetch`, `publish`… */
+    calls: number;
+};
+/** Text travels as text; anything else base64, so a body is never mangled crossing a boundary that only speaks JSON. */
+export type WireBody = {
+    text: string;
+} | {
+    base64: string;
+};
+export type WireHeaders = [string, string][];
+export type WireRequest = {
+    method: string;
+    url: string;
+    headers: WireHeaders;
+    body: WireBody | null;
+};
+export type WireResponse = {
+    status: number;
+    statusText: string;
+    headers: WireHeaders;
+    body: WireBody | null;
+};
+/** Who and what an invocation is for: the facts a {@link FunctionContext} carries, sent with it rather than asked for. */
+export type FunctionInvocationContext = Pick<FunctionContext, 'spaceId' | 'environment' | 'runId' | 'trigger' | 'callerId' | 'user'>;
+export type FunctionInvocation = {
+    kind: 'task';
+    name: string;
+    params: Record<string, unknown>;
+    context: FunctionInvocationContext;
+} | {
+    kind: 'route';
+    key: string;
+    params: Record<string, string>;
+    request: WireRequest;
+    context: FunctionInvocationContext;
+};
+/**
+ * One call back from the code to the platform: a {@link FunctionContext} method, by name, with its arguments. The
+ * platform answers it with the run's own context — scoped to the space and the run before anything is done.
+ */
+export type FunctionCall = {
+    op: 'kv';
+    method: string;
+    args: unknown[];
+} | {
+    op: 'fetch';
+    url: string;
+    init: FunctionFetchInit;
+} | {
+    op: 'publish';
+    topic: string;
+    type: string;
+    data: unknown;
+} | {
+    op: 'grant';
+    topic: string;
+    ttlSeconds?: number;
+} | {
+    op: 'revoke';
+    topic: string;
+    grant?: string;
+} | {
+    op: 'rateLimit';
+    bucket: string;
+    limit: RateLimit;
+} | {
+    op: 'sign';
+    value: string;
+} | {
+    op: 'verify';
+    value: string;
+    signature: string;
+}
+/** Each value as the guest could send it: JSON, with what JSON cannot say already said as text. */
+ | {
+    op: 'log';
+    values: unknown[];
+} | {
+    op: 'emit';
+    chunk: unknown;
+};
+/** How a call or an invocation ended: its value, or why not — never a thrown object crossing the boundary. */
+export type FunctionAnswer = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: string;
+};
+/** Why the runner stopped an invocation, when it was not the code's own error. */
+export type FunctionStopReason = 'cpu' | 'wall' | 'memory' | 'output' | 'calls' | 'aborted';
+/** What the platform asks a runner for: every runner implements this, and nothing else of it is assumed. */
+export type FunctionRunner = {
+    /** Loads a bundle and answers what it declares — when the space's functions are saved, never on a run. */
+    describe: (bundle: FunctionsBundle) => Promise<unknown>;
+    /**
+     * Runs one task or route of a bundle. Each call the code makes is handed to `answer`, whose result goes back to it;
+     * `signal` aborting ends the invocation. Resolves with what the code returned, and rejects with a
+     * {@link FunctionFailure}.
+     */
+    invoke: (request: FunctionInvokeRequest) => Promise<unknown>;
+    close?: () => Promise<void>;
+};
+/** What one invocation spent — what a deployment meters and budgets by. */
+export type FunctionUsage = {
+    cpuMs: number;
+    wallMs: number;
+    calls: number;
+};
+export type FunctionInvokeRequest = {
+    bundle: FunctionsBundleRef;
+    invocation: FunctionInvocation;
+    limits: FunctionLimits;
+    /** Handed each call exactly as the code sent it: the platform reads it (`readCall`), trusting no runner to have. */
+    answer: (call: unknown) => Promise<unknown>;
+    signal: AbortSignal;
+    /** Told what the invocation spent once it ends, however it ended — before `invoke` settles. */
+    onUsage?: (usage: FunctionUsage) => void;
+};
+/**
+ * Why an invocation did not answer: the code refused (`refused` — an `ActionRefusal`, its message written for whoever
+ * asked), it threw (`error`), or the runner stopped it (a {@link FunctionStopReason}).
+ */
+export type FunctionFailureReason = FunctionStopReason | 'error' | 'refused';
+/** An invocation that did not answer, and why ({@link FunctionFailureReason}). */
+export declare class FunctionFailure extends Error {
+    readonly reason: FunctionFailureReason;
+    constructor(reason: FunctionFailureReason, message: string);
+}
+/**
+ * A space's functions as a run reaches them: the bundle by reference, what it declared when it was saved, and the limits
+ * its plan sets.
+ */
+export type SpaceFunctions = {
+    bundle: FunctionsBundleRef;
+    manifest: FunctionsManifest;
+    limits?: Partial<FunctionLimits>;
+    /**
+     * What runs them, when it is not the deployment's sandbox: the space's own runtime (`createRemoteRunner` to it). Its
+     * bundle id then names that runtime's code, so a registry built for one never answers for another.
+     */
+    runner?: FunctionRunner;
+};
+/** The messages of one runner connection (our own runner service), each side's in turn. */
+export type RunnerRequestMessage = {
+    type: 'describe';
+    protocol: number;
+    bundle: FunctionsBundle;
+} | {
+    type: 'invoke';
+    protocol: number;
+    bundleId: string;
+    invocation: FunctionInvocation;
+    limits: FunctionLimits;
+} | {
+    type: 'bundle';
+    bundle: FunctionsBundle;
+} | {
+    type: 'answer';
+    id: number;
+    answer: FunctionAnswer;
+} | {
+    type: 'abort';
+};
+export type RunnerResponseMessage = {
+    type: 'needBundle';
+}
+/** As the code sent it: the platform reads it, trusting no runner to have. */
+ | {
+    type: 'call';
+    id: number;
+    call: unknown;
+} | {
+    type: 'done';
+    value: unknown;
+    usage?: FunctionUsage;
+} | {
+    type: 'failed';
+    reason: FunctionFailureReason;
+    error: string;
+    usage?: FunctionUsage;
+};

package/dist/modules/functions/protocol.js

@@ -0,0 +1,18 @@
+//#region src/modules/functions/protocol.ts
+/**
+* The messages between the platform and whatever runs a space's code — the one protocol every runner speaks, whether
+* it is in the process, a service of ours or a provider's. Versioned, because a runner is deployed apart from the
+* platform that calls it.
+*/
+var FUNCTIONS_PROTOCOL = 1;
+/** An invocation that did not answer, and why ({@link FunctionFailureReason}). */
+var FunctionFailure = class extends Error {
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.name = "FunctionFailure";
+		this.reason = reason;
+	}
+};
+//#endregion
+export { FUNCTIONS_PROTOCOL, FunctionFailure };

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

@@ -0,0 +1,36 @@
+import { FunctionsConfig } from './config';
+import { SpaceFunctions } from './protocol';
+import { TaskContextSource } from '../actions/runtime/runAction';
+import { Environment, SpaceRevision, SSRUser } from '@plitzi/sdk-shared';
+/** Who is asking a route, as the transport knows them. */
+export type RouteVisit = {
+    spaceId: number;
+    environment: Environment;
+    at?: SpaceRevision;
+    user?: SSRUser;
+    /** `user:<id>` or `ip:<address>`, as for an action call. */
+    callerId: string;
+    signal: AbortSignal;
+};
+export type RouteHandler = {
+    key: string;
+    handle: (request: Request) => Promise<Response>;
+};
+/** The first of `keys` that answers the request, with its params — declared order, as a space reads them. */
+export declare const matchRoute: (keys: readonly string[], method: string, path: string) => {
+    key: string;
+    params: Record<string, string>;
+} | undefined;
+export type RouteSources = {
+    config: FunctionsConfig;
+    getFunctions?: (spaceId: number, at?: SpaceRevision) => Promise<SpaceFunctions | undefined>;
+    taskContext: TaskContextSource;
+};
+/**
+ * The route a request reaches, if one does: the deployment's own (its native functions') first, then the space's —
+ * each run with the same context a task of theirs gets, `trigger: 'route'`.
+ */
+export declare const createRoutes: ({ config, getFunctions, taskContext }: RouteSources) => {
+    /** The route that answers `method path` (the path after `/api`), for this visit — or none. */
+    routeFor: (visit: RouteVisit, method: string, path: string) => Promise<RouteHandler | undefined>;
+};

package/dist/modules/functions/routes.js

@@ -0,0 +1,181 @@
+import { serverLog } from "../../helpers/serverLog.js";
+import { ActionRefusal } from "../actions/runtime/errors.js";
+import { functionContextFor } from "./context.js";
+import { parseRouteKey } from "./manifest.js";
+import { answerCall, readCall, responseOf, wireRequestOf, wireResponseFrom } from "./capabilities.js";
+import { functionLimitsFor } from "./config.js";
+import { FunctionFailure } from "./protocol.js";
+import { randomUUID } from "node:crypto";
+//#region src/modules/functions/routes.ts
+/** A route key's params from a path it answers, or nothing when it does not answer it. */
+var matchKey = (key, method, path) => {
+	const segments = path.replace(/^\/+/, "").split("/");
+	if (key.method !== method || segments.length !== key.segments.length) return;
+	const params = {};
+	for (const [index, expected] of key.segments.entries()) {
+		let actual;
+		try {
+			actual = decodeURIComponent(segments[index] ?? "");
+		} catch {
+			return;
+		}
+		if (expected.startsWith(":")) {
+			if (!actual) return;
+			params[expected.slice(1)] = actual;
+		} else if (expected !== actual) return;
+	}
+	return params;
+};
+/** The first of `keys` that answers the request, with its params — declared order, as a space reads them. */
+var matchRoute = (keys, method, path) => {
+	for (const key of keys) {
+		const parsed = parseRouteKey(key);
+		const params = parsed ? matchKey(parsed, method, path) : void 0;
+		if (params) return {
+			key,
+			params
+		};
+	}
+};
+/**
+* What of a visitor's request a function sees: everything but their credentials. The session cookie and any bearer
+* are the platform's — `ctx.user` says who is asking — and a function holding them could spend them anywhere its
+* hosts reach.
+*/
+var withoutCredentials = (request) => {
+	const headers = new Headers(request.headers);
+	[
+		"cookie",
+		"authorization",
+		"proxy-authorization"
+	].forEach((name) => headers.delete(name));
+	[...headers.keys()].filter((name) => name.startsWith("x-plitzi-")).forEach((name) => headers.delete(name));
+	return new Request(request, { headers });
+};
+/** What of a function's answer reaches the visitor: everything but cookies — the host's cookies are the platform's. */
+var withoutCookies = (response) => {
+	const headers = new Headers(response.headers);
+	headers.delete("set-cookie");
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+};
+/**
+* A route that refused, threw or was stopped. A refusal's message was written for the visitor, who gets it with a 400;
+* of anything else the visitor gets that it failed, and the server's log gets why.
+*/
+var failed = (visit, key, error) => {
+	if (error instanceof ActionRefusal || error instanceof FunctionFailure && error.reason === "refused") return Response.json({ error: error.message }, { status: 400 });
+	serverLog.error("Functions", `route ${key} of space ${String(visit.spaceId)} failed`, error);
+	const stopped = error instanceof FunctionFailure && error.reason !== "error";
+	return Response.json({ error: stopped ? "This route ran out of what it may spend" : "This route failed" }, { status: stopped ? 503 : 500 });
+};
+/**
+* The route a request reaches, if one does: the deployment's own (its native functions') first, then the space's —
+* each run with the same context a task of theirs gets, `trigger: 'route'`.
+*/
+var createRoutes = ({ config, getFunctions, taskContext }) => {
+	const native = (config.native ?? []).flatMap((definition) => Object.entries(definition.routes ?? {}).map(([key, handler]) => ({
+		key,
+		handler,
+		hosts: definition.allow?.hosts ?? []
+	})));
+	const contextOf = (visit, key, hosts) => {
+		const ctx = taskContext({
+			runId: randomUUID(),
+			spaceId: visit.spaceId,
+			environment: visit.environment,
+			trigger: "call",
+			callerId: visit.callerId,
+			...visit.user ? { user: visit.user } : {},
+			...visit.at ? { at: visit.at } : {}
+		}, visit.signal, [`route:${key}`]);
+		return {
+			...functionContextFor({
+				...ctx,
+				log: (line) => {
+					serverLog.info("Functions", `route ${key} of space ${String(visit.spaceId)}: ${line}`);
+				}
+			}, hosts),
+			trigger: "route"
+		};
+	};
+	const nativeRoute = (visit, method, path) => {
+		const match = matchRoute(native.map((route) => route.key), method, path);
+		const route = match ? native.find((entry) => entry.key === match.key) : void 0;
+		if (!match || !route) return;
+		const handler = route.handler;
+		return {
+			key: match.key,
+			handle: async (request) => {
+				try {
+					return withoutCookies(await handler(withoutCredentials(request), {
+						...contextOf(visit, match.key, route.hosts),
+						params: match.params
+					}));
+				} catch (error) {
+					return failed(visit, match.key, error);
+				}
+			}
+		};
+	};
+	const spaceRoute = async (visit, method, path) => {
+		const functions = await getFunctions?.(visit.spaceId, visit.at);
+		const runner = functions?.runner ?? config.runner;
+		const match = functions ? matchRoute(functions.manifest.routes, method, path) : void 0;
+		if (!runner || !functions || !match) return;
+		return {
+			key: match.key,
+			handle: async (request) => {
+				const refusal = await config.admit?.(visit.spaceId);
+				if (refusal) return Response.json({ error: refusal }, { status: 429 });
+				const fnCtx = contextOf(visit, match.key, functions.manifest.hosts);
+				let ok = false;
+				let spent;
+				try {
+					const value = await runner.invoke({
+						bundle: functions.bundle,
+						invocation: {
+							kind: "route",
+							key: match.key,
+							params: match.params,
+							request: await wireRequestOf(withoutCredentials(request)),
+							context: {
+								spaceId: fnCtx.spaceId,
+								environment: fnCtx.environment,
+								runId: fnCtx.runId,
+								trigger: fnCtx.trigger,
+								callerId: fnCtx.callerId,
+								...fnCtx.user ? { user: fnCtx.user } : {}
+							}
+						},
+						limits: functionLimitsFor(config.limits, functions.limits),
+						answer: (call) => answerCall(fnCtx, readCall(call)),
+						signal: visit.signal,
+						onUsage: (usage) => {
+							spent = usage;
+						}
+					});
+					ok = true;
+					return withoutCookies(responseOf(wireResponseFrom(value)));
+				} catch (error) {
+					return failed(visit, match.key, error);
+				} finally {
+					if (spent) config.onUsage?.({
+						spaceId: visit.spaceId,
+						task: `route ${match.key}`,
+						ok,
+						usage: spent
+					});
+				}
+			}
+		};
+	};
+	return { 
+	/** The route that answers `method path` (the path after `/api`), for this visit — or none. */
+routeFor: async (visit, method, path) => nativeRoute(visit, method, path) ?? await spaceRoute(visit, method, path) };
+};
+//#endregion
+export { createRoutes, matchRoute };

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

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

package/dist/modules/functions/runner/messages.d.ts

@@ -0,0 +1,5 @@
+import { RunnerRequestMessage, RunnerResponseMessage } from '../protocol';
+/** What the platform sent the runner, or nothing when it is not one of the protocol's messages. */
+export declare const readRequestMessage: (data: string) => RunnerRequestMessage | undefined;
+/** What the runner sent the platform, or nothing when it is not one of the protocol's messages. */
+export declare const readResponseMessage: (data: string) => RunnerResponseMessage | undefined;

package/dist/modules/functions/runner/messages.js

@@ -0,0 +1,188 @@
+//#region src/modules/functions/runner/messages.ts
+var ENVIRONMENTS = {
+	production: true,
+	staging: true,
+	development: true,
+	main: true
+};
+var isEnvironment = (value) => typeof value === "string" && Object.hasOwn(ENVIRONMENTS, value);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parse = (data) => {
+	try {
+		const value = JSON.parse(data);
+		return isRecord(value) ? value : void 0;
+	} catch {
+		return;
+	}
+};
+var bundleOf = (value) => isRecord(value) && typeof value.id === "string" && typeof value.code === "string" ? {
+	id: value.id,
+	code: value.code
+} : void 0;
+var limitOf = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+var limitsOf = (value) => {
+	if (!isRecord(value)) return;
+	const cpuMs = limitOf(value.cpuMs);
+	const wallMs = limitOf(value.wallMs);
+	const memoryMb = limitOf(value.memoryMb);
+	const outputBytes = limitOf(value.outputBytes);
+	const calls = limitOf(value.calls);
+	return cpuMs !== void 0 && wallMs !== void 0 && memoryMb !== void 0 && outputBytes !== void 0 && calls !== void 0 ? {
+		cpuMs,
+		wallMs,
+		memoryMb,
+		outputBytes,
+		calls
+	} : void 0;
+};
+/**
+* An invocation as the platform sent it. The runner only carries it into the isolate, where the guest reads it again;
+* what is checked here is what the runner itself acts on.
+*/
+var invocationOf = (value) => {
+	if (!isRecord(value) || !isRecord(value.context) || value.kind !== "task" && value.kind !== "route") return;
+	const { context } = value;
+	if (typeof context.spaceId !== "number" || typeof context.runId !== "string" || typeof context.trigger !== "string" || typeof context.callerId !== "string" || !isEnvironment(context.environment)) return;
+	const facts = {
+		spaceId: context.spaceId,
+		environment: context.environment,
+		runId: context.runId,
+		trigger: context.trigger,
+		callerId: context.callerId
+	};
+	const user = isRecord(context.user) ? context.user : void 0;
+	const withUser = user && typeof user.id === "number" && typeof user.username === "string" && typeof user.email === "string" && typeof user.verified === "boolean" && Array.isArray(user.permissions) && Array.isArray(user.roles) ? {
+		...facts,
+		user: {
+			id: user.id,
+			username: user.username,
+			email: user.email,
+			verified: user.verified,
+			permissions: user.permissions.filter((entry) => typeof entry === "string"),
+			roles: user.roles.filter((entry) => typeof entry === "string")
+		}
+	} : facts;
+	if (value.kind === "task") return typeof value.name === "string" && isRecord(value.params) ? {
+		kind: "task",
+		name: value.name,
+		params: value.params,
+		context: withUser
+	} : void 0;
+	const request = isRecord(value.request) ? value.request : void 0;
+	if (!request || typeof value.key !== "string" || typeof request.method !== "string" || typeof request.url !== "string") return;
+	const params = isRecord(value.params) ? value.params : {};
+	const body = isRecord(request.body) ? request.body : void 0;
+	return {
+		kind: "route",
+		key: value.key,
+		params: Object.fromEntries(Object.entries(params).map(([name, param]) => [name, String(param)])),
+		request: {
+			method: request.method,
+			url: request.url,
+			headers: Array.isArray(request.headers) ? request.headers.flatMap((pair) => Array.isArray(pair) && typeof pair[0] === "string" && typeof pair[1] === "string" ? [[pair[0], pair[1]]] : []) : [],
+			body: body && typeof body.text === "string" ? { text: body.text } : body && typeof body.base64 === "string" ? { base64: body.base64 } : null
+		},
+		context: withUser
+	};
+};
+var answerOf = (value) => {
+	if (!isRecord(value)) return;
+	if (value.ok === true) return {
+		ok: true,
+		value: value.value
+	};
+	return value.ok === false && typeof value.error === "string" ? {
+		ok: false,
+		error: value.error
+	} : void 0;
+};
+/** What the platform sent the runner, or nothing when it is not one of the protocol's messages. */
+var readRequestMessage = (data) => {
+	const message = parse(data);
+	switch (message?.type) {
+		case "describe": {
+			const bundle = bundleOf(message.bundle);
+			return bundle && typeof message.protocol === "number" ? {
+				type: "describe",
+				protocol: message.protocol,
+				bundle
+			} : void 0;
+		}
+		case "invoke": {
+			const invocation = invocationOf(message.invocation);
+			const limits = limitsOf(message.limits);
+			return invocation && limits && typeof message.bundleId === "string" && typeof message.protocol === "number" ? {
+				type: "invoke",
+				protocol: message.protocol,
+				bundleId: message.bundleId,
+				invocation,
+				limits
+			} : void 0;
+		}
+		case "bundle": {
+			const bundle = bundleOf(message.bundle);
+			return bundle ? {
+				type: "bundle",
+				bundle
+			} : void 0;
+		}
+		case "answer": {
+			const answer = answerOf(message.answer);
+			return answer && typeof message.id === "number" ? {
+				type: "answer",
+				id: message.id,
+				answer
+			} : void 0;
+		}
+		case "abort": return { type: "abort" };
+		default: return;
+	}
+};
+var FAILURE_REASONS = [
+	"cpu",
+	"wall",
+	"memory",
+	"output",
+	"calls",
+	"aborted",
+	"error",
+	"refused"
+];
+var reasonOf = (value) => FAILURE_REASONS.find((reason) => reason === value) ?? "error";
+var usageOf = (value) => {
+	if (!isRecord(value)) return {};
+	const cpuMs = limitOf(value.cpuMs);
+	const wallMs = limitOf(value.wallMs);
+	const calls = limitOf(value.calls);
+	return cpuMs !== void 0 && wallMs !== void 0 && calls !== void 0 ? { usage: {
+		cpuMs,
+		wallMs,
+		calls
+	} } : {};
+};
+/** What the runner sent the platform, or nothing when it is not one of the protocol's messages. */
+var readResponseMessage = (data) => {
+	const message = parse(data);
+	switch (message?.type) {
+		case "needBundle": return { type: "needBundle" };
+		case "call": return typeof message.id === "number" ? {
+			type: "call",
+			id: message.id,
+			call: message.call
+		} : void 0;
+		case "done": return {
+			type: "done",
+			value: message.value,
+			...usageOf(message.usage)
+		};
+		case "failed": return typeof message.error === "string" ? {
+			type: "failed",
+			reason: reasonOf(message.reason),
+			error: message.error,
+			...usageOf(message.usage)
+		} : void 0;
+		default: return;
+	}
+};
+//#endregion
+export { readRequestMessage, readResponseMessage };

package/dist/modules/functions/runner/remote.d.ts

@@ -0,0 +1,19 @@
+import { FunctionRunner } from '../protocol';
+export type RemoteRunnerOptions = {
+    /** The runner service, `ws://functions-runner:8790`. */
+    url: string;
+    secret: string;
+    /** How long to wait for the runner to accept a connection. */
+    connectTimeoutMs?: number;
+    /**
+     * How long past an invocation's own wall limit this side waits before giving up on the runner and closing the socket.
+     * The runner stops an invocation at its limit and says so; this is for a runner that no longer says anything, so a
+     * connection never outlives the work it was for.
+     */
+    graceMs?: number;
+};
+/**
+ * The platform's side of the runner service: a {@link FunctionRunner} over one WebSocket per operation. Each call the
+ * code makes arrives on it and is answered on it, by this process — the one holding the run.
+ */
+export declare const createRemoteRunner: ({ url, secret, connectTimeoutMs, graceMs }: RemoteRunnerOptions) => FunctionRunner;