withruntime 0.18.0 → 0.23.0

package/dist/client.js

@@ -167,6 +167,26 @@ export class AccountApi {
      * name exactly (`me().orgName`). Needs a key for every product made by an
      * owner. Moves no money: what is unspent of a purchase made in the last 15
      * days is refunded on request; other credit is forfeited. */
+    /** Which of Runtime's optional emails this key's person gets for this
+     * account. Without `set`, reads them; with `{ category, enabled }`, turns
+     * one on or off for that person only, and answers all of them. Sign-in,
+     * support replies, credit expiry and deletions Runtime decides are always
+     * sent and are not listed. */
+    async emails(set, options = {}) {
+        const answer = set
+            ? await this.t.json({
+                method: "POST",
+                path: "/v1/account/emails:update",
+                body: { category: set.category, enabled: set.enabled },
+                ...options,
+            })
+            : await this.t.json({
+                method: "GET",
+                path: "/v1/account/emails",
+                ...options,
+            });
+        return answer.settings;
+    }
     close(input, options = {}) {
         return this.t.json({
             method: "POST",

package/dist/cloudflare/errors.d.ts

@@ -119,6 +119,29 @@ export declare class OperationInterruptedError extends SandboxError<{
 }> {
     get reason(): string;
 }
+/** Cloudflare's transport error for its WebSocket sessions; Runtime's API
+ * has no such session, so the adapter never throws it. */
+export declare class RPCTransportError extends SandboxError<{
+    kind: string;
+    originalMessage: string;
+}> {
+    get kind(): string;
+    get originalMessage(): string;
+}
+/** Input the container refuses, such as content that is not base64. */
+export declare class ValidationFailedError extends SandboxError<{
+    validationErrors: {
+        field: string;
+        message: string;
+        code: string;
+    }[];
+}> {
+    get validationErrors(): {
+        field: string;
+        message: string;
+        code: string;
+    }[];
+}
 export declare class BucketMountError extends Error {
     readonly code: string;
     constructor(message: string, code?: string);

package/dist/cloudflare/errors.js

@@ -125,6 +125,22 @@ export class OperationInterruptedError extends SandboxError {
         return this.context.reason;
     }
 }
+/** Cloudflare's transport error for its WebSocket sessions; Runtime's API
+ * has no such session, so the adapter never throws it. */
+export class RPCTransportError extends SandboxError {
+    get kind() {
+        return this.context.kind;
+    }
+    get originalMessage() {
+        return this.context.originalMessage;
+    }
+}
+/** Input the container refuses, such as content that is not base64. */
+export class ValidationFailedError extends SandboxError {
+    get validationErrors() {
+        return this.context.validationErrors;
+    }
+}
 export class BucketMountError extends Error {
     code;
     constructor(message, code = "BUCKET_MOUNT_ERROR") {

package/dist/cloudflare/index.d.ts

@@ -6,8 +6,11 @@ export { CompatibilityError };
 export * from "./errors.js";
 export { CodeInterpreter } from "./interpreter.js";
 export type { CodeContext, CreateContextOptions, ExecutionError, OutputMessage, RunCodeOptions, } from "./interpreter.js";
-export { collectFile, isExecResult, isProcess, isProcessStatus, parseSSEStream, streamFile, } from "./streams.js";
+export { collectFile, isExecResult, isProcess, isProcessStatus, parseSSEStream, streamFile, asyncIterableToSSEStream, responseToAsyncIterable, } from "./streams.js";
 export type { FileChunk, FileMetadata, FileStreamEvent } from "./streams.js";
+export * from "./types.js";
+/** Cloudflare's interface for its Sandbox class. */
+export type ISandbox = Sandbox;
 export declare class SandboxSecurityError extends Error {
     readonly code: string;
     constructor(message: string, code: string);
@@ -58,6 +61,13 @@ export type CheckChangesResult = {
     version: string;
     timestamp: string;
 };
+export interface GitCheckoutOptions {
+    branch?: string;
+    targetDir?: string;
+    sessionId?: string;
+    depth?: number;
+    cloneTimeoutMs?: number;
+}
 export interface GitCheckoutResult {
     success: boolean;
     repoUrl: string;
@@ -96,6 +106,7 @@ export interface ReadFileResult {
     content: string;
     encoding: "utf-8" | "base64";
     isBinary: boolean;
+    mimeType: string;
     size: number;
     timestamp: string;
 }
@@ -115,6 +126,16 @@ export interface SessionOptions {
     isolation?: boolean;
     commandTimeoutMs?: number;
 }
+export interface WaitForPortOptions {
+    mode?: "http" | "tcp";
+    path?: string;
+    status?: number | {
+        min: number;
+        max: number;
+    };
+    timeout?: number;
+    interval?: number;
+}
 export interface ProcessOptions {
     timeout?: number;
     env?: Record<string, string | undefined>;
@@ -312,13 +333,7 @@ export declare class Sandbox {
         signal?: AbortSignal;
     }): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
     /** Clones with git in the sandbox, as Cloudflare's container does. */
-    gitCheckout(repoUrl: string, options?: {
-        branch?: string;
-        targetDir?: string;
-        sessionId?: string;
-        depth?: number;
-        cloneTimeoutMs?: number;
-    }): Promise<GitCheckoutResult>;
+    gitCheckout(repoUrl: string, options?: GitCheckoutOptions): Promise<GitCheckoutResult>;
     /** Changes under a directory as `data:` lines of Cloudflare's watch events,
      * once the watch is established, until the stream is cancelled. */
     watch(path: string, options?: WatchOptions): Promise<ReadableStream<Uint8Array>>;
@@ -442,6 +457,57 @@ export declare class ExecutionSession {
         timestamp: string;
     }>;
     setEnvVars(env: Record<string, string | undefined>): Promise<void>;
+    moveFile(path: string, newPath: string): Promise<{
+        success: boolean;
+        path: string;
+        newPath: string;
+        timestamp: string;
+    }>;
+    readFileStream(path: string): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    gitCheckout(repoUrl: string, options?: Omit<GitCheckoutOptions, "sessionId">): Promise<GitCheckoutResult>;
+    watch(path: string, options?: Omit<WatchOptions, "sessionId">): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    checkChanges(path: string, options?: Omit<CheckChangesOptions, "sessionId">): Promise<CheckChangesResult>;
+    listProcesses(): Promise<Process[]>;
+    getProcess(id: string): Promise<Process | null>;
+    killProcess(id: string, signal?: string): Promise<void>;
+    killAllProcesses(): Promise<number>;
+    cleanupCompletedProcesses(): Promise<number>;
+    getProcessLogs(id: string): Promise<{
+        stdout: string;
+        stderr: string;
+        processId: string;
+    }>;
+    streamProcessLogs(id: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    createCodeContext(options?: CreateContextOptions): Promise<CodeContext>;
+    runCode(code: string, options?: RunCodeOptions): Promise<{
+        code: string;
+        logs: {
+            stdout: string[];
+            stderr: string[];
+        };
+        error: import("./interpreter.js").ExecutionError | undefined;
+        executionCount: number | undefined;
+        results: {
+            text: string | undefined;
+            html: string | undefined;
+            png: string | undefined;
+            jpeg: string | undefined;
+            svg: string | undefined;
+            latex: string | undefined;
+            markdown: string | undefined;
+            javascript: string | undefined;
+            json: unknown;
+            chart: undefined;
+            data: Record<string, unknown> | undefined;
+        }[];
+    }>;
+    runCodeStream(code: string, options?: RunCodeOptions): Promise<ReadableStream<any>>;
+    listCodeContexts(): Promise<CodeContext[]>;
+    deleteCodeContext(contextId: string): Promise<void>;
+    mountBucket(bucket: string, mountPath: string, options: MountBucketOptions): Promise<void>;
+    unmountBucket(mountPath: string): Promise<void>;
 }
 export declare class Process {
     #private;
@@ -466,7 +532,14 @@ export declare class Process {
         exitCode: number;
     }>;
     waitForLog(pattern: string | RegExp, timeout?: number): Promise<{
-        match?: true | RegExpMatchArray | undefined;
         line: string;
+        match?: undefined;
+    } | {
+        line: string;
+        match: RegExpMatchArray;
     }>;
+    /** Resolves once the port answers: an HTTP status in range (200-399 by
+     * default) at `path`, or a TCP connection in `tcp` mode. Throws if the
+     * process ends first, or after `timeout` milliseconds when one is given. */
+    waitForPort(port: number, options?: WaitForPortOptions): Promise<void>;
 }

package/dist/cloudflare/index.js

@@ -3,14 +3,16 @@ import { Runtime } from "../client.js";
 import { NotFoundError } from "../errors.js";
 import { timeoutSignal } from "../transport.js";
 import { quote, client, closeShell, CompatibilityError, refuse, destroy, environment, execOptions, only, pathAt, saveEnvironment, shellCommand, shellRoot, } from "../compat/core.js";
-import { BucketUnmountError, InvalidMountConfigError, ProcessExitedBeforeReadyError, ProcessReadyTimeoutError, S3FSMountError, response, } from "./errors.js";
+import { BucketUnmountError, InvalidMountConfigError, ProcessExitedBeforeReadyError, ProcessReadyTimeoutError, S3FSMountError, ValidationFailedError, response, } from "./errors.js";
 import { CodeInterpreter, hasEnv, RUN_ENV, } from "./interpreter.js";
 import { sseStream } from "./streams.js";
+import { mimeType } from "./mime.js";
 import { CHANGES, watchFilters } from "./watch.js";
 export { CompatibilityError };
 export * from "./errors.js";
 export { CodeInterpreter } from "./interpreter.js";
-export { collectFile, isExecResult, isProcess, isProcessStatus, parseSSEStream, streamFile, } from "./streams.js";
+export { collectFile, isExecResult, isProcess, isProcessStatus, parseSSEStream, streamFile, asyncIterableToSSEStream, responseToAsyncIterable, } from "./streams.js";
+export * from "./types.js";
 export class SandboxSecurityError extends Error {
     code;
     constructor(message, code) {
@@ -262,7 +264,7 @@ export class Sandbox {
         return sseStream(async (send) => {
             send({
                 type: "metadata",
-                mimeType: isBinary ? "application/octet-stream" : "text/plain",
+                mimeType: read.mimeType,
                 size: bytes.length,
                 isBinary,
                 encoding: isBinary ? "base64" : "utf-8",
@@ -800,11 +802,18 @@ export class ExecutionSession {
         if (options.encoding && !["utf8", "utf-8", "base64"].includes(options.encoding))
             throw new CompatibilityError("Cloudflare", `file encoding ${options.encoding}`);
         let bytes;
-        if (typeof content === "string")
-            bytes =
-                options.encoding === "base64"
-                    ? Uint8Array.from(atob(content), (c) => c.charCodeAt(0))
-                    : new TextEncoder().encode(content);
+        if (typeof content === "string" && options.encoding === "base64") {
+            // Cloudflare's container refuses anything but base64's alphabet.
+            if (!/^[A-Za-z0-9+/=]*$/.test(content))
+                throw new ValidationFailedError(response("VALIDATION_FAILED", `Invalid base64 content for '${path}': must contain only A-Z, a-z, 0-9, +, /, =`, {
+                    validationErrors: [
+                        { field: "content", message: "Invalid base64 characters", code: "INVALID_BASE64" },
+                    ],
+                }, { httpStatus: 400 }));
+            bytes = Uint8Array.from(atob(content), (c) => c.charCodeAt(0));
+        }
+        else if (typeof content === "string")
+            bytes = new TextEncoder().encode(content);
         else {
             const buffer = await new Response(content).arrayBuffer();
             bytes = new Uint8Array(buffer);
@@ -813,7 +822,7 @@ export class ExecutionSession {
         return { success: true, path, bytesWritten: bytes.length, timestamp: new Date().toISOString() };
     }
     async readFile(path, options = {}) {
-        const s = await this.sandbox.native(), bytes = await s.files.read(await this.path(path));
+        const s = await this.sandbox.native(), resolved = await this.path(path), bytes = await s.files.read(resolved), type = mimeType(resolved, bytes);
         if (options.encoding === "none")
             return {
                 success: true,
@@ -825,7 +834,7 @@ export class ExecutionSession {
                     },
                 }),
                 size: bytes.length,
-                mimeType: "application/octet-stream",
+                mimeType: type,
                 timestamp: new Date().toISOString(),
             };
         const text = new TextDecoder().decode(bytes), binary = text.includes("\0") || text.includes("\ufffd"), encoded = options.encoding === "base64" || (options.encoding === undefined && binary);
@@ -839,6 +848,7 @@ export class ExecutionSession {
             content: encoded ? btoa(raw) : text,
             encoding: encoded ? "base64" : "utf-8",
             isBinary: binary,
+            mimeType: type,
             size: bytes.length,
             timestamp: new Date().toISOString(),
         };
@@ -888,7 +898,68 @@ export class ExecutionSession {
         this.options = { ...this.options, env: { ...this.options.env, ...cleanEnv(env) } };
         await (await this.sandbox.native()).files.write(`/workspace/.runtime-compat/cloudflare/${encodeURIComponent(this.id)}.json`, JSON.stringify(this.options), { mode: 0o600 });
     }
+    // The rest of Cloudflare's ExecutionSession: the sandbox's calls, in this session.
+    moveFile(path, newPath) {
+        return this.renameFile(path, newPath);
+    }
+    readFileStream(path) {
+        return this.sandbox.readFileStream(path, { sessionId: this.id });
+    }
+    gitCheckout(repoUrl, options = {}) {
+        return this.sandbox.gitCheckout(repoUrl, { ...options, sessionId: this.id });
+    }
+    watch(path, options = {}) {
+        return this.sandbox.watch(path, { ...options, sessionId: this.id });
+    }
+    checkChanges(path, options = {}) {
+        return this.sandbox.checkChanges(path, { ...options, sessionId: this.id });
+    }
+    listProcesses() {
+        return this.sandbox.listProcesses();
+    }
+    getProcess(id) {
+        return this.sandbox.getProcess(id);
+    }
+    killProcess(id, signal) {
+        return this.sandbox.killProcess(id, signal);
+    }
+    killAllProcesses() {
+        return this.sandbox.killAllProcesses();
+    }
+    cleanupCompletedProcesses() {
+        return this.sandbox.cleanupCompletedProcesses();
+    }
+    getProcessLogs(id) {
+        return this.sandbox.getProcessLogs(id);
+    }
+    streamProcessLogs(id, options) {
+        return this.sandbox.streamProcessLogs(id, options);
+    }
+    createCodeContext(options) {
+        return this.sandbox.createCodeContext(options);
+    }
+    runCode(code, options) {
+        return this.sandbox.runCode(code, options);
+    }
+    runCodeStream(code, options) {
+        return this.sandbox.runCodeStream(code, options);
+    }
+    listCodeContexts() {
+        return this.sandbox.listCodeContexts();
+    }
+    deleteCodeContext(contextId) {
+        return this.sandbox.deleteCodeContext(contextId);
+    }
+    mountBucket(bucket, mountPath, options) {
+        return this.sandbox.mountBucket(bucket, mountPath, options);
+    }
+    unmountBucket(mountPath) {
+        return this.sandbox.unmountBucket(mountPath);
+    }
 }
+refuse("Cloudflare", "ExecutionSession", ExecutionSession, {
+    terminal: "open a terminal with the native Runtime sandbox's terminal()",
+});
 export class Process {
     sandbox;
     native;
@@ -940,43 +1011,96 @@ export class Process {
         });
         return { exitCode: r.exitCode ?? -1 };
     }
-    async waitForLog(pattern, timeout = 30000) {
-        const condition = `log pattern ${String(pattern)}`;
-        const context = { processId: this.id, command: this.command, condition };
+    /** Cloudflare's errors for a wait, with its messages: a timeout, or the
+     * process ending first. */
+    #timedOut(condition, timeout) {
+        return new ProcessReadyTimeoutError(response("PROCESS_READY_TIMEOUT", `Process did not become ready within ${timeout}ms. Waiting for: ${condition}`, { processId: this.id, command: this.command, condition, timeout }, {
+            httpStatus: 408,
+            suggestion: `Check if your process outputs ${condition}. You can increase the timeout parameter.`,
+        }));
+    }
+    #exited(condition, exitCode) {
+        return new ProcessExitedBeforeReadyError(response("PROCESS_EXITED_BEFORE_READY", `Process exited with code ${exitCode} before becoming ready. Waiting for: ${condition}`, { processId: this.id, command: this.command, condition, exitCode }, { httpStatus: 500, suggestion: "Check process logs with getLogs() for error messages" }));
+    }
+    /** Waits as Cloudflare does: with no limit unless `timeout` is given. */
+    async #within(condition, timeout, wait) {
+        if (timeout === undefined)
+            return wait();
         const signal = timeoutSignal(timeout);
         try {
-            return await this.#waitForLog(pattern, signal);
+            return await wait(signal);
         }
         catch (error) {
             if (!signal.aborted)
                 throw error;
-            throw new ProcessReadyTimeoutError(response("PROCESS_READY_TIMEOUT", `Process did not become ready within ${timeout}ms`, { ...context, timeout }, { httpStatus: 408, operation: "process.start" }));
+            throw this.#timedOut(condition, timeout);
         }
     }
-    async #waitForLog(pattern, signal) {
-        let output = "";
+    async waitForLog(pattern, timeout) {
+        const condition = typeof pattern === "string" ? `"${pattern}"` : pattern.toString();
+        return this.#within(condition, timeout, (signal) => this.#waitForLog(pattern, condition, signal));
+    }
+    async #waitForLog(pattern, condition, signal) {
+        let stdout = "", stderr = "";
         for await (const e of this.native.output({ signal })) {
-            if (e.type === "stdout" || e.type === "stderr") {
-                output += e.data;
-                const match = typeof pattern === "string" ? output.includes(pattern) : output.match(pattern);
-                if (match)
-                    return {
-                        line: output
-                            .split("\n")
-                            .find((line) => typeof pattern === "string"
-                            ? line.includes(pattern)
-                            : new RegExp(pattern.source, pattern.flags.replace("g", "")).test(line)) ?? output,
-                        ...(typeof pattern === "string" ? {} : { match }),
-                    };
-            }
-            else if (e.type === "exit")
-                throw new ProcessExitedBeforeReadyError(response("PROCESS_EXITED_BEFORE_READY", "Process exited before expected output", {
-                    processId: this.id,
-                    command: this.command,
-                    condition: `log pattern ${String(pattern)}`,
-                    exitCode: e.exitCode ?? -1,
-                }, { httpStatus: 409, operation: "process.start" }));
+            if (e.type === "stdout")
+                stdout += e.data;
+            else if (e.type === "stderr")
+                stderr += e.data;
+            const found = matchLine(stdout, pattern) ?? matchLine(stderr, pattern);
+            if (found)
+                return found;
+            if (e.type === "exit")
+                throw this.#exited(condition, e.exitCode ?? 1);
         }
-        throw new Error("Process output ended before expected output");
+        throw this.#exited(condition, 0);
+    }
+    /** Resolves once the port answers: an HTTP status in range (200-399 by
+     * default) at `path`, or a TCP connection in `tcp` mode. Throws if the
+     * process ends first, or after `timeout` milliseconds when one is given. */
+    async waitForPort(port, options = {}) {
+        only("Cloudflare waitForPort", options, ["mode", "path", "status", "timeout", "interval"]);
+        const { mode = "http", path = "/", status = { min: 200, max: 399 }, interval = 500 } = options;
+        if (!Number.isInteger(port) || port < 1 || port > 65535)
+            throw new TypeError(`Invalid port number: ${port}`);
+        if (mode !== "http" && mode !== "tcp")
+            throw new TypeError("mode is http or tcp");
+        const condition = mode === "http" ? `port ${port} (HTTP ${path})` : `port ${port} (TCP)`;
+        const min = typeof status === "number" ? status : status.min;
+        const max = typeof status === "number" ? status : status.max;
+        const url = `http://127.0.0.1:${port}${path.startsWith("/") ? path : `/${path}`}`;
+        const probe = mode === "http"
+            ? `code=$(curl -s -o /dev/null -w '%{http_code}' --max-time 2 ${quote(url)}) && [ "$code" -ge ${min} ] && [ "$code" -le ${max} ]`
+            : `exec 3<>/dev/tcp/127.0.0.1/${port}`;
+        const s = await this.sandbox.native();
+        await this.#within(condition, options.timeout, async (signal) => {
+            for (;;) {
+                await this.native.refresh();
+                if (this.native.info.state !== "running")
+                    throw this.#exited(condition, this.native.info.exitCode ?? 1);
+                if ((await s.exec(["bash", "-c", probe], { signal })).exitCode === 0)
+                    return;
+                await new Promise((done) => setTimeout(done, interval));
+                signal?.throwIfAborted();
+            }
+        });
     }
 }
+/** The first line holding a match, as Cloudflare's waitForLog answers. */
+function matchLine(text, pattern) {
+    if (typeof pattern === "string") {
+        if (!text.includes(pattern))
+            return null;
+        return { line: text.split("\n").find((line) => line.includes(pattern)) ?? pattern };
+    }
+    const safe = new RegExp(pattern.source, pattern.flags.replace("g", ""));
+    const match = text.match(safe);
+    if (!match)
+        return null;
+    for (const line of text.split("\n")) {
+        const lineMatch = line.match(safe);
+        if (lineMatch)
+            return { line, match: lineMatch };
+    }
+    return { line: match[0], match };
+}

package/dist/cloudflare/interpreter.js

@@ -106,11 +106,20 @@ export class CodeInterpreter {
         only("Cloudflare createCodeContext", options, ["language", "cwd", "envVars", "timeout"]);
         const language = this.#language(options.language);
         const s = await this.#native();
-        return context(await s.interpreter.contexts.create({
-            language,
-            cwd: options.cwd ?? "/workspace",
-            env: Object.fromEntries(Object.entries(options.envVars ?? {}).filter((e) => e[1] !== undefined)),
-        }, options.timeout !== undefined ? { timeoutMs: options.timeout } : {}));
+        try {
+            return context(await s.interpreter.contexts.create({
+                language,
+                cwd: options.cwd ?? "/workspace",
+                env: Object.fromEntries(Object.entries(options.envVars ?? {}).filter((e) => e[1] !== undefined)),
+            }, options.timeout !== undefined ? { timeoutMs: options.timeout } : {}));
+        }
+        catch (error) {
+            // Cloudflare's container has no fixed count; Runtime's does. Say so,
+            // and what frees one, in the message: only it survives Worker RPC.
+            if (error.code !== "context_limit")
+                throw error;
+            throw new Error(`${error.message} Cloudflare's container has no fixed limit; delete a context you no longer need with deleteCodeContext(), and list them with listCodeContexts(). runCode without a context uses one per language.`, { cause: error });
+        }
     }
     async runCode(code, options = {}) {
         if (hasEnv(options.envVars))

package/dist/cloudflare/mime.d.ts

@@ -0,0 +1 @@
+export declare function mimeType(path: string, bytes: Uint8Array): string;

package/dist/cloudflare/mime.js

@@ -0,0 +1,66 @@
+/** A file's MIME type as Cloudflare's container reports it: from the
+ * extension first, then from the content (`file --mime-type` there; the
+ * common signatures and text here), else application/octet-stream. */
+const BY_EXTENSION = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    ico: "image/x-icon",
+    bmp: "image/bmp",
+    avif: "image/avif",
+    pdf: "application/pdf",
+    zip: "application/zip",
+    gz: "application/gzip",
+    tgz: "application/gzip",
+    tar: "application/x-tar",
+    wasm: "application/wasm",
+    json: "application/json",
+    xml: "application/xml",
+    js: "text/javascript",
+    mjs: "text/javascript",
+    cjs: "text/javascript",
+    css: "text/css",
+    html: "text/html",
+    htm: "text/html",
+    md: "text/markdown",
+    txt: "text/plain",
+    csv: "text/csv",
+    yaml: "text/yaml",
+    yml: "text/yaml",
+    py: "text/x-python",
+    sh: "application/x-sh",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+};
+const SIGNATURES = [
+    [[0x89, 0x50, 0x4e, 0x47], "image/png"],
+    [[0xff, 0xd8, 0xff], "image/jpeg"],
+    [[0x47, 0x49, 0x46, 0x38], "image/gif"],
+    [[0x25, 0x50, 0x44, 0x46], "application/pdf"],
+    [[0x50, 0x4b, 0x03, 0x04], "application/zip"],
+    [[0x1f, 0x8b], "application/gzip"],
+    [[0x00, 0x61, 0x73, 0x6d], "application/wasm"],
+    [[0x7f, 0x45, 0x4c, 0x46], "application/x-executable"],
+];
+export function mimeType(path, bytes) {
+    const name = path.split("/").pop() ?? "";
+    const dot = name.lastIndexOf(".");
+    const known = dot > 0 ? BY_EXTENSION[name.slice(dot + 1).toLowerCase()] : undefined;
+    if (known)
+        return known;
+    for (const [signature, type] of SIGNATURES)
+        if (signature.every((byte, i) => bytes[i] === byte))
+            return type;
+    if (bytes.length === 0)
+        return "inode/x-empty";
+    const text = new TextDecoder().decode(bytes.subarray(0, 8192));
+    return text.includes("\0") || text.includes("�") ? "application/octet-stream" : "text/plain";
+}

package/dist/cloudflare/streams.d.ts

@@ -25,6 +25,14 @@ export declare function sseStream<T>(events: (send: (event: T) => void, signal:
 /** The events of a server-sent-events stream, each `data:` parsed as JSON;
  * `[DONE]`, blank and unparsable data are skipped, as Cloudflare's do. */
 export declare function parseSSEStream<T>(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncIterable<T>;
+/** The events of a server-sent-events Response, as parseSSEStream reads them. */
+export declare function responseToAsyncIterable<T>(response: Response, signal?: AbortSignal): AsyncIterable<T>;
+/** Events as a server-sent-events stream, one `data:` line each, then
+ * `data: [DONE]`, as Cloudflare's helper writes them. */
+export declare function asyncIterableToSSEStream<T>(events: AsyncIterable<T>, options?: {
+    signal?: AbortSignal;
+    serialize?: (event: T) => string;
+}): ReadableStream<Uint8Array>;
 /** A `readFileStream()` stream's chunks: strings for text, bytes for binary.
  * Returns the file's metadata. */
 export declare function streamFile(stream: ReadableStream<Uint8Array>): AsyncGenerator<FileChunk, FileMetadata>;

package/dist/cloudflare/streams.js

@@ -77,6 +77,36 @@ export async function* parseSSEStream(stream, signal) {
         reader.releaseLock();
     }
 }
+/** The events of a server-sent-events Response, as parseSSEStream reads them. */
+export async function* responseToAsyncIterable(response, signal) {
+    if (!response.ok)
+        throw new Error(`Response not ok: ${response.status} ${response.statusText}`);
+    if (!response.body)
+        throw new Error("No response body");
+    yield* parseSSEStream(response.body, signal);
+}
+/** Events as a server-sent-events stream, one `data:` line each, then
+ * `data: [DONE]`, as Cloudflare's helper writes them. */
+export function asyncIterableToSSEStream(events, options = {}) {
+    const encoder = new TextEncoder();
+    const serialize = options.serialize ?? ((event) => JSON.stringify(event));
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const event of events) {
+                    if (options.signal?.aborted)
+                        throw new Error("Operation was aborted");
+                    controller.enqueue(encoder.encode(`data: ${serialize(event)}\n\n`));
+                }
+                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+                controller.close();
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    });
+}
 /** A `readFileStream()` stream's chunks: strings for text, bytes for binary.
  * Returns the file's metadata. */
 export async function* streamFile(stream) {