@specific.dev/spectest 0.63.0 → 0.64.0

package/dist/components/supabase.js

@@ -698,12 +698,60 @@ async function validJwt(token: string): Promise<boolean> {
   }
 }
 
+/** One isolate per function, reused across requests (the runtime pools by
+ *  servicePath). The idle timeout is a day, not upstream's five minutes: a
+ *  test environment is a snapshot lineage whose forks inherit these
+ *  isolates, and an isolate reaped for idleness is rebooted by the next
+ *  test that calls the function — a boot's worth of dirtied memory in that
+ *  test's own snapshot diff. */
+function workerFor(name: string) {
+  return EdgeRuntime.userWorkers.create({
+    servicePath: FUNCTIONS_DIR + "/" + name,
+    memoryLimitMb: 256,
+    workerTimeoutMs: 24 * 60 * 60 * 1000,
+    noModuleCache: false,
+    importMapPath: null,
+    envVars: Object.entries(Deno.env.toObject()),
+  });
+}
+
+/** Boot every function's isolate now, without calling it. Creating the
+ *  worker loads the module graph and runs the module's top level — for a
+ *  function that is its \`Deno.serve(handler)\` registration, no business
+ *  logic. Called once at environment setup, before the warm snapshot, so
+ *  the isolates are shared, clean pages of the snapshot rather than a boot
+ *  in every test that first touches a function. */
+async function warmAll(): Promise<{ warmed: string[]; failed: Record<string, string> }> {
+  const names: string[] = [];
+  for await (const entry of Deno.readDir(FUNCTIONS_DIR)) {
+    if (!entry.isDirectory || entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+    try {
+      await Deno.stat(FUNCTIONS_DIR + "/" + entry.name + "/index.ts");
+      names.push(entry.name);
+    } catch {
+      // not a function directory
+    }
+  }
+  // All at once: a project can have dozens of functions, and each boot is
+  // mostly module loading — the isolates come up concurrently.
+  const results = await Promise.allSettled(names.map((name) => workerFor(name)));
+  const warmed: string[] = [];
+  const failed: Record<string, string> = {};
+  results.forEach((r, i) => {
+    if (r.status === "fulfilled") warmed.push(names[i]);
+    else failed[names[i]] = String(r.reason);
+  });
+  return { warmed: warmed.sort(), failed };
+}
+
 Deno.serve(async (req: Request) => {
   const { pathname } = new URL(req.url);
 
   // Ready probe — answered before any auth check, so bring-up never needs a
   // token, and never treated as a function name.
   if (pathname === "/_spectest/health") return new Response("ok");
+  // Setup-time warm-up (see warmAll); never treated as a function name.
+  if (pathname === "/_spectest/warm") return json(await warmAll());
 
   const name = pathname.split("/")[1] ?? "";
   if (name === "") return json({ msg: "missing function name in request" }, 400);
@@ -718,14 +766,7 @@ Deno.serve(async (req: Request) => {
 
   const servicePath = FUNCTIONS_DIR + "/" + name;
   try {
-    const worker = await EdgeRuntime.userWorkers.create({
-      servicePath,
-      memoryLimitMb: 256,
-      workerTimeoutMs: 5 * 60 * 1000,
-      noModuleCache: false,
-      importMapPath: null,
-      envVars: Object.entries(Deno.env.toObject()),
-    });
+    const worker = await workerFor(name);
     return await worker.fetch(req);
   } catch (e) {
     // A missing directory lands here too, so say which function was asked
@@ -1416,7 +1457,7 @@ export function supabase(opts = {}) {
             }
             // ── functions (edge runtime) ────────────────────────────────────
             if (withFunctions) {
-                parts.functions = {
+                const functionsDef = {
                     // Built rather than pulled, so the functions' remote imports are
                     // fetched by the host builder and cached into the image — see
                     // `functionsDockerfile`.
@@ -1472,7 +1513,27 @@ export function supabase(opts = {}) {
                         path: "/_spectest/health",
                         timeoutSecs: 120,
                     },
+                    // Boot every function's isolate before the warm snapshot is
+                    // taken (see warmAll in the router). Measured on a real project
+                    // (Harmony, 2026-08-28): a test that first touched a few
+                    // functions dirtied ~1 GB booting them — memory that then had to
+                    // be written into that test's snapshot diff and paid for by every
+                    // fork of it. Warm, the isolates are clean shared pages of the
+                    // snapshot and a test's diff is what its requests mutate.
+                    setup: async () => {
+                        const res = await fetch(`http://${g.key("functions")}:9000/_spectest/warm`);
+                        if (!res.ok) {
+                            console.warn(`supabase(): edge functions warm-up answered ${res.status}; functions boot on first call instead.`);
+                            return;
+                        }
+                        const { warmed, failed } = (await res.json());
+                        console.log(`supabase(): warmed ${warmed.length} edge function${warmed.length === 1 ? "" : "s"}${warmed.length ? ` (${warmed.join(", ")})` : ""}.`);
+                        for (const [name, err] of Object.entries(failed)) {
+                            console.warn(`supabase(): edge function "${name}" failed to boot at warm-up — it will be retried on first call: ${err}`);
+                        }
+                    },
                 };
+                parts.functions = functionsDef;
             }
             // ── kong (gateway / primary) — no explicit dependsOn: the group
             // expansion makes the primary depend on every member ──────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.63.0",
+  "version": "0.64.0",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/components/supabase.ts

@@ -1043,12 +1043,60 @@ async function validJwt(token: string): Promise<boolean> {
   }
 }
 
+/** One isolate per function, reused across requests (the runtime pools by
+ *  servicePath). The idle timeout is a day, not upstream's five minutes: a
+ *  test environment is a snapshot lineage whose forks inherit these
+ *  isolates, and an isolate reaped for idleness is rebooted by the next
+ *  test that calls the function — a boot's worth of dirtied memory in that
+ *  test's own snapshot diff. */
+function workerFor(name: string) {
+  return EdgeRuntime.userWorkers.create({
+    servicePath: FUNCTIONS_DIR + "/" + name,
+    memoryLimitMb: 256,
+    workerTimeoutMs: 24 * 60 * 60 * 1000,
+    noModuleCache: false,
+    importMapPath: null,
+    envVars: Object.entries(Deno.env.toObject()),
+  });
+}
+
+/** Boot every function's isolate now, without calling it. Creating the
+ *  worker loads the module graph and runs the module's top level — for a
+ *  function that is its \`Deno.serve(handler)\` registration, no business
+ *  logic. Called once at environment setup, before the warm snapshot, so
+ *  the isolates are shared, clean pages of the snapshot rather than a boot
+ *  in every test that first touches a function. */
+async function warmAll(): Promise<{ warmed: string[]; failed: Record<string, string> }> {
+  const names: string[] = [];
+  for await (const entry of Deno.readDir(FUNCTIONS_DIR)) {
+    if (!entry.isDirectory || entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+    try {
+      await Deno.stat(FUNCTIONS_DIR + "/" + entry.name + "/index.ts");
+      names.push(entry.name);
+    } catch {
+      // not a function directory
+    }
+  }
+  // All at once: a project can have dozens of functions, and each boot is
+  // mostly module loading — the isolates come up concurrently.
+  const results = await Promise.allSettled(names.map((name) => workerFor(name)));
+  const warmed: string[] = [];
+  const failed: Record<string, string> = {};
+  results.forEach((r, i) => {
+    if (r.status === "fulfilled") warmed.push(names[i]);
+    else failed[names[i]] = String(r.reason);
+  });
+  return { warmed: warmed.sort(), failed };
+}
+
 Deno.serve(async (req: Request) => {
   const { pathname } = new URL(req.url);
 
   // Ready probe — answered before any auth check, so bring-up never needs a
   // token, and never treated as a function name.
   if (pathname === "/_spectest/health") return new Response("ok");
+  // Setup-time warm-up (see warmAll); never treated as a function name.
+  if (pathname === "/_spectest/warm") return json(await warmAll());
 
   const name = pathname.split("/")[1] ?? "";
   if (name === "") return json({ msg: "missing function name in request" }, 400);
@@ -1063,14 +1111,7 @@ Deno.serve(async (req: Request) => {
 
   const servicePath = FUNCTIONS_DIR + "/" + name;
   try {
-    const worker = await EdgeRuntime.userWorkers.create({
-      servicePath,
-      memoryLimitMb: 256,
-      workerTimeoutMs: 5 * 60 * 1000,
-      noModuleCache: false,
-      importMapPath: null,
-      envVars: Object.entries(Deno.env.toObject()),
-    });
+    const worker = await workerFor(name);
     return await worker.fetch(req);
   } catch (e) {
     // A missing directory lands here too, so say which function was asked
@@ -1917,7 +1958,7 @@ export function supabase(opts: SupabaseOptions = {}): SupabaseStack {
 
       // ── functions (edge runtime) ────────────────────────────────────
       if (withFunctions) {
-        parts.functions = {
+        const functionsDef: ServiceDefinition = {
           // Built rather than pulled, so the functions' remote imports are
           // fetched by the host builder and cached into the image — see
           // `functionsDockerfile`.
@@ -1976,7 +2017,27 @@ export function supabase(opts: SupabaseOptions = {}): SupabaseStack {
             path: "/_spectest/health",
             timeoutSecs: 120,
           },
+          // Boot every function's isolate before the warm snapshot is
+          // taken (see warmAll in the router). Measured on a real project
+          // (Harmony, 2026-08-28): a test that first touched a few
+          // functions dirtied ~1 GB booting them — memory that then had to
+          // be written into that test's snapshot diff and paid for by every
+          // fork of it. Warm, the isolates are clean shared pages of the
+          // snapshot and a test's diff is what its requests mutate.
+          setup: async () => {
+            const res = await fetch(`http://${g.key("functions")}:9000/_spectest/warm`);
+            if (!res.ok) {
+              console.warn(`supabase(): edge functions warm-up answered ${res.status}; functions boot on first call instead.`);
+              return;
+            }
+            const { warmed, failed } = (await res.json()) as { warmed: string[]; failed: Record<string, string> };
+            console.log(`supabase(): warmed ${warmed.length} edge function${warmed.length === 1 ? "" : "s"}${warmed.length ? ` (${warmed.join(", ")})` : ""}.`);
+            for (const [name, err] of Object.entries(failed)) {
+              console.warn(`supabase(): edge function "${name}" failed to boot at warm-up — it will be retried on first call: ${err}`);
+            }
+          },
         };
+        parts.functions = functionsDef;
       }
 
       // ── kong (gateway / primary) — no explicit dependsOn: the group