withruntime 0.9.0 → 0.10.0

package/dist/blaxel/pagination.js

@@ -8,30 +8,58 @@ export function unwrapListData(response) {
     return response.data ?? [];
 }
 /** Blaxel's own helper, for a list fetched by `fetchPage`. */
-export async function createPaginatedList({ response, fetchPage, mapItem, query, }) {
-    const meta = !response || Array.isArray(response) ? {} : (response.meta ?? {});
+export async function createPaginatedList({ response, fetchPage, mapItem, query, seenCursors, }) {
+    const meta = !response || Array.isArray(response)
+        ? { hasMore: false }
+        : (response.meta ?? { hasMore: false });
     const data = await Promise.all(unwrapListData(response).map(mapItem));
-    return build(data, meta.nextCursor || undefined, async (cursor) => createPaginatedList({
-        response: await fetchPage({ ...(query ?? {}), cursor }),
-        fetchPage,
-        mapItem,
-        ...(query ? { query: { ...query, cursor } } : {}),
-    }));
+    const cursors = new Set(seenCursors);
+    if (query?.cursor)
+        cursors.add(query.cursor);
+    return build(data, meta.nextCursor || undefined, async (cursor) => {
+        if (cursors.has(cursor))
+            throw new Error("Pagination returned a repeated cursor");
+        const nextQuery = { ...(query ?? {}), cursor };
+        const nextSeenCursors = new Set(cursors);
+        nextSeenCursors.add(cursor);
+        return createPaginatedList({
+            response: await fetchPage(nextQuery),
+            fetchPage,
+            mapItem,
+            query: nextQuery,
+            seenCursors: nextSeenCursors,
+        });
+    }, meta);
 }
 /** A Runtime page, each item mapped, as Blaxel's paginated list. */
-export function paginate(page, map) {
-    return build(page.data.map(map), page.nextCursor ?? undefined, async () => {
-        const next = await guard(() => page.next());
-        return next ? paginate(next, map) : null;
+export function paginate(page, map, seenCursors = new Set()) {
+    return build(page.data.map(map), page.nextCursor ?? undefined, async (cursor) => {
+        if (cursor && seenCursors.has(cursor))
+            throw new Error("Pagination returned a repeated cursor");
+        const nextSeenCursors = new Set(seenCursors);
+        if (cursor)
+            nextSeenCursors.add(cursor);
+        const next = await guard(() => page.next(cursor));
+        return next ? paginate(next, map, nextSeenCursors) : null;
     });
 }
-function build(data, nextCursor, more) {
+function build(data, nextCursor, more, meta = {
+    hasMore: nextCursor !== undefined,
+    ...(nextCursor ? { nextCursor } : {}),
+}) {
     const list = {
         data,
-        meta: { hasMore: nextCursor !== undefined, ...(nextCursor ? { nextCursor } : {}) },
-        hasMore: nextCursor !== undefined,
-        ...(nextCursor ? { nextCursor } : {}),
-        nextPage: async () => (nextCursor ? more(nextCursor) : null),
+        meta,
+        get hasMore() {
+            return Boolean(list.nextCursor);
+        },
+        get nextCursor() {
+            return meta.nextCursor || undefined;
+        },
+        nextPage: async () => {
+            const cursor = list.nextCursor;
+            return cursor ? more(cursor) : null;
+        },
         async autoPagingEach(onItem) {
             for await (const item of list)
                 if ((await onItem(item)) === false)

package/dist/blaxel/preview.d.ts

@@ -67,7 +67,8 @@ export declare class SandboxPreviewTokens {
     constructor(preview: SandboxPreview, ctx: PreviewContext);
     get previewName(): string;
     get resourceName(): string;
-    /** A token that lasts until `expiresAt` (at least a minute, at most a week). */
+    /** A token bounded by `expiresAt`; native signing floors milliseconds and
+     * caps it to the caller's session. Older servers refuse without a TTL fallback. */
     create(expiresAt: Date): Promise<SandboxPreviewToken>;
     list(): Promise<never>;
     /** Revokes the preview's tokens. Runtime cannot revoke one token alone, so

package/dist/blaxel/preview.js

@@ -1,8 +1,5 @@
 import { guard, isNotFound, NotSupportedError, responseError } from "./errors.js";
 import { PREVIEW } from "./lookup.js";
-/** Runtime's shortest and longest token, in seconds. */
-const TOKEN_MIN = 60;
-const TOKEN_MAX = 7 * 86_400;
 function checkName(name) {
     if (!/^[A-Za-z0-9._-]{1,48}$/.test(name))
         throw new NotSupportedError(`The preview name "${name}"`, "Use 1 to 48 letters, digits, dots, dashes or underscores.");
@@ -56,19 +53,24 @@ export class SandboxPreviewTokens {
     get resourceName() {
         return this.#ctx.sandboxName;
     }
-    /** A token that lasts until `expiresAt` (at least a minute, at most a week). */
+    /** A token bounded by `expiresAt`; native signing floors milliseconds and
+     * caps it to the caller's session. Older servers refuse without a TTL fallback. */
     async create(expiresAt) {
-        const seconds = Math.ceil((expiresAt.getTime() - Date.now()) / 1000);
-        if (seconds > TOKEN_MAX)
-            throw new NotSupportedError("A preview token lasting more than a week", "Create one for at most seven days, and a new one when it runs out.");
-        const port = this.#preview.spec.port;
-        const got = await this.#ctx.run((runtime) => runtime.previews.get(port, Math.max(TOKEN_MIN, seconds)));
+        const requested = expiresAt.getTime();
+        if (!Number.isFinite(requested))
+            throw responseError(400, "A preview token needs a valid expiration date.");
+        const remaining = requested - Date.now();
+        if (remaining < 60_000 || remaining > 7 * 86_400_000)
+            throw new NotSupportedError("A preview token lasting less than a minute or more than a week", "Request an expiration at least one minute and at most seven days away.");
+        const got = await this.#ctx.run((runtime) => runtime.previews.get(this.#preview.spec.port, undefined, {
+            expiresAt: expiresAt.toISOString(),
+        }));
+        const actual = got.tokenExpiresAt === null ? Number.NaN : Date.parse(got.tokenExpiresAt);
+        if (!got.token || !Number.isFinite(actual) || actual > requested)
+            throw new NotSupportedError("A preview token with the requested expiration", "The server must issue a token that never outlives the requested expiration; no duration-based fallback was requested.");
         return new SandboxPreviewToken({
             metadata: { name: `token-${Date.now()}`, previewName: this.previewName },
-            spec: {
-                ...(got.token ? { token: got.token } : {}),
-                ...(got.tokenExpiresAt ? { expiresAt: got.tokenExpiresAt } : {}),
-            },
+            spec: { token: got.token, expiresAt: got.tokenExpiresAt },
         });
     }
     list() {

package/dist/blaxel/process.js

@@ -152,14 +152,17 @@ export class SandboxProcess {
     }
     /** A call that found the sandbox paused (autoWake off) is made again once,
      * after a wake: it never started, so it cannot run twice. */
-    async #retryPaused(work) {
+    async #retryPaused(work, signal) {
+        signal?.throwIfAborted();
         try {
             return await work();
         }
         catch (error) {
+            signal?.throwIfAborted();
             if (codeOf(error) !== "sandbox_paused")
                 throw translate(error);
             await this.#ctx.wake();
+            signal?.throwIfAborted();
             return guard(work);
         }
     }
@@ -281,16 +284,20 @@ export class SandboxProcess {
         };
     }
     /** A process by pid or name: the registry first, then Runtime's list. */
-    async #find(identifier) {
+    async #find(identifier, signal) {
+        signal?.throwIfAborted();
         const runtime = await this.#ctx.live();
+        signal?.throwIfAborted();
         const registry = this.#registry;
         const known = registry.byName.get(identifier) ?? (registry.meta.has(identifier) ? identifier : undefined);
         if (known !== undefined) {
-            const process = await this.#retryPaused(() => runtime.processes.get(known));
+            const process = await this.#retryPaused(() => runtime.processes.get(known, { signal }), signal);
+            signal?.throwIfAborted();
             registry.processes.set(known, process);
             return { id: known, info: process.info, process };
         }
-        const all = await this.#retryPaused(() => runtime.processes.list());
+        const all = await this.#retryPaused(() => runtime.processes.list({ signal }), signal);
+        signal?.throwIfAborted();
         let found;
         for (const info of all) {
             const parsed = parseProcessLine(info.command);
@@ -323,7 +330,9 @@ export class SandboxProcess {
         const running = found.info.state === "running";
         if (running && !untilExit && found.info.outputBytes <= found.info.firstOffset)
             return out;
+        signal?.throwIfAborted();
         const runtime = await this.#ctx.live();
+        signal?.throwIfAborted();
         const abort = new AbortController();
         const forward = () => abort.abort();
         signal?.throwIfAborted();
@@ -369,9 +378,30 @@ export class SandboxProcess {
     /** The process, with the output it has written so far. */
     async get(identifier, options = {}) {
         options.signal?.throwIfAborted();
-        const found = await this.#find(identifier);
-        const out = await this.#output(found, false, options.signal);
-        return this.#settled(this.#response(found.info, this.#registry.meta.get(found.id), out));
+        const signal = options.signal;
+        let onAbort;
+        const interrupted = new Promise((_, reject) => {
+            onAbort = () => reject(new Error("Process read was interrupted.", { cause: signal?.reason }));
+            signal?.addEventListener("abort", onAbort, { once: true });
+        });
+        try {
+            const reading = (async () => {
+                const found = await this.#find(identifier, signal);
+                const out = await this.#output(found, false, signal);
+                signal?.throwIfAborted();
+                return this.#settled(this.#response(found.info, this.#registry.meta.get(found.id), out));
+            })();
+            return await Promise.race([reading, interrupted]);
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw signal.reason ?? error;
+            throw error;
+        }
+        finally {
+            if (onAbort)
+                signal?.removeEventListener("abort", onAbort);
+        }
     }
     /** Waits for the process to end (at most `maxWait` ms, -1 for no limit) and
      * answers it with its output. The process is never stopped by the wait. */
@@ -390,10 +420,24 @@ export class SandboxProcess {
         signal?.throwIfAborted();
         signal?.addEventListener("abort", forward, { once: true });
         const timer = maxWait === -1 ? undefined : setTimeout(() => abort.abort(late()), maxWait);
+        let onAbort;
+        const interrupted = new Promise((_, reject) => {
+            onAbort = () => {
+                const reason = abort.signal.reason;
+                reject(reason instanceof Error
+                    ? reason
+                    : new Error("Process wait was interrupted.", { cause: reason }));
+            };
+            abort.signal.addEventListener("abort", onAbort, { once: true });
+        });
         try {
-            const found = await this.#find(identifier);
-            const out = await this.#output(found, true, abort.signal);
-            return await this.#settled(this.#response(found.info, this.#registry.meta.get(found.id), out));
+            const result = (async () => {
+                const found = await this.#find(identifier, abort.signal);
+                const out = await this.#output(found, true, abort.signal);
+                abort.signal.throwIfAborted();
+                return await this.#settled(this.#response(found.info, this.#registry.meta.get(found.id), out));
+            })();
+            return await Promise.race([result, interrupted]);
         }
         catch (error) {
             if (abort.signal.aborted)
@@ -402,6 +446,8 @@ export class SandboxProcess {
         }
         finally {
             clearTimeout(timer);
+            if (onAbort)
+                abort.signal.removeEventListener("abort", onAbort);
             signal?.removeEventListener("abort", forward);
         }
     }

package/dist/blaxel/sandbox.d.ts

@@ -32,6 +32,8 @@ export type SandboxForkOptions = {
     /** A snapshot's id or, of this sandbox's snapshots, its name. */
     snapshotId?: string;
     envs?: Env[];
+    /** Blaxel's fork override; Runtime cannot enforce this override during a fork. */
+    lifecycle?: SandboxLifecycle;
 };
 export type SandboxArchiveOptions = {
     wait?: boolean;

package/dist/blaxel/sandbox.js

@@ -750,6 +750,8 @@ export class SandboxInstance {
      * (files, memory and running processes), or started from a snapshot with
      * `snapshotId`. `envs` are added over this sandbox's. */
     async fork(targetName, options = {}) {
+        if (options.lifecycle !== undefined)
+            throw new NotSupportedError("Overriding lifecycle during a fork", "Omit lifecycle to use the existing Runtime fork behavior.");
         refuseApplication(options);
         const envs = envRecord(options.envs);
         checkEnvNames(Object.keys(envs));

package/dist/blaxel/snapshot.js

@@ -22,13 +22,11 @@ export function snapshotModel(snapshot, sandboxName) {
 }
 /** Envs as a record; a nameless one is refused. */
 export function envRecord(envs) {
-    const out = {};
-    for (const env of envs ?? []) {
+    return Object.fromEntries((envs ?? []).map((env) => {
         if (!env.name)
             throw responseError(400, "every env needs a name");
-        out[env.name] = env.value ?? "";
-    }
-    return out;
+        return [env.name, env.value ?? ""];
+    }));
 }
 /** Appends envs to a sandbox's env file: they win over the ones it has. */
 export async function appendEnvs(runtime, envs) {

package/dist/cli.d.ts

@@ -7,6 +7,8 @@ type Out = {
     json: boolean;
     write: (text: string) => void;
     error: (text: string) => void;
+    /** Wait when an output pipe cannot accept another page yet. */
+    drain?: () => Promise<void>;
 };
 type Args = {
     positional: string[];