@nylorun/runtime 0.15.2-beta → 0.17.0-beta

package/dist/blob/s3.js

@@ -0,0 +1,366 @@
+import { createHash } from "node:crypto";
+import { AwsClient } from "aws4fetch";
+import { BlobRangeError, BlobStoreError, BlobTooLargeError, DEFAULT_CONTENT_TYPE, assertBlobKey, assertBlobPrefix, assertMaxBytes, assertRange, chunksOf, } from "./types.js";
+const MIN_PART_SIZE = 5 * 1024 * 1024;
+const DEFAULT_PART_SIZE = 8 * 1024 * 1024;
+function sha256Hex(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function concat(chunks, length) {
+    if (chunks.length === 1)
+        return chunks[0];
+    const out = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return out;
+}
+function decodeXml(text) {
+    return text
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))
+        .replace(/&amp;/g, "&");
+}
+function escapeXml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/** The text of the first `<name>` element in `xml`, decoded. */
+function tag(xml, name) {
+    const match = new RegExp(`<${name}>([\\s\\S]*?)</${name}>`).exec(xml);
+    return match ? decodeXml(match[1]) : undefined;
+}
+function blocks(xml, name) {
+    return [...xml.matchAll(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`, "g"))].map((m) => m[1]);
+}
+/**
+ * The `s3` adapter over the plain S3 API: PutObject, multipart upload, GetObject with Range,
+ * HeadObject, DeleteObject and ListObjectsV2, signed with SigV4 by aws4fetch (MIT, no
+ * dependencies, built on `fetch` and web streams). It uses no server's admin, KMS or lifecycle
+ * API (D35), so RustFS, S3, R2 or any S3 server sits behind it.
+ *
+ * Uploads stream: the body is counted and hashed as it arrives and sent in parts of
+ * `partSize`, so memory stays at about one part whatever the size, and a body that passes
+ * `maxBytes` aborts its multipart upload. Each request carries the SHA-256 of its payload,
+ * which the server checks. Downloads hand back the response's stream.
+ */
+export function createS3BlobStore(options) {
+    const endpoint = new URL(options.endpoint);
+    if (endpoint.protocol !== "http:" && endpoint.protocol !== "https:")
+        throw new TypeError("The S3 endpoint must be an http or https URL");
+    const base = endpoint.toString().replace(/\/+$/, "");
+    const pathStyle = options.forcePathStyle !== false;
+    const bucketUrl = pathStyle
+        ? `${base}/${options.bucket}`
+        : `${endpoint.protocol}//${options.bucket}.${endpoint.host}${endpoint.pathname.replace(/\/+$/, "")}`;
+    const partSize = Math.max(options.partSize ?? DEFAULT_PART_SIZE, MIN_PART_SIZE);
+    const attempts = Math.max(1, options.attempts ?? 3);
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const client = new AwsClient({
+        accessKeyId: options.accessKeyId,
+        secretAccessKey: options.secretAccessKey,
+        service: "s3",
+        region: options.region ?? "us-east-1",
+        retries: 0,
+    });
+    const objectUrl = (key, query) => {
+        const url = new URL(`${bucketUrl}/${key}`);
+        for (const [name, value] of Object.entries(query ?? {}))
+            url.searchParams.set(name, value);
+        return url.toString();
+    };
+    /** One signed request; retried on a network error, 429 or 5xx unless `once`. */
+    async function send(url, init, once = false) {
+        let lastError;
+        for (let attempt = 1; attempt <= (once ? 1 : attempts); attempt += 1) {
+            try {
+                const response = await fetchImpl(await client.sign(url, init));
+                if ((response.status >= 500 || response.status === 429) && attempt < attempts && !once) {
+                    await response.body?.cancel();
+                    await new Promise((resolve) => setTimeout(resolve, 50 * 2 ** attempt));
+                    continue;
+                }
+                return response;
+            }
+            catch (error) {
+                if (init.signal?.aborted)
+                    throw error;
+                lastError = error;
+                if (attempt < (once ? 1 : attempts))
+                    await new Promise((resolve) => setTimeout(resolve, 50 * 2 ** attempt));
+            }
+        }
+        throw new BlobStoreError(`The Object store is unreachable: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+    }
+    async function failure(response, what) {
+        const text = await response.text().catch(() => "");
+        const code = tag(text, "Code");
+        const message = tag(text, "Message");
+        return new BlobStoreError(`${what} failed: ${response.status}${code ? ` ${code}` : ""}${message ? `: ${message}` : ""}`, response.status, code);
+    }
+    /** PUT with the payload's SHA-256, which the server verifies. */
+    const putBytes = (url, bytes, headers, signal) => send(url, {
+        method: "PUT",
+        // fetch sends any ArrayBufferView; the DOM types want one over an ArrayBuffer.
+        body: bytes,
+        headers: { ...headers, "x-amz-content-sha256": sha256Hex(bytes) },
+        ...(signal ? { signal } : {}),
+    });
+    async function head(key) {
+        assertBlobKey(key);
+        const response = await send(objectUrl(key), { method: "HEAD" });
+        if (response.status === 404)
+            return undefined;
+        if (!response.ok)
+            throw await failure(response, `HEAD ${key}`);
+        return metaOf(key, response.headers, Number(response.headers.get("content-length") ?? 0));
+    }
+    function metaOf(key, headers, size) {
+        const modified = headers.get("last-modified");
+        return {
+            key,
+            size,
+            contentType: headers.get("content-type") ?? DEFAULT_CONTENT_TYPE,
+            lastModified: modified ? new Date(modified) : new Date(0),
+        };
+    }
+    async function putMultipart(key, first, rest, state, put) {
+        const signal = put.signal;
+        const created = await send(objectUrl(key, { uploads: "" }), {
+            method: "POST",
+            headers: { "content-type": put.contentType ?? DEFAULT_CONTENT_TYPE },
+            ...(signal ? { signal } : {}),
+        }, true);
+        if (!created.ok)
+            throw await failure(created, `CreateMultipartUpload ${key}`);
+        const uploadId = tag(await created.text(), "UploadId");
+        if (!uploadId)
+            throw new BlobStoreError(`CreateMultipartUpload ${key} returned no UploadId`);
+        const parts = [];
+        const uploadPart = async (bytes) => {
+            const number = parts.length + 1;
+            const response = await putBytes(objectUrl(key, { partNumber: String(number), uploadId }), bytes, {}, signal);
+            if (!response.ok)
+                throw await failure(response, `UploadPart ${number} of ${key}`);
+            await response.body?.cancel();
+            const etag = response.headers.get("etag");
+            if (!etag)
+                throw new BlobStoreError(`UploadPart ${number} of ${key} returned no ETag`);
+            parts.push({ number, etag });
+        };
+        try {
+            await uploadPart(first);
+            let buffered = [];
+            let length = 0;
+            for (;;) {
+                const next = await rest.next();
+                if (next.done)
+                    break;
+                const chunk = next.value;
+                signal?.throwIfAborted();
+                state.size += chunk.byteLength;
+                if (put.maxBytes !== undefined && state.size > put.maxBytes)
+                    throw new BlobTooLargeError(put.maxBytes);
+                state.hash.update(chunk);
+                buffered.push(chunk);
+                length += chunk.byteLength;
+                if (length >= partSize) {
+                    await uploadPart(concat(buffered, length));
+                    buffered = [];
+                    length = 0;
+                }
+            }
+            if (length > 0)
+                await uploadPart(concat(buffered, length));
+            const body = `<CompleteMultipartUpload>${parts
+                .map((part) => `<Part><PartNumber>${part.number}</PartNumber><ETag>${escapeXml(part.etag)}</ETag></Part>`)
+                .join("")}</CompleteMultipartUpload>`;
+            const completed = await send(objectUrl(key, { uploadId }), {
+                method: "POST",
+                body,
+                headers: { "content-type": "application/xml", "x-amz-content-sha256": sha256Hex(new TextEncoder().encode(body)) },
+                ...(signal ? { signal } : {}),
+            }, true);
+            // CompleteMultipartUpload may answer 200 with an error in the body.
+            const text = completed.ok ? await completed.text() : "";
+            if (!completed.ok)
+                throw await failure(completed, `CompleteMultipartUpload ${key}`);
+            if (/<Error>/.test(text))
+                throw new BlobStoreError(`CompleteMultipartUpload ${key} failed: ${tag(text, "Code") ?? "error"}: ${tag(text, "Message") ?? ""}`, completed.status, tag(text, "Code"));
+        }
+        catch (error) {
+            // Best effort: an upload left behind holds only parts, never an object.
+            await send(objectUrl(key, { uploadId }), { method: "DELETE" })
+                .then((response) => response.body?.cancel())
+                .catch(() => undefined);
+            throw error;
+        }
+    }
+    return {
+        kind: "s3",
+        async ensureBucket() {
+            const found = await send(bucketUrl, { method: "HEAD" });
+            if (found.ok)
+                return;
+            if (found.status !== 404)
+                throw await failure(found, `HEAD bucket ${options.bucket}`);
+            const region = options.region ?? "us-east-1";
+            const body = region === "us-east-1"
+                ? undefined
+                : `<CreateBucketConfiguration><LocationConstraint>${escapeXml(region)}</LocationConstraint></CreateBucketConfiguration>`;
+            const created = await send(bucketUrl, {
+                method: "PUT",
+                ...(body
+                    ? {
+                        body,
+                        headers: {
+                            "content-type": "application/xml",
+                            "x-amz-content-sha256": sha256Hex(new TextEncoder().encode(body)),
+                        },
+                    }
+                    : {}),
+            });
+            if (created.ok) {
+                await created.body?.cancel();
+                return;
+            }
+            const error = await failure(created, `CreateBucket ${options.bucket}`);
+            if (error.code === "BucketAlreadyOwnedByYou" || error.code === "BucketAlreadyExists")
+                return;
+            throw error;
+        },
+        async put(key, body, put = {}) {
+            assertBlobKey(key);
+            assertMaxBytes(put.maxBytes);
+            put.signal?.throwIfAborted();
+            const state = { size: 0, hash: createHash("sha256") };
+            const chunks = chunksOf(body)[Symbol.asyncIterator]();
+            // Buffer up to one part: a body that ends first goes in one PutObject.
+            const buffered = [];
+            let length = 0;
+            let ended = false;
+            try {
+                while (length < partSize) {
+                    const next = await chunks.next();
+                    if (next.done) {
+                        ended = true;
+                        break;
+                    }
+                    put.signal?.throwIfAborted();
+                    state.size += next.value.byteLength;
+                    if (put.maxBytes !== undefined && state.size > put.maxBytes)
+                        throw new BlobTooLargeError(put.maxBytes);
+                    state.hash.update(next.value);
+                    buffered.push(next.value);
+                    length += next.value.byteLength;
+                }
+                const first = concat(buffered, length);
+                if (ended) {
+                    const response = await putBytes(objectUrl(key), first, { "content-type": put.contentType ?? DEFAULT_CONTENT_TYPE }, put.signal);
+                    if (!response.ok)
+                        throw await failure(response, `PUT ${key}`);
+                    await response.body?.cancel();
+                }
+                else {
+                    await putMultipart(key, first, chunks, state, put);
+                }
+            }
+            catch (error) {
+                await chunks.return?.(undefined).catch(() => undefined);
+                throw error;
+            }
+            return { key, size: state.size, sha256: state.hash.digest("hex") };
+        },
+        async get(key, get = {}) {
+            assertBlobKey(key);
+            const range = get.range;
+            if (range)
+                assertRange(range);
+            const response = await send(objectUrl(key), {
+                method: "GET",
+                ...(range ? { headers: { range: `bytes=${range.start}-${range.end ?? ""}` } } : {}),
+                ...(get.signal ? { signal: get.signal } : {}),
+            });
+            if (response.status === 404) {
+                await response.body?.cancel();
+                return undefined;
+            }
+            if (response.status === 416 && range) {
+                await response.body?.cancel();
+                const total = /\/(\d+)$/.exec(response.headers.get("content-range") ?? "")?.[1];
+                throw new BlobRangeError(range, total !== undefined ? Number(total) : ((await head(key))?.size ?? 0));
+            }
+            if (!response.ok || !response.body)
+                throw await failure(response, `GET ${key}`);
+            const length = Number(response.headers.get("content-length") ?? 0);
+            if (response.status === 206) {
+                const match = /^bytes (\d+)-(\d+)\/(\d+|\*)$/.exec(response.headers.get("content-range") ?? "");
+                if (!match) {
+                    await response.body.cancel();
+                    throw new BlobStoreError(`GET ${key} answered 206 without a Content-Range`);
+                }
+                const size = match[3] === "*" ? ((await head(key))?.size ?? 0) : Number(match[3]);
+                return {
+                    ...metaOf(key, response.headers, size),
+                    body: response.body,
+                    range: { start: Number(match[1]), end: Number(match[2]) },
+                };
+            }
+            // 200: the whole object. A server that ignores Range sends it all too.
+            const meta = metaOf(key, response.headers, length);
+            if (!range)
+                return { ...meta, body: response.body };
+            if (range.start >= length) {
+                await response.body.cancel();
+                throw new BlobRangeError(range, length);
+            }
+            if (range.start !== 0) {
+                await response.body.cancel();
+                throw new BlobStoreError(`GET ${key} ignored the Range header`);
+            }
+            return { ...meta, body: response.body, range: { start: 0, end: length - 1 } };
+        },
+        head,
+        async delete(key) {
+            assertBlobKey(key);
+            const response = await send(objectUrl(key), { method: "DELETE" });
+            if (response.ok || response.status === 404) {
+                await response.body?.cancel();
+                return;
+            }
+            throw await failure(response, `DELETE ${key}`);
+        },
+        async *list(prefix) {
+            assertBlobPrefix(prefix);
+            let token;
+            do {
+                const url = new URL(bucketUrl);
+                url.searchParams.set("list-type", "2");
+                if (prefix !== "")
+                    url.searchParams.set("prefix", prefix);
+                if (token)
+                    url.searchParams.set("continuation-token", token);
+                const response = await send(url.toString(), { method: "GET" });
+                if (!response.ok)
+                    throw await failure(response, `ListObjectsV2 ${prefix}`);
+                const xml = await response.text();
+                for (const entry of blocks(xml, "Contents")) {
+                    const key = tag(entry, "Key");
+                    if (key === undefined)
+                        continue;
+                    const modified = tag(entry, "LastModified");
+                    yield {
+                        key,
+                        size: Number(tag(entry, "Size") ?? 0),
+                        lastModified: modified ? new Date(modified) : new Date(0),
+                    };
+                }
+                token = tag(xml, "IsTruncated") === "true" ? tag(xml, "NextContinuationToken") : undefined;
+            } while (token);
+        },
+    };
+}

package/dist/blob/types.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The `BlobStore` seam (blueprint D35, F8.1): the only way the Runtime reaches the Object
+ * store. Bytes live here; what they mean lives in Postgres, which is the commit point: an
+ * object counts only once a committed row references its key, so an orphaned upload is
+ * garbage, never data. Keys are chosen by the Runtime (fresh random ids), so the seam needs no
+ * conditional writes.
+ *
+ * Two adapters, held to one conformance suite (`test/blob/conformance.ts`):
+ * - `s3` (`./s3.ts`): the plain S3 API, against RustFS in the local stack and S3 or any S3
+ *   server elsewhere;
+ * - `fs` (`./fs.ts`): files under a directory, for embedding and tests.
+ */
+/** A body to store: bytes, a web stream, or any async iterable of chunks (a Node stream). */
+export type BlobBody = Uint8Array | ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
+export interface BlobPutOptions {
+    /** Stored with the object and returned by `head` and `get`. Default `application/octet-stream`. */
+    contentType?: string;
+    /**
+     * Refuse a body longer than this many bytes with `BlobTooLargeError`; nothing is stored. The
+     * body is counted as it streams, so a caller need not know its length up front.
+     */
+    maxBytes?: number;
+    signal?: AbortSignal;
+}
+export interface BlobPutResult {
+    key: string;
+    /** Bytes stored. */
+    size: number;
+    /** SHA-256 of the bytes stored, lowercase hex. */
+    sha256: string;
+}
+export interface BlobMeta {
+    key: string;
+    /** The whole object's size in bytes. */
+    size: number;
+    contentType: string;
+    lastModified: Date;
+}
+/** Bytes `start` to `end`, both inclusive, as in an HTTP `Range` header. */
+export interface BlobRange {
+    start: number;
+    /** Inclusive; past the end of the object means "to the end". Default: to the end. */
+    end?: number;
+}
+export interface BlobGetOptions {
+    /** Only these bytes. A range that starts at or past the end throws `BlobRangeError`. */
+    range?: BlobRange;
+    signal?: AbortSignal;
+}
+export interface BlobGetResult extends BlobMeta {
+    /** The bytes asked for: the whole object, or the range. Read it or cancel it. */
+    body: ReadableStream<Uint8Array>;
+    /** Present when a range was asked for: the bytes `body` holds, both inclusive. */
+    range?: {
+        start: number;
+        end: number;
+    };
+}
+/** An entry of `list`: the object's key, size and when it was last written. */
+export interface BlobListEntry {
+    key: string;
+    size: number;
+    lastModified: Date;
+}
+export interface BlobStore {
+    /** Which adapter this is, for logs and `/ready`. */
+    readonly kind: "fs" | "s3";
+    /** Store `body` at `key`, replacing what is there. Streams; counts and hashes as it goes. */
+    put(key: string, body: BlobBody, options?: BlobPutOptions): Promise<BlobPutResult>;
+    /** The object's bytes and metadata, or `undefined` when there is none at `key`. */
+    get(key: string, options?: BlobGetOptions): Promise<BlobGetResult | undefined>;
+    /** The object's metadata, or `undefined` when there is none at `key`. */
+    head(key: string): Promise<BlobMeta | undefined>;
+    /** Remove the object; removing one that is not there succeeds. */
+    delete(key: string): Promise<void>;
+    /** Every object whose key starts with `prefix`, in key order. */
+    list(prefix: string): AsyncIterable<BlobListEntry>;
+}
+/** The Object store failed or refused a request; `status` is the HTTP status when it has one. */
+export declare class BlobStoreError extends Error {
+    readonly status?: number | undefined;
+    readonly code?: string | undefined;
+    constructor(message: string, status?: number | undefined, code?: string | undefined);
+}
+/** A `put` body grew past `maxBytes`. Nothing was stored. */
+export declare class BlobTooLargeError extends Error {
+    readonly maxBytes: number;
+    constructor(maxBytes: number);
+}
+/** A `get` range starts at or past the end of the object (HTTP 416). */
+export declare class BlobRangeError extends Error {
+    readonly range: BlobRange;
+    readonly size: number;
+    constructor(range: BlobRange, size: number);
+}
+export declare const DEFAULT_CONTENT_TYPE = "application/octet-stream";
+export declare const MAX_KEY_BYTES = 1024;
+/**
+ * Keys are `/`-separated segments of `A-Z a-z 0-9 . _ -`, neither `.` nor `..`, at most 1024
+ * bytes: safe as S3 keys without encoding surprises and as relative paths for `fs`.
+ */
+export declare function assertBlobKey(key: string): void;
+/** A `list` prefix: empty, a key, or a key followed by `/` (or the start of a segment). */
+export declare function assertBlobPrefix(prefix: string): void;
+export declare function assertRange(range: BlobRange): void;
+export declare function assertMaxBytes(maxBytes: number | undefined): void;
+/** The chunks of a `BlobBody`, as `Uint8Array`s. */
+export declare function chunksOf(body: BlobBody): AsyncGenerator<Uint8Array>;

package/dist/blob/types.js

@@ -0,0 +1,85 @@
+/**
+ * The `BlobStore` seam (blueprint D35, F8.1): the only way the Runtime reaches the Object
+ * store. Bytes live here; what they mean lives in Postgres, which is the commit point: an
+ * object counts only once a committed row references its key, so an orphaned upload is
+ * garbage, never data. Keys are chosen by the Runtime (fresh random ids), so the seam needs no
+ * conditional writes.
+ *
+ * Two adapters, held to one conformance suite (`test/blob/conformance.ts`):
+ * - `s3` (`./s3.ts`): the plain S3 API, against RustFS in the local stack and S3 or any S3
+ *   server elsewhere;
+ * - `fs` (`./fs.ts`): files under a directory, for embedding and tests.
+ */
+/** The Object store failed or refused a request; `status` is the HTTP status when it has one. */
+export class BlobStoreError extends Error {
+    status;
+    code;
+    constructor(message, status, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "BlobStoreError";
+    }
+}
+/** A `put` body grew past `maxBytes`. Nothing was stored. */
+export class BlobTooLargeError extends Error {
+    maxBytes;
+    constructor(maxBytes) {
+        super(`The body is larger than ${maxBytes} bytes`);
+        this.maxBytes = maxBytes;
+        this.name = "BlobTooLargeError";
+    }
+}
+/** A `get` range starts at or past the end of the object (HTTP 416). */
+export class BlobRangeError extends Error {
+    range;
+    size;
+    constructor(range, size) {
+        super(`Range ${range.start}-${range.end ?? ""} is outside an object of ${size} bytes`);
+        this.range = range;
+        this.size = size;
+        this.name = "BlobRangeError";
+    }
+}
+export const DEFAULT_CONTENT_TYPE = "application/octet-stream";
+export const MAX_KEY_BYTES = 1024;
+const SEGMENT = /^[A-Za-z0-9._-]+$/;
+/**
+ * Keys are `/`-separated segments of `A-Z a-z 0-9 . _ -`, neither `.` nor `..`, at most 1024
+ * bytes: safe as S3 keys without encoding surprises and as relative paths for `fs`.
+ */
+export function assertBlobKey(key) {
+    if (typeof key !== "string" || key === "" || key.length > MAX_KEY_BYTES)
+        throw new TypeError(`Blob key must be 1 to ${MAX_KEY_BYTES} characters`);
+    for (const segment of key.split("/"))
+        if (!SEGMENT.test(segment) || segment === "." || segment === "..")
+            throw new TypeError(`Blob key ${JSON.stringify(key)} must be /-separated segments of A-Z a-z 0-9 . _ -, none . or ..`);
+}
+/** A `list` prefix: empty, a key, or a key followed by `/` (or the start of a segment). */
+export function assertBlobPrefix(prefix) {
+    if (prefix === "")
+        return;
+    assertBlobKey(prefix.endsWith("/") ? prefix.slice(0, -1) : prefix);
+}
+export function assertRange(range) {
+    if (!Number.isSafeInteger(range.start) || range.start < 0)
+        throw new TypeError("Range start must be a non-negative integer");
+    if (range.end !== undefined && (!Number.isSafeInteger(range.end) || range.end < range.start))
+        throw new TypeError("Range end must be an integer no smaller than start");
+}
+export function assertMaxBytes(maxBytes) {
+    if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes < 0))
+        throw new TypeError("maxBytes must be a non-negative integer");
+}
+/** The chunks of a `BlobBody`, as `Uint8Array`s. */
+export async function* chunksOf(body) {
+    if (body instanceof Uint8Array) {
+        yield body;
+        return;
+    }
+    for await (const chunk of body) {
+        if (!(chunk instanceof Uint8Array))
+            throw new TypeError("A blob body must yield Uint8Array chunks");
+        yield chunk;
+    }
+}

package/dist/core/sandbox-routes.d.ts

@@ -1,5 +1,5 @@
 import type { Action } from "@nylorun/core/contracts";
-import type { SandboxManager } from "../sandbox/manager.js";
+import type { WorkspacePort } from "../harness-api/workspace.js";
 import type { SandboxToolOutcome } from "../sandbox/tools.js";
 import { type SessionSandboxRef } from "../sandbox/share.js";
 export declare class SandboxRouteError extends Error {
@@ -16,7 +16,7 @@ export type SandboxRouteRead = {
     readonly lookup: (id: string) => SessionSandboxRef | undefined;
 };
 export type SandboxRouteDeps = {
-    readonly sandbox: SandboxManager;
+    readonly sandbox: Pick<WorkspacePort, "run">;
     /** The session (rejects when missing) and its owner chain, read in one transaction. */
     readonly session: (id: string) => Promise<SandboxRouteRead>;
     readonly getAction: (id: string) => Promise<Action | undefined>;

package/dist/core/sandbox-routes.js

@@ -3,7 +3,7 @@
  * Wired from TenantRuntime; keeps route bodies out of the hot runtime file.
  */
 import { isSandboxToolName, } from "@nylorun/core/define";
-import { capabilityForSandbox, owningSandboxSessionId, sandboxSpecOf, sandboxSpecsEqual, sessionSandboxSpec, } from "../sandbox/share.js";
+import { capabilityForSandbox, owningSandboxSessionId, sandboxSpecOf, sandboxWorkspaceOf, sandboxSpecsEqual, sessionSandboxSpec, } from "../sandbox/share.js";
 export class SandboxRouteError extends Error {
     status;
     constructor(status, message) {
@@ -36,11 +36,12 @@ function toolInput(body) {
 }
 async function runTool(deps, { session, lookup }, tool, input, signal) {
     const spec = resolveSpec(session, lookup);
-    const ownerId = owningSandboxSessionId(session, lookup);
+    const workspace = sandboxWorkspaceOf(session, lookup);
     const ref = {
-        id: ownerId,
+        id: workspace.ownerId,
         activeTurnId: session.activeTurnId,
         manifest: session.manifest,
+        ...(workspace.sandboxId === undefined ? {} : { sandboxId: workspace.sandboxId }),
     };
     return deps.sandbox.run(ref, capabilityForSandbox(spec), tool, input, signal);
 }

package/dist/execution/memory.d.ts

@@ -1,4 +1,4 @@
-import { type DurableExecution, type Wake, type WorkerHandlers } from "./types.js";
+import { type DurableExecution, type SandboxSignal, type Wake, type WorkerHandlers } from "./types.js";
 export interface MemoryExecutionOptions {
     /** Delay between sweep passes of one Tenant. Default 5000. */
     sweepIntervalMs?: number;
@@ -8,6 +8,11 @@ export interface MemoryExecutionOptions {
     maxAttempts?: number;
     /** How long a dedupe key merges repeated wakes. Default 24 hours. */
     dedupeRetentionMs?: number;
+    /**
+     * How long `stop` waits for running handlers after aborting them; the ones still running
+     * then are abandoned. Default `DEFAULT_STOP_GRACE_MS`.
+     */
+    stopGraceMs?: number;
     /** Receives handler failures that are not retried. */
     onError?: (error: unknown) => void;
 }
@@ -23,16 +28,21 @@ export declare class MemoryExecution implements DurableExecution {
     private readonly seen;
     private readonly timers;
     private readonly sweeps;
+    private readonly sandboxes;
     private readonly delayed;
     private readonly inflight;
     private readonly sweepIntervalMs;
     private readonly retryDelayMs;
     private readonly maxAttempts;
     private readonly dedupeRetentionMs;
+    private readonly stopGraceMs;
     private readonly onError;
     constructor(options?: MemoryExecutionOptions);
     wake(tenantId: string, sessionId: string, wake: Wake): Promise<void>;
     deliver(tenantId: string, actionId: string): Promise<void>;
+    sandbox(tenantId: string, sandboxId: string, signal: SandboxSignal): Promise<void>;
+    private armSandbox;
+    private runSandbox;
     timer(tenantId: string, key: string, at: Date): Promise<void>;
     armSweep(tenantId: string): Promise<void>;
     disarmSweep(tenantId: string): Promise<void>;