1tube 0.1.33 → 0.1.35

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.33",
+  "version": "0.1.35",
   "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
@@ -818,9 +826,9 @@ export function createDenoWorkerHost(
         manifest: handle.manifest,
         isPublic: handle.isPublic,
         timeoutMs: handle.timeoutMs,
-        dispatch: (req, auth, signal) => {
+        dispatch: (req, auth, signal, invocationId) => {
           lastDispatch.set(cand.name, Date.now());
-          return handle.dispatch(req, auth, signal);
+          return handle.dispatch(req, auth, signal, invocationId);
         },
         terminate: () => handle.terminate(),
       });
@@ -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/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