1tube 0.1.34 → 0.1.36

package/README.md

@@ -120,7 +120,12 @@ Deferred boot (default whenever `--dev` or `--hmr` is on) flips the order:
    the gateway starts serving right away. Time-to-first-request drops from
    "sum of all worker spawns" to effectively zero.
 2. Workers spawn in the background with the usual bounded concurrency
-   (`--deno-worker-concurrency`, default 8).
+   (`--deno-worker-concurrency`, default 8), **most-recently-used first**:
+   the queue is ordered by each function's last invocation time from the
+   invocation log store, so the functions you were actually hitting before
+   the restart are warm within the first few seconds and the long tail of
+   rarely-called functions loads last. First run (empty store) falls back
+   to name order.
 3. A request for a function whose Worker isn't ready yet **bumps it to the
    front of the queue** and spawns it immediately, out-of-band. If it becomes
    ready within the grace window (`--warmup-grace-ms`, default 250 ms) the
@@ -190,6 +195,15 @@ little as possible:
   `X-1tube-Stale: 1` (CORS-exposed) so tooling can tell the difference.
 - **Targeted re-discovery.** Reloading one function stats only that function's
   dir instead of re-scanning the whole functions root.
+- **Local-only dep graphs.** The module graph that maps file changes to
+  affected functions stops at the local-file boundary: `npm:`/`jsr:`/`https:`
+  subtrees are marked external instead of being fetched and parsed. Only
+  `file://` modules can fire watcher events, so nothing is lost — and graph
+  builds for npm-heavy functions drop from seconds to milliseconds.
+- **One batch graph per deferred boot.** With shared modules active, deferred
+  boot builds a single module graph for all functions in the background
+  instead of letting every spawn crawl its own (which re-parsed the same
+  `_shared` files once per function).
 
 Notes:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "1tube",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "private": false,
   "description": "Self-hosted Supabase Edge Functions gateway for Deno, plus an ESLint plugin for consumers",
   "license": "MIT",

package/src/backends/deno/dep-graph.ts

@@ -164,6 +164,38 @@ function resolveAgainst(target: string, base: string): string {
   return new URL(target, baseUrl).href;
 }
 
+/**
+ * Local-only module loader for `createGraph`.
+ *
+ * The graph exists solely to map fs-watcher events to affected
+ * functions, and only `file://` modules can ever fire those events.
+ * deno_graph's DEFAULT loader, however, follows every specifier —
+ * reading npm/jsr packages and even `fetch()`ing `https:` imports —
+ * which made big functions pay multi-second graph builds for data we
+ * throw away. Marking every non-`file:` specifier as external stops
+ * the crawl at the local-file boundary: remote subtrees are never
+ * read, parsed, or fetched.
+ */
+async function loadLocalOnly(
+  specifier: string,
+): Promise<
+  | { kind: "module"; specifier: string; content: Uint8Array }
+  | { kind: "external"; specifier: string }
+  | undefined
+> {
+  if (!specifier.startsWith("file://")) {
+    return { kind: "external", specifier };
+  }
+  try {
+    const content = await Deno.readFile(fileURLToPath(specifier));
+    return { kind: "module", specifier, content };
+  } catch {
+    // Missing file mid-edit: report "not found" and let deno_graph
+    // record a load error for this module instead of throwing.
+    return undefined;
+  }
+}
+
 export function createDepGraph(options?: DepGraphOptions): DepGraph {
   const perName = new Map<string, Set<string>>();
   const reverse = new Map<string, Set<string>>();
@@ -247,7 +279,10 @@ export function createDepGraph(options?: DepGraphOptions): DepGraph {
       const entry = normalize(entryFileUrl);
       let graph;
       try {
-        graph = await createGraph([entry], resolve ? { resolve } : undefined);
+        graph = await createGraph([entry], {
+          load: loadLocalOnly,
+          ...(resolve ? { resolve } : {}),
+        });
       } catch {
         // A save mid-flush can leave a syntactically broken file on
         // disk; deno_graph throws. Drop the graph for `name` so the
@@ -281,7 +316,10 @@ export function createDepGraph(options?: DepGraphOptions): DepGraph {
       try {
         graph = await createGraph(
           normalized.map((e) => e.entry),
-          resolve ? { resolve } : undefined,
+          {
+            load: loadLocalOnly,
+            ...(resolve ? { resolve } : {}),
+          },
         );
       } catch {
         for (const e of normalized) replaceGraph(e.name, minimalGraph(e.entry));

package/src/backends/deno/worker-host.ts

@@ -93,6 +93,14 @@ export interface DenoWorkerHostOptions {
   captureConsole?: boolean;
   /** Sink for captured console lines + worker runtime errors. */
   onConsole?: (event: WorkerConsoleEvent) => void;
+  /**
+   * Last-dispatch timestamp per function from a PREVIOUS run (e.g. the
+   * invocation log store). Seeds the MRU ordering used by deferred
+   * boot and HMR respawns, so the functions the developer was hitting
+   * before a gateway restart warm up first instead of alphabetically.
+   * Fresh in-process dispatches overwrite the seed as traffic arrives.
+   */
+  initialRecency?: ReadonlyMap<string, number>;
 }
 
 export interface ReloadSummary {
@@ -595,7 +603,7 @@ export function createDenoWorkerHost(
   /** Spawns started out-of-band by prioritize(), above the lane bound. */
   const outOfBandSpawns = new Set<Promise<void>>();
   /** Last gateway dispatch per function — drives MRU reload ordering. */
-  const lastDispatch = new Map<string, number>();
+  const lastDispatch = new Map<string, number>(opts.initialRecency ?? []);
   /**
    * Per-name spawn serialization. Deferred boot and HMR reload can both
    * want to spawn the same function concurrently (e.g. an edit lands
@@ -955,6 +963,13 @@ export function createDenoWorkerHost(
     loaded: string[];
     errors: Array<{ name: string; error: string }>;
     nextIndex: number;
+    /**
+     * Resolves when the boot-wide batch dep-graph (shared-rewrite mode
+     * only) has landed. Spawns wait on it instead of each paying a
+     * full per-function graph crawl — one batch graph parses every
+     * `_shared` file once instead of once per function.
+     */
+    batchGraphReady: Promise<void> | null;
   }
   let deferredCtx: DeferredCtx | null = null;
 
@@ -967,7 +982,11 @@ export function createDenoWorkerHost(
     const index = ++ctx.nextIndex;
     ctx.startOpts.onSpawnStart?.({ index, total: ctx.total, name: cand.name });
     const t0 = performance.now();
-    const r = await runSerialized(cand.name, () => spawnAndRegister(cand));
+    if (ctx.batchGraphReady) await ctx.batchGraphReady;
+    const r = await runSerialized(
+      cand.name,
+      () => spawnAndRegister(cand, { graphReady: ctx.batchGraphReady !== null }),
+    );
     const durationMs = performance.now() - t0;
     if ("error" in r) {
       ctx.errors.push({ name: cand.name, error: r.error });
@@ -1003,12 +1022,44 @@ export function createDenoWorkerHost(
     startOpts: StartOptions = {},
   ): Promise<DeferredStart> {
     const candidates = await discoverCandidates(opts.functionsDir);
+    // MRU-first warm-up: the background queue boots the functions the
+    // developer was hitting most recently (seeded from the invocation
+    // log store across restarts) before the ones nobody calls. Ties —
+    // including everything on a first run — keep name order.
+    candidates.sort((a, b) =>
+      (lastDispatch.get(b.name) ?? 0) - (lastDispatch.get(a.name) ?? 0) ||
+      a.name.localeCompare(b.name)
+    );
+    // Shared-rewrite mode needs each function's file list BEFORE its
+    // worker spawns. Build ONE batch graph in the background (the
+    // gateway still starts serving immediately) rather than letting
+    // every spawn crawl its own graph — the per-function crawls
+    // re-parse the same shared files over and over.
+    const useSharedRewrite = Boolean(
+      rewriteCache && sharedRuntime && sharedRuntime.list().length > 0,
+    );
+    let batchGraphReady: Promise<void> | null = null;
+    if (useSharedRewrite && candidates.length > 0) {
+      const graphStart = performance.now();
+      batchGraphReady = depGraph
+        .refreshMany(
+          candidates.map((c) => ({ name: c.name, entryFileUrl: c.entryUrl })),
+        )
+        .then(() => {
+          startOpts.onBatchGraph?.({
+            total: candidates.length,
+            durationMs: performance.now() - graphStart,
+          });
+        })
+        .catch(() => {});
+    }
     const ctx: DeferredCtx = {
       total: candidates.length,
       startOpts,
       loaded: [],
       errors: [],
       nextIndex: 0,
+      batchGraphReady,
     };
     deferredCtx = ctx;
     const items: ClaimItem[] = [];

package/src/backends/vercel/wrapper.ts

@@ -0,0 +1,307 @@
+/**
+ * Vercel (Node / Fluid) bundle wrapper.
+ *
+ * Unlike the workerd wrapper (which installs a `__edgeFunctionRegistry` and
+ * exports a workerd `default { fetch(request, env, ctx) }`), the Vercel target
+ * runs each function as a standalone Vercel Node Function. The goals:
+ *
+ *  1. **Stay on the shared handler's standalone path.** The host project's
+ *     `_shared/handler.ts` checks for `globalThis.__edgeFunctionRegistry`. We
+ *     deliberately do NOT install it, so `serve()` falls through to
+ *     `getStandaloneServe()` -> `globalThis.Deno.serve(...)`. The banner
+ *     installs a `Deno.serve` shim that simply captures the fetch handler.
+ *     This keeps auth (JWT verification, service-role), CORS preflight,
+ *     claims checks, Supabase context construction, and route dispatch exactly
+ *     where they already live — no per-function changes required.
+ *
+ *  2. **`Deno.env` -> `process.env`.** User code reads env via `Deno.env.get`.
+ *     On Vercel Node there is no `Deno`, so the banner installs a `Deno.env`
+ *     shim backed by `process.env`.
+ *
+ *  3. **`EdgeRuntime.waitUntil`.** Supabase Edge Runtime exposes
+ *     `EdgeRuntime.waitUntil()` for background work after the response is sent.
+ *     On Vercel the equivalent is provided through the `@vercel/request-context`
+ *     global (which is precisely what `@vercel/functions`' `waitUntil()` reads).
+ *     The banner shims `globalThis.EdgeRuntime.waitUntil` onto it, and falls
+ *     back to locally draining pending promises before the handler resolves
+ *     when no platform context is present (e.g. local execution / tests).
+ *
+ *  4. **Node request/response bridge.** The footer exports a Vercel Node
+ *     handler `(req, res)` that converts the Node request into a Web `Request`
+ *     (preserving the raw body stream for uploads), invokes the captured fetch
+ *     handler, and streams the Web `Response` back to the Node `res` (so SSE /
+ *     NDJSON / AI token streaming keep flowing incrementally).
+ *
+ * The banner intentionally avoids the workerd console-capture marker: on Vercel
+ * `console.*` is already routed to the function's logs.
+ */
+
+/**
+ * Node builtin module names. Imports of these (bare or `node:`-prefixed) are
+ * marked external for the Vercel target so the real Node runtime provides them
+ * instead of bundling Deno's polyfills. Subpath imports (e.g. `stream/web`,
+ * `fs/promises`) are matched by their head segment.
+ */
+export const NODE_BUILTIN_MODULES: readonly string[] = [
+  "assert",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "diagnostics_channel",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "sys",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "wasi",
+  "worker_threads",
+  "zlib",
+];
+
+/**
+ * Banner injected at the top of every Vercel bundle. Runs before the user
+ * entrypoint import so top-level `Deno.env.get(...)` / `serve(...)` calls find
+ * the shims installed. The captured handler lives in module scope; the footer
+ * exports the Vercel Node handler that dispatches to it.
+ */
+export const VERCEL_BANNER = `// AUTO-GENERATED by 1tube vercel bundler — do not edit
+import { Readable as __1tubeReadable } from "node:stream";
+
+let __1tubeCapturedHandler;
+let __1tubeCapturedOpts = { public: false };
+const __1tubePending = [];
+
+// --- Deno.env / Deno.serve shim ------------------------------------------
+const __1tubeProcessEnv = () => (globalThis.process && globalThis.process.env) || {};
+const __1tubeDenoEnv = {
+  get(key) {
+    const v = __1tubeProcessEnv()[key];
+    return typeof v === "string" ? v : undefined;
+  },
+  set(key, value) {
+    __1tubeProcessEnv()[key] = String(value);
+  },
+  delete(key) {
+    delete __1tubeProcessEnv()[key];
+  },
+  has(key) {
+    return typeof __1tubeProcessEnv()[key] === "string";
+  },
+  toObject() {
+    const out = {};
+    const env = __1tubeProcessEnv();
+    for (const k of Object.keys(env)) {
+      if (typeof env[k] === "string") out[k] = env[k];
+    }
+    return out;
+  },
+};
+
+// Captures the fetch handler passed to Deno.serve(). Deno.serve supports
+// serve(handler), serve(options, handler) and serve({ handler }); we accept
+// all three shapes. Returns a Deno.HttpServer-like object so callers that
+// inspect the return value don't crash.
+function __1tubeCaptureServe(arg1, arg2) {
+  const handler = typeof arg1 === "function"
+    ? arg1
+    : (typeof arg2 === "function"
+      ? arg2
+      : (arg1 && typeof arg1.handler === "function" ? arg1.handler : undefined));
+  if (typeof handler === "function") __1tubeCapturedHandler = handler;
+  return {
+    finished: Promise.resolve(),
+    shutdown() { return Promise.resolve(); },
+    ref() {},
+    unref() {},
+    addr: { transport: "tcp", hostname: "0.0.0.0", port: 0 },
+  };
+}
+
+if (typeof globalThis.Deno === "undefined") {
+  // Pure Node (Vercel): install the full shim.
+  Object.defineProperty(globalThis, "Deno", {
+    value: { env: __1tubeDenoEnv, serve: __1tubeCaptureServe },
+    writable: true,
+    configurable: true,
+    enumerable: false,
+  });
+} else {
+  // Host Deno (1tube's own tests): override only serve so the handler is
+  // captured instead of binding a real port; leave the rest of Deno intact.
+  try {
+    globalThis.Deno.serve = __1tubeCaptureServe;
+  } catch (_e) { /* serve not writable — capture unavailable in this realm */ }
+}
+
+// --- EdgeRuntime.waitUntil shim ------------------------------------------
+function __1tubeRequestContext() {
+  try {
+    const rc = globalThis[Symbol.for("@vercel/request-context")];
+    return rc && typeof rc.get === "function" ? rc.get() : undefined;
+  } catch (_e) {
+    return undefined;
+  }
+}
+function __1tubeHasPlatformWaitUntil() {
+  const ctx = __1tubeRequestContext();
+  return !!(ctx && typeof ctx.waitUntil === "function");
+}
+function __1tubePlatformWaitUntil(promise) {
+  const ctx = __1tubeRequestContext();
+  if (ctx && typeof ctx.waitUntil === "function") {
+    try {
+      ctx.waitUntil(promise);
+      return true;
+    } catch (_e) { /* fall through to local draining */ }
+  }
+  return false;
+}
+if (!globalThis.EdgeRuntime || typeof globalThis.EdgeRuntime.waitUntil !== "function") {
+  const edgeRuntime = (globalThis.EdgeRuntime && typeof globalThis.EdgeRuntime === "object")
+    ? globalThis.EdgeRuntime
+    : {};
+  edgeRuntime.waitUntil = (promise) => {
+    const p = Promise.resolve(promise);
+    __1tubePending.push(p.catch(() => {}));
+    __1tubePlatformWaitUntil(p);
+    return p;
+  };
+  try {
+    globalThis.EdgeRuntime = edgeRuntime;
+  } catch (_e) { /* read-only EdgeRuntime — waitUntil shim unavailable */ }
+}
+`;
+
+/**
+ * Footer injected at the bottom of every Vercel bundle. Exports the Vercel
+ * Node handler. By the time Vercel invokes it the entrypoint import has run, so
+ * `__1tubeCapturedHandler` is populated.
+ */
+export const VERCEL_FOOTER = `
+function __1tubeHeadersFromNode(req) {
+  const headers = new Headers();
+  const raw = req.headers || {};
+  for (const key of Object.keys(raw)) {
+    const value = raw[key];
+    if (Array.isArray(value)) {
+      for (const v of value) headers.append(key, String(v));
+    } else if (value !== undefined && value !== null) {
+      headers.set(key, String(value));
+    }
+  }
+  return headers;
+}
+
+function __1tubeToWebRequest(req) {
+  const headers = __1tubeHeadersFromNode(req);
+  const xfproto = headers.get("x-forwarded-proto");
+  const proto = (xfproto ? xfproto.split(",")[0] : "https").trim() || "https";
+  const host = headers.get("x-forwarded-host") || headers.get("host") || "localhost";
+  const path = req.url || "/";
+  const url = /^https?:\\/\\//.test(path) ? path : (proto + "://" + host + path);
+  const method = (req.method || "GET").toUpperCase();
+  const init = { method, headers };
+  if (method !== "GET" && method !== "HEAD") {
+    // Stream the raw request body through untouched — multipart uploads and
+    // proxied request streams must not be buffered/parsed here.
+    init.body = __1tubeReadable.toWeb(req);
+    init.duplex = "half";
+  }
+  return new Request(url, init);
+}
+
+async function __1tubeWriteWebResponse(res, response) {
+  res.statusCode = response.status;
+  const setCookie = typeof response.headers.getSetCookie === "function"
+    ? response.headers.getSetCookie()
+    : [];
+  response.headers.forEach((value, key) => {
+    if (key.toLowerCase() === "set-cookie") return;
+    try { res.setHeader(key, value); } catch (_e) { /* ignore invalid header */ }
+  });
+  if (setCookie.length > 0) {
+    try { res.setHeader("set-cookie", setCookie); } catch (_e) { /* ignore */ }
+  }
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  const reader = response.body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value && value.length > 0) {
+        const ok = res.write(value);
+        if (ok === false) {
+          await new Promise((resolve) => res.once("drain", resolve));
+        }
+      }
+    }
+  } finally {
+    res.end();
+  }
+}
+
+export default async function handler(req, res) {
+  try {
+    if (typeof __1tubeCapturedHandler !== "function") {
+      res.statusCode = 500;
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({ error: "function did not register a handler" }));
+      return;
+    }
+    const request = __1tubeToWebRequest(req);
+    const response = await __1tubeCapturedHandler(request);
+    await __1tubeWriteWebResponse(res, response);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    try {
+      console.error(err instanceof Error ? (err.stack || message) : message);
+    } catch (_e) { /* logging must never throw */ }
+    if (!res.headersSent) {
+      res.statusCode = 500;
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({ error: message }));
+    } else {
+      try { res.end(); } catch (_e) { /* already ended */ }
+    }
+  } finally {
+    // When no platform waitUntil is available (local execution / tests), drain
+    // background work before resolving so it isn't dropped.
+    if (!__1tubeHasPlatformWaitUntil() && __1tubePending.length > 0) {
+      const pending = __1tubePending.splice(0, __1tubePending.length);
+      await Promise.allSettled(pending);
+    }
+  }
+}
+`;

package/src/backends/workerd/bundler.ts

@@ -44,6 +44,20 @@ import {
   SHARED_RUNTIME_URL_ENV,
   type SharedRuntimeModule,
 } from "./shared-runtime.ts";
+import {
+  NODE_BUILTIN_MODULES,
+  VERCEL_BANNER,
+  VERCEL_FOOTER,
+} from "../vercel/wrapper.ts";
+
+/**
+ * Which runtime the chunked bundler emits for. `workerd` (default) wraps each
+ * function as a workerd `default { fetch }` registered through
+ * `__edgeFunctionRegistry`; `vercel` wraps it as a Vercel Node handler that
+ * captures `Deno.serve` and bridges Node req/res to Web fetch. See
+ * `../vercel/wrapper.ts` for the Vercel banner/footer.
+ */
+export type BundleTarget = "workerd" | "vercel";
 
 /**
  * Banner injected at the top of every bundle. Runs before any user code so
@@ -485,14 +499,19 @@ function toPosix(path: string): string {
   return path.replace(/\\/g, "/");
 }
 
-function entryProxySource(entrypoint: string): string {
-  return `${BANNER}
+function entryProxySource(entrypoint: string, target: BundleTarget): string {
+  const banner = target === "vercel" ? VERCEL_BANNER : BANNER;
+  const footer = target === "vercel" ? VERCEL_FOOTER : FOOTER;
+  return `${banner}
 await import(${JSON.stringify(pathToFileURL(entrypoint).href)});
-${FOOTER}
+${footer}
 `;
 }
 
-function entryProxyPlugin(inputs: readonly BundleInput[]): esbuild.Plugin {
+function entryProxyPlugin(
+  inputs: readonly BundleInput[],
+  target: BundleTarget,
+): esbuild.Plugin {
   const byName = new Map(inputs.map((input) => [input.name, input]));
   return {
     name: "1tube-entry-proxy",
@@ -513,7 +532,7 @@ function entryProxyPlugin(inputs: readonly BundleInput[]): esbuild.Plugin {
             );
           }
           return {
-            contents: entryProxySource(input.entrypoint),
+            contents: entryProxySource(input.entrypoint, target),
             loader: "js",
             resolveDir: dirname(input.entrypoint),
           };
@@ -523,6 +542,40 @@ function entryProxyPlugin(inputs: readonly BundleInput[]): esbuild.Plugin {
   };
 }
 
+const NODE_BUILTIN_SET = new Set<string>(NODE_BUILTIN_MODULES);
+
+function isNodeBuiltinBare(spec: string): boolean {
+  const slash = spec.indexOf("/");
+  const head = slash === -1 ? spec : spec.slice(0, slash);
+  return NODE_BUILTIN_SET.has(head);
+}
+
+/**
+ * For the Vercel (Node) target, leave Node builtins to the host runtime
+ * instead of bundling Deno's polyfills for them. `node:`-prefixed specifiers
+ * are always external; bare builtins (`crypto`, `stream`, `stream/web`, ...)
+ * are rewritten to their `node:` form and externalized. Non-builtins fall
+ * through to the deno loader for npm/jsr resolution. Registered before the
+ * deno plugin so it wins for these specifiers.
+ */
+function nodeBuiltinsExternalPlugin(): esbuild.Plugin {
+  return {
+    name: "1tube-node-builtins-external",
+    setup(build) {
+      build.onResolve({ filter: /^node:/ }, (args) => ({
+        path: args.path,
+        external: true,
+      }));
+      build.onResolve({ filter: /^[A-Za-z][A-Za-z0-9._/-]*$/ }, (args) => {
+        if (isNodeBuiltinBare(args.path)) {
+          return { path: `node:${args.path}`, external: true };
+        }
+        return null;
+      });
+    },
+  };
+}
+
 async function patchOutputFile(path: string): Promise<void> {
   const emitted = await Deno.readTextFile(path);
   const patched = patchCjsDefaultInterop(emitted);
@@ -692,14 +745,21 @@ export function createBundler(opts: BundlerOptions): Bundler {
 export async function bundleAllChunked(
   opts: BundlerOptions & {
     inputs: BundleInput[];
+    /** Runtime to emit for. Defaults to `workerd`. */
+    target?: BundleTarget;
   },
 ): Promise<ChunkedBundleAllResult> {
   await ensureDir(opts.outDir);
   const start = performance.now();
+  const target: BundleTarget = opts.target ?? "workerd";
+  const isVercel = target === "vercel";
   const sourcemap = opts.sourcemap ?? "linked";
   const sharedModules = opts.sharedModules ?? [];
   const plugins = [
-    entryProxyPlugin(opts.inputs),
+    // Node builtins must be externalized before the deno loader gets a
+    // chance to substitute its polyfills for the Vercel/Node target.
+    ...(isVercel ? [nodeBuiltinsExternalPlugin()] : []),
+    entryProxyPlugin(opts.inputs, target),
     ...(sharedModules.length > 0
       ? [sharedModulesExternalPlugin(sharedModules)]
       : []),
@@ -722,8 +782,13 @@ export async function bundleAllChunked(
       splitting: true,
       format: "esm",
       target: "es2022",
-      platform: "neutral",
-      conditions: ["worker", "browser", "import", "default"],
+      // Vercel runs on Node, so resolve the node conditions and let the
+      // host runtime provide builtins; workerd uses the leaner
+      // worker/browser conditions with nodejs_compat polyfills.
+      platform: isVercel ? "node" : "neutral",
+      conditions: isVercel
+        ? ["node", "import", "default"]
+        : ["worker", "browser", "import", "default"],
       sourcemap,
       minify: opts.minify ?? false,
       treeShaking: true,
@@ -737,7 +802,7 @@ export async function bundleAllChunked(
     });
   } catch (err) {
     const cause = err instanceof Error ? err.message : String(err);
-    throw new Error(`workerd chunked bundle failed\n${cause}`, {
+    throw new Error(`${target} chunked bundle failed\n${cause}`, {
       cause: err instanceof Error ? err : undefined,
     });
   }

package/src/cli/build.ts

@@ -419,6 +419,35 @@ export async function build(opts: BuildOptions): Promise<BuildResult> {
  *   --workerd-shared path  repeatable; module to run in gateway shared runtime
  */
 export async function runBuild(args: string[]): Promise<number> {
+  // --target selects the backend artifact. Default `workerd` (dist/ +
+  // manifest.json); `--target vercel` delegates to the Vercel Build Output
+  // API builder, which owns its own flags (--path-prefix, --runtime,
+  // --max-duration, …). Pre-scanned here so we route before parsing any
+  // workerd-specific flags.
+  let target = "workerd";
+  const rest: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if ((a === "--target" || a === "-t") && args[i + 1]) {
+      target = args[++i];
+    } else if (a.startsWith("--target=")) {
+      target = a.slice("--target=".length);
+    } else {
+      rest.push(a);
+    }
+  }
+  if (target === "vercel") {
+    const { runVercelBuild } = await import("./vercel-build.ts");
+    return await runVercelBuild(rest);
+  }
+  if (target !== "workerd") {
+    console.error(
+      `[1tube build] unknown --target: ${target} (expected "workerd" or "vercel")`,
+    );
+    return 2;
+  }
+  args = rest;
+
   let functionsDir = Deno.env.get("FUNCTIONS_PATH") || "./supabase/functions";
   let outDir = "./dist";
   let only: string[] | undefined;
@@ -713,6 +742,8 @@ export async function runBuild(args: string[]): Promise<number> {
 const BUILD_USAGE = `Usage: 1tube build [options]
 
 Options:
+  -t, --target NAME          Build target: workerd (default) | vercel
+                             For vercel options: 1tube build --target vercel --help
   -f, --functions <path>     Function source dir (default: ./supabase/functions)
   -o, --out <path>           Output directory (default: ./dist)
       --only A,B,C           Build only the named subset

package/src/cli/deno-config.ts

@@ -0,0 +1,83 @@
+/**
+ * Shared Deno-config resolution for the build commands.
+ *
+ * esbuild's Deno loader needs the host project's `deno.json[c]` to apply the
+ * import map. Both `1tube build` (workerd) and `1tube vercel-build` resolve it
+ * the same way, in priority order:
+ *
+ *   1. explicit `--config <path>`  → must exist (hard error otherwise)
+ *   2. explicit `--no-config`      → skip the import map entirely
+ *   3. auto-detect                 → cwd/deno.json[c] then
+ *                                    <functions-dir>/deno.json[c]
+ *
+ * The functions-dir fallback is what makes this work for hosts like
+ * sciobot-next: a Vite/Bun project whose only `deno.json` lives next to the
+ * edge functions (Supabase layout), not at repo root.
+ */
+
+import { isAbsolute, resolve as resolvePath } from "node:path";
+
+export interface ResolveDenoConfigOptions {
+  /** Function source dir (absolute or relative to cwd). */
+  functionsDir: string;
+  /**
+   * Explicit `--config` value. `undefined` = auto-detect; `""` = `--no-config`
+   * (skip the import map); otherwise an explicit path that must exist.
+   */
+  configArg?: string | undefined;
+  /** Sink for human-facing detection messages (no prefix). */
+  onMessage?: (message: string) => void;
+}
+
+export interface ResolveDenoConfigResult {
+  /** Resolved absolute config path, or undefined when none applies. */
+  configPath?: string;
+  /** Set when an explicit `--config` path was unreadable. */
+  error?: string;
+}
+
+export async function resolveDenoConfigPath(
+  opts: ResolveDenoConfigOptions,
+): Promise<ResolveDenoConfigResult> {
+  const { functionsDir, configArg, onMessage } = opts;
+
+  if (configArg !== undefined) {
+    if (configArg === "") return {};
+    const abs = isAbsolute(configArg)
+      ? configArg
+      : resolvePath(Deno.cwd(), configArg);
+    try {
+      const stat = await Deno.stat(abs);
+      if (!stat.isFile) throw new Error("not a regular file");
+      return { configPath: abs };
+    } catch (err) {
+      return {
+        error: `--config path not readable: ${abs} (${(err as Error).message})`,
+      };
+    }
+  }
+
+  const fnDirAbs = isAbsolute(functionsDir)
+    ? functionsDir
+    : resolvePath(Deno.cwd(), functionsDir);
+  const candidates = [
+    `${Deno.cwd()}/deno.json`,
+    `${Deno.cwd()}/deno.jsonc`,
+    `${fnDirAbs}/deno.json`,
+    `${fnDirAbs}/deno.jsonc`,
+  ];
+  for (const abs of candidates) {
+    try {
+      const stat = await Deno.stat(abs);
+      if (stat.isFile) {
+        onMessage?.(`using deno config: ${abs}`);
+        return { configPath: abs };
+      }
+    } catch { /* not found, try next */ }
+  }
+  onMessage?.(
+    `no deno.json / deno.jsonc at ${Deno.cwd()} or ${fnDirAbs} — bundling ` +
+      `without an import map. Pass --config <path> if you want one.`,
+  );
+  return {};
+}

package/src/cli/vercel-build.ts

@@ -0,0 +1,497 @@
+/**
+ * `1tube vercel-build` — compile edge functions into Vercel Build Output API
+ * function artifacts.
+ *
+ * Unlike `1tube build` (which produces a workerd `dist/` + `manifest.json`),
+ * this command emits one Vercel Node Function per edge function, laid out for
+ * the Build Output API so `vercel deploy --prebuilt` ships them as-is:
+ *
+ *     .vercel/output/
+ *       functions/
+ *         functions/v1/<name>.func/
+ *           .vc-config.json        — runtime + handler + streaming/maxDuration
+ *           package.json           — { "type": "module" } so .js is treated ESM
+ *           functions/<name>.js    — esbuild entry (the Vercel Node handler)
+ *           chunks/<hash>.js       — shared ESM chunks (copied per function)
+ *
+ * A function placed at `functions/functions/v1/<name>.func` is served by Vercel
+ * at the route `/functions/v1/<name>` — matching the path shape the frontend
+ * already calls (see sciobot's `API_CONFIG`). No per-function source changes are
+ * required: the Vercel bundle wrapper captures `Deno.serve` and bridges Node
+ * req/res to the Web fetch handler (see `../backends/vercel/wrapper.ts`).
+ *
+ * This command MERGES into an existing `.vercel/output` (e.g. one produced by
+ * `vercel build` for the static frontend). It only creates/replaces the
+ * specific `.func` directories; it never wipes the output root, so the
+ * frontend's `config.json` and static assets are left untouched.
+ *
+ * Each function is fully standalone — there is no gateway shared runtime on
+ * Vercel, so modules like `_shared/profile-cache.ts` are bundled inline rather
+ * than turned into RPC stubs.
+ */
+
+import { ensureDir } from "jsr:@std/fs@^1/ensure-dir";
+import { dirname, isAbsolute, join, resolve as resolvePath } from "node:path";
+import {
+  bundleAllChunked,
+  type ChunkedBundleAllResult,
+  discoverEntrypoints,
+  disposeBundlerResources,
+} from "../backends/workerd/bundler.ts";
+import { loadManifest } from "../manifest.ts";
+import { resolveDenoConfigPath } from "./deno-config.ts";
+
+/** Default Vercel managed Node runtime for emitted functions. */
+const DEFAULT_RUNTIME = "nodejs24.x";
+/** Default route prefix; matches sciobot's `/functions/v1/<name>` calls. */
+const DEFAULT_PATH_PREFIX = "functions/v1";
+/** Default function timeout (seconds) when no `1tube.json` timeoutMs is set. */
+const DEFAULT_MAX_DURATION = 300;
+/** Upper bound for maxDuration (seconds). Fluid/Pro allows long durations. */
+const DEFAULT_MAX_DURATION_CAP = 800;
+
+export interface VercelBuildOptions {
+  functionsDir: string;
+  /** Build Output API root, typically `.vercel/output`. */
+  outDir: string;
+  /** Path to host project's deno.json (for esbuild's Deno loader import map). */
+  configPath?: string;
+  /** Restrict the build to a subset of function names. */
+  only?: readonly string[];
+  /** Sourcemap mode. Defaults to "linked". */
+  sourcemap?: boolean | "linked" | "inline";
+  /** Minify bundles. Defaults to false. */
+  minify?: boolean;
+  /** Route prefix under `functions/`. Defaults to "functions/v1". */
+  pathPrefix?: string;
+  /** Vercel runtime identifier. Defaults to "nodejs24.x". */
+  runtime?: string;
+  /** Fallback maxDuration (seconds) when a function has no timeoutMs. */
+  defaultMaxDuration?: number;
+  /** Hard cap (seconds) applied to any derived maxDuration. */
+  maxDurationCap?: number;
+  /** Progress callback for CLI/status reporting. */
+  onProgress?: (event: VercelBuildProgress) => void;
+}
+
+export type VercelBuildProgress =
+  | { phase: "bundle-start"; functions: number }
+  | {
+    phase: "bundle-complete";
+    functions: number;
+    chunks: number;
+    durationMs: number;
+  }
+  | {
+    phase: "emit-function";
+    name: string;
+    route: string;
+    bytes: number;
+    maxDuration: number;
+  };
+
+export interface VercelFunctionEntry {
+  /** Logical function name. */
+  name: string;
+  /** Public route, e.g. `functions/v1/hello`. */
+  route: string;
+  /** Absolute path to the emitted `<name>.func` directory. */
+  funcDir: string;
+  /** Handler path relative to `funcDir` (POSIX), e.g. `functions/hello.js`. */
+  handler: string;
+  /** All module files copied into the func dir (POSIX, entry first). */
+  moduleFiles: string[];
+  /** Entry bundle byte size. */
+  byteLength: number;
+  /** Derived Vercel maxDuration (seconds). */
+  maxDuration: number;
+}
+
+export interface VercelBuildResult {
+  /** Build Output API root. */
+  outDir: string;
+  /** Absolute path to `<outDir>/functions/<pathPrefix>`. */
+  functionsRoot: string;
+  /** Runtime baked into each `.vc-config.json`. */
+  runtime: string;
+  /** Effective route prefix. */
+  pathPrefix: string;
+  /** Emitted functions, sorted by name. */
+  functions: VercelFunctionEntry[];
+  durationMs: number;
+}
+
+/** `.vc-config.json` shape for a Build Output API Node function. */
+interface VcConfig {
+  runtime: string;
+  handler: string;
+  launcherType: "Nodejs";
+  shouldAddHelpers: boolean;
+  shouldAddSourcemapSupport: boolean;
+  supportsResponseStreaming: boolean;
+  maxDuration: number;
+}
+
+async function removeDirIfExists(path: string): Promise<void> {
+  try {
+    await Deno.remove(path, { recursive: true });
+  } catch (err) {
+    if (!(err instanceof Deno.errors.NotFound)) throw err;
+  }
+}
+
+/**
+ * Convert a per-function `timeoutMs` into a Vercel maxDuration (seconds),
+ * clamped to `[1, cap]`. Falls back to `def` when no timeout is configured.
+ */
+function clampMaxDuration(
+  timeoutMs: number | undefined,
+  def: number,
+  cap: number,
+): number {
+  const base = typeof timeoutMs === "number" && timeoutMs > 0
+    ? Math.ceil(timeoutMs / 1000)
+    : def;
+  return Math.max(1, Math.min(cap, base));
+}
+
+function normalizePrefix(prefix: string): string {
+  return prefix.replace(/^[/\\]+/, "").replace(/[/\\]+$/, "").replace(
+    /\\/g,
+    "/",
+  );
+}
+
+async function buildVercelOnce(
+  opts: VercelBuildOptions,
+): Promise<VercelBuildResult> {
+  const startedAt = performance.now();
+  const cwd = Deno.cwd();
+  const functionsDir = isAbsolute(opts.functionsDir)
+    ? opts.functionsDir
+    : resolvePath(cwd, opts.functionsDir);
+  const outDir = isAbsolute(opts.outDir)
+    ? opts.outDir
+    : resolvePath(cwd, opts.outDir);
+  const pathPrefix = normalizePrefix(opts.pathPrefix ?? DEFAULT_PATH_PREFIX);
+  const runtime = opts.runtime ?? DEFAULT_RUNTIME;
+  const sourcemap = opts.sourcemap ?? "linked";
+  const defaultMaxDuration = opts.defaultMaxDuration ?? DEFAULT_MAX_DURATION;
+  const maxDurationCap = opts.maxDurationCap ?? DEFAULT_MAX_DURATION_CAP;
+
+  let inputs = await discoverEntrypoints(functionsDir);
+  if (opts.only && opts.only.length > 0) {
+    const allow = new Set(opts.only);
+    inputs = inputs.filter((i) => allow.has(i.name));
+  }
+  if (inputs.length === 0) {
+    throw new Error(
+      `1tube vercel-build: no functions matched under ${functionsDir}` +
+        (opts.only ? ` (only=${JSON.stringify(opts.only)})` : ""),
+    );
+  }
+
+  // Bundle into a throwaway staging dir, then distribute each function's
+  // module files into its own `.func` directory. Staging keeps the chunk
+  // graph intact (shared chunks are emitted once) while letting us copy the
+  // reachable set per function so each `.func` is self-contained.
+  const stageDir = await Deno.makeTempDir({ prefix: "1tube-vercel-" });
+  try {
+    opts.onProgress?.({ phase: "bundle-start", functions: inputs.length });
+    const bundleStart = performance.now();
+    const chunked: ChunkedBundleAllResult = await bundleAllChunked({
+      inputs,
+      outDir: stageDir,
+      target: "vercel",
+      ...(opts.configPath ? { configPath: opts.configPath } : {}),
+      sourcemap,
+      minify: opts.minify ?? false,
+    });
+    opts.onProgress?.({
+      phase: "bundle-complete",
+      functions: chunked.functions.length,
+      chunks: chunked.chunks.length,
+      durationMs: performance.now() - bundleStart,
+    });
+
+    const functionsRoot = join(outDir, "functions", ...pathPrefix.split("/"));
+    const entries: VercelFunctionEntry[] = [];
+
+    for (const fn of chunked.functions) {
+      const funcDir = join(functionsRoot, `${fn.name}.func`);
+      // Replace any stale artifact so removed chunks don't linger.
+      await removeDirIfExists(funcDir);
+
+      for (const moduleFile of fn.moduleFiles) {
+        const src = join(stageDir, moduleFile);
+        const dest = join(funcDir, moduleFile);
+        await ensureDir(dirname(dest));
+        await Deno.copyFile(src, dest);
+        if (sourcemap === "linked") {
+          try {
+            await Deno.copyFile(`${src}.map`, `${dest}.map`);
+          } catch (err) {
+            if (!(err instanceof Deno.errors.NotFound)) throw err;
+          }
+        }
+      }
+
+      const handler = fn.moduleFiles[0];
+      const manifest = await loadManifest(functionsDir, fn.name);
+      const maxDuration = clampMaxDuration(
+        manifest.timeoutMs,
+        defaultMaxDuration,
+        maxDurationCap,
+      );
+
+      const vcConfig: VcConfig = {
+        runtime,
+        handler,
+        launcherType: "Nodejs",
+        shouldAddHelpers: false,
+        shouldAddSourcemapSupport: sourcemap === "linked",
+        supportsResponseStreaming: true,
+        maxDuration,
+      };
+      await Deno.writeTextFile(
+        join(funcDir, ".vc-config.json"),
+        JSON.stringify(vcConfig, null, 2) + "\n",
+      );
+      // package.json with type:module so Vercel's Node launcher loads the
+      // emitted `.js` files as ESM (esbuild output uses import/export).
+      await Deno.writeTextFile(
+        join(funcDir, "package.json"),
+        JSON.stringify({ type: "module" }, null, 2) + "\n",
+      );
+
+      const route = `${pathPrefix}/${fn.name}`;
+      entries.push({
+        name: fn.name,
+        route,
+        funcDir,
+        handler,
+        moduleFiles: [...fn.moduleFiles],
+        byteLength: fn.byteLength,
+        maxDuration,
+      });
+      opts.onProgress?.({
+        phase: "emit-function",
+        name: fn.name,
+        route,
+        bytes: fn.byteLength,
+        maxDuration,
+      });
+    }
+
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    return {
+      outDir,
+      functionsRoot,
+      runtime,
+      pathPrefix,
+      functions: entries,
+      durationMs: performance.now() - startedAt,
+    };
+  } finally {
+    await removeDirIfExists(stageDir);
+  }
+}
+
+export async function buildVercel(
+  opts: VercelBuildOptions,
+): Promise<VercelBuildResult> {
+  try {
+    return await buildVercelOnce(opts);
+  } finally {
+    // Always release esbuild's worker subprocess — on Windows it otherwise
+    // lingers and blocks deletion of the staging dir / output.
+    await disposeBundlerResources().catch(() => {});
+  }
+}
+
+/**
+ * CLI entry point. Returns a process exit code (does not call `Deno.exit`).
+ *
+ * Recognised flags (all optional):
+ *   --functions <path>     function source dirs (default ./supabase/functions)
+ *   --out <path>           Build Output API root (default ./.vercel/output)
+ *   --only A,B,C           build a subset of functions
+ *   --sourcemap none|linked|inline   (default: linked)
+ *   --minify               minify bundles
+ *   --path-prefix <p>      route prefix under functions/ (default functions/v1)
+ *   --runtime <id>         Vercel runtime (default nodejs24.x)
+ *   --max-duration <s>     fallback maxDuration seconds (default 300)
+ *   --max-duration-cap <s> hard cap for maxDuration (default 800)
+ *   --config <path>        explicit deno.json path
+ *   --no-config            skip the import map
+ */
+export async function runVercelBuild(args: string[]): Promise<number> {
+  let functionsDir = Deno.env.get("FUNCTIONS_PATH") || "./supabase/functions";
+  let outDir = "./.vercel/output";
+  let only: string[] | undefined;
+  let sourcemap: boolean | "linked" | "inline" = "linked";
+  let minify = false;
+  let pathPrefix = DEFAULT_PATH_PREFIX;
+  let runtime = DEFAULT_RUNTIME;
+  let defaultMaxDuration = DEFAULT_MAX_DURATION;
+  let maxDurationCap = DEFAULT_MAX_DURATION_CAP;
+  let configPathArg: string | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if ((a === "--functions" || a === "-f") && args[i + 1]) {
+      functionsDir = args[++i];
+    } else if ((a === "--out" || a === "-o") && args[i + 1]) {
+      outDir = args[++i];
+    } else if (a === "--only" && args[i + 1]) {
+      only = args[++i].split(",").map((s) => s.trim()).filter((s) =>
+        s.length > 0
+      );
+    } else if (a === "--sourcemap" && args[i + 1]) {
+      const v = args[++i];
+      if (v === "none" || v === "false" || v === "off") sourcemap = false;
+      else if (v === "inline") sourcemap = "inline";
+      else if (v === "linked" || v === "true" || v === "on") {
+        sourcemap = "linked";
+      } else {
+        console.error(`[1tube vercel-build] unknown --sourcemap value: ${v}`);
+        return 2;
+      }
+    } else if (a === "--minify") {
+      minify = true;
+    } else if (a === "--path-prefix" && args[i + 1]) {
+      pathPrefix = args[++i];
+    } else if (a.startsWith("--path-prefix=")) {
+      pathPrefix = a.slice("--path-prefix=".length);
+    } else if (a === "--runtime" && args[i + 1]) {
+      runtime = args[++i];
+    } else if (a.startsWith("--runtime=")) {
+      runtime = a.slice("--runtime=".length);
+    } else if (a === "--max-duration" && args[i + 1]) {
+      const n = parseInt(args[++i], 10);
+      if (!Number.isFinite(n) || n < 1) {
+        console.error(
+          `[1tube vercel-build] --max-duration must be a positive integer`,
+        );
+        return 2;
+      }
+      defaultMaxDuration = n;
+    } else if (a === "--max-duration-cap" && args[i + 1]) {
+      const n = parseInt(args[++i], 10);
+      if (!Number.isFinite(n) || n < 1) {
+        console.error(
+          `[1tube vercel-build] --max-duration-cap must be a positive integer`,
+        );
+        return 2;
+      }
+      maxDurationCap = n;
+    } else if (a === "--config" && args[i + 1]) {
+      configPathArg = args[++i];
+    } else if (a.startsWith("--config=")) {
+      configPathArg = a.slice("--config=".length);
+    } else if (a === "--no-config") {
+      configPathArg = "";
+    } else if (a === "--help" || a === "-h") {
+      console.log(VERCEL_BUILD_USAGE);
+      return 0;
+    } else {
+      console.error(
+        `[1tube vercel-build] unknown argument: ${a}\n${VERCEL_BUILD_USAGE}`,
+      );
+      return 2;
+    }
+  }
+
+  const configResult = await resolveDenoConfigPath({
+    functionsDir,
+    configArg: configPathArg,
+    onMessage: (m) => console.log(`[1tube vercel-build] ${m}`),
+  });
+  if (configResult.error) {
+    console.error(`[1tube vercel-build] ${configResult.error}`);
+    return 2;
+  }
+  const configPath = configResult.configPath;
+
+  console.log(
+    `[1tube vercel-build] bundling functions from ${functionsDir} → ${outDir} ` +
+      `(runtime ${runtime}, route /${normalizePrefix(pathPrefix)}/<name>)`,
+  );
+  const fmt = (n: number) => {
+    if (n < 1024) return `${n}B`;
+    if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
+    return `${(n / (1024 * 1024)).toFixed(2)}MB`;
+  };
+
+  try {
+    const result = await buildVercel({
+      functionsDir,
+      outDir,
+      ...(configPath ? { configPath } : {}),
+      ...(only ? { only } : {}),
+      sourcemap,
+      minify,
+      pathPrefix,
+      runtime,
+      defaultMaxDuration,
+      maxDurationCap,
+      onProgress(event) {
+        if (event.phase === "bundle-start") {
+          console.log(
+            `[1tube vercel-build] bundling ${event.functions} function(s) for Vercel Node…`,
+          );
+        } else if (event.phase === "bundle-complete") {
+          console.log(
+            `[1tube vercel-build] bundled ${event.functions} function(s) and ${event.chunks} chunk(s) in ${
+              event.durationMs.toFixed(0)
+            }ms`,
+          );
+        } else if (event.phase === "emit-function") {
+          console.log(
+            `[1tube vercel-build]   /${event.route} → ${
+              fmt(event.bytes)
+            } (maxDuration ${event.maxDuration}s)`,
+          );
+        }
+      },
+    });
+
+    const totalBytes = result.functions.reduce((acc, f) => acc + f.byteLength, 0);
+    console.log(
+      `[1tube vercel-build] emitted ${result.functions.length} function(s) ` +
+        `(${fmt(totalBytes)}) into ${result.functionsRoot} in ${
+          result.durationMs.toFixed(0)
+        }ms`,
+    );
+    console.log(
+      `[1tube vercel-build] deploy with: vercel deploy --prebuilt`,
+    );
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[1tube vercel-build] FAILED: ${msg}`);
+    return 1;
+  }
+}
+
+const VERCEL_BUILD_USAGE = `Usage: 1tube build --target vercel [options]
+
+Emits Vercel Build Output API function artifacts under <out>/functions/<prefix>/.
+Merges into an existing .vercel/output (e.g. from \`vercel build\`).
+
+Options:
+  -f, --functions <path>     Function source dir (default: ./supabase/functions)
+  -o, --out <path>           Build Output root (default: ./.vercel/output)
+      --only A,B,C           Build only the named subset
+      --sourcemap MODE       none | linked (default) | inline
+      --minify               Minify bundles
+      --path-prefix <p>      Route prefix under functions/ (default: functions/v1)
+      --runtime <id>         Vercel runtime (default: nodejs24.x)
+      --max-duration <s>     Fallback maxDuration seconds when no 1tube.json
+                             timeoutMs is set (default: 300)
+      --max-duration-cap <s> Hard cap for maxDuration seconds (default: 800)
+      --config <path>        Explicit deno.json path for the import map.
+                             Default: auto-detect cwd/deno.json[c] then
+                             <functions-dir>/deno.json[c] (Supabase layout).
+      --no-config            Skip the import map entirely.
+  -h, --help                 Show this help`;

package/src/cli.ts

@@ -36,7 +36,7 @@ if (arg0 === "build") {
 
 Commands:
   serve       Run the gateway (default when no command given)
-  build       Bundle functions into a sealed artifact for prebuilt deploys
+  build       Bundle functions for a target (--target workerd|vercel)
   package     Build and/or wrap dist/ into a signed .1tube firmware payload
   --version   Print version and exit
   --help      Print this help

package/src/logs/query.ts

@@ -195,6 +195,12 @@ export interface LogQuery {
   logsSince(afterId: number, limit?: number): LogRecord[];
   /** Distinct function names seen in the store (for filter dropdowns). */
   functionNames(): string[];
+  /**
+   * Most recent invocation timestamp per function, across the whole
+   * retention window. Seeds the Deno worker host's MRU boot ordering so
+   * deferred boot warms the functions the developer actually uses first.
+   */
+  lastDispatchByFunction(): Map<string, number>;
 }
 
 export function createLogQuery(db: LogDb): LogQuery {
@@ -368,5 +374,23 @@ export function createLogQuery(db: LogDb): LogQuery {
     return rows.map((r) => r.function_name);
   }
 
-  return { queryInvocations, getInvocation, searchLogs, logsSince, functionNames };
+  function lastDispatchByFunction(): Map<string, number> {
+    // Satisfied entirely by idx_invocations_fn_ts (fn, ts) — one index
+    // scan, no table reads.
+    const rows = raw.prepare(
+      `SELECT function_name, MAX(ts_ms) AS last_ts FROM invocations GROUP BY function_name`,
+    ).all() as unknown as Array<{ function_name: string; last_ts: number }>;
+    const out = new Map<string, number>();
+    for (const r of rows) out.set(r.function_name, Number(r.last_ts));
+    return out;
+  }
+
+  return {
+    queryInvocations,
+    getInvocation,
+    searchLogs,
+    logsSince,
+    functionNames,
+    lastDispatchByFunction,
+  };
 }

package/src/server.ts

@@ -1329,6 +1329,18 @@ if (opts.backend === "workerd") {
     );
   }
 
+  // MRU warm-up seed: the invocation log store remembers which
+  // functions were hit before the restart; deferred boot warms those
+  // first instead of going alphabetically.
+  let bootRecency: Map<string, number> | undefined;
+  if (logDbHandle) {
+    try {
+      bootRecency = createLogQuery(logDbHandle).lastDispatchByFunction();
+    } catch {
+      // Best-effort: a broken store only costs the smarter boot order.
+    }
+  }
+
   denoWorkerHost = createDenoWorkerHost({
     functionsDir: resolvedFunctionsPath,
     registry,
@@ -1351,6 +1363,9 @@ if (opts.backend === "workerd") {
     ...(denoImportMapOptions ?? {}),
     ...(denoSharedRuntime ? { sharedRuntime: denoSharedRuntime } : {}),
     ...(denoRewriteCache ? { rewriteCache: denoRewriteCache } : {}),
+    ...(bootRecency && bootRecency.size > 0
+      ? { initialRecency: bootRecency }
+      : {}),
   });
 
   // Boot progress: append-only `[i/N] ✓ name (123ms)` per worker plus