1tube 0.1.21 → 0.1.23

package/src/discovery.ts

@@ -28,13 +28,6 @@ export interface DiscoveryProgress {
 export interface DiscoveryOptions {
   /** When set, appended as `?v=` to module URLs to force re-transpilation. */
   cacheBust?: string;
-  /**
-   * Optional alternate root for dynamic imports. Discovery and manifests still
-   * read from `functionsDir`; only module URLs are resolved under this root.
-   * Used by Deno-backend HMR snapshots so transitive relative imports get a
-   * fresh file URL namespace.
-   */
-  importRoot?: string;
   /** Restrict loading to this set of function names (others are skipped entirely). */
   only?: ReadonlySet<string>;
   /** Max number of concurrent dynamic imports. Defaults to 8. */
@@ -80,9 +73,6 @@ export async function discoverAndLoad(
   const errors: Array<{ name: string; error: string }> = [];
 
   const resolvedDir = await Deno.realPath(functionsDir);
-  const importRoot = options?.importRoot
-    ? await Deno.realPath(options.importRoot)
-    : resolvedDir;
 
   const candidates: string[] = [];
   for await (const entry of Deno.readDir(resolvedDir)) {
@@ -131,7 +121,7 @@ export async function discoverAndLoad(
   let completed = 0;
 
   const loadOne = async (name: string): Promise<void> => {
-    const indexPath = join(importRoot, name, "index.ts");
+    const indexPath = join(resolvedDir, name, "index.ts");
     // pathToFileURL is the node:url equivalent of std/path's toFileUrl;
     // both produce a `file://` URL whose searchParams we mutate below for
     // HMR cache-busting.
@@ -153,11 +143,7 @@ export async function discoverAndLoad(
       // on demand. This is the single biggest startup-time win for sites
       // with many rarely-called functions.
       if (options?.lazy && !manifest.warm) {
-        registry.registerCandidate({
-          name,
-          moduleUrl: moduleUrl.href,
-          manifest,
-        });
+        registry.registerCandidate({ name, moduleUrl: moduleUrl.href, manifest });
         deferred.push(name);
         const durationMs = performance.now() - start;
         options?.onProgress?.({
@@ -174,11 +160,7 @@ export async function discoverAndLoad(
       // Even in lazy mode, eagerly-warm functions still register a candidate
       // so HMR reloads can re-import via the same URL.
       if (options?.lazy && manifest.warm) {
-        registry.registerCandidate({
-          name,
-          moduleUrl: moduleUrl.href,
-          manifest,
-        });
+        registry.registerCandidate({ name, moduleUrl: moduleUrl.href, manifest });
       }
       await registry.runWithCurrentFunction(name, async () => {
         await import(moduleUrl.href);
@@ -211,16 +193,13 @@ export async function discoverAndLoad(
   // internally, but we still benefit from overlapping transpile + JSR fetches.
   const concurrency = Math.max(1, options?.concurrency ?? 8);
   let cursor = 0;
-  const workers = Array.from(
-    { length: Math.min(concurrency, work.length) },
-    async () => {
-      while (true) {
-        const i = cursor++;
-        if (i >= work.length) return;
-        await loadOne(work[i]);
-      }
-    },
-  );
+  const workers = Array.from({ length: Math.min(concurrency, work.length) }, async () => {
+    while (true) {
+      const i = cursor++;
+      if (i >= work.length) return;
+      await loadOne(work[i]);
+    }
+  });
   await Promise.all(workers);
 
   return { loaded, skipped, errors, removed, deferred };

package/src/registry.ts

@@ -77,6 +77,29 @@ export interface FunctionCandidate {
   manifest: FunctionManifest;
 }
 
+/**
+ * Out-of-process function handle used by the Worker-backed Deno backend.
+ * The gateway holds a `WorkerFunctionHandle` instead of a JS handler;
+ * `dispatch()` forwards the request through `postMessage` to the
+ * function's Web Worker.
+ *
+ * Defined here (rather than in `backends/deno/`) so the registry can
+ * type its `workerHandles` map without a circular import. The actual
+ * implementation lives in `src/backends/deno/worker-host.ts`.
+ */
+export interface WorkerFunctionHandle {
+  readonly name: string;
+  readonly manifest: FunctionManifest;
+  readonly isPublic: boolean;
+  readonly timeoutMs?: number;
+  dispatch(
+    req: Request,
+    auth: AuthContext | null,
+    signal: AbortSignal,
+  ): Promise<Response>;
+  terminate(): Promise<void>;
+}
+
 export class FunctionRegistry {
   private handlers = new Map<string, RegisteredFunction>();
   private pendingManifests = new Map<string, FunctionManifest>();
@@ -91,6 +114,14 @@ export class FunctionRegistry {
    * a JS handler exists.
    */
   private externalManifests = new Map<string, FunctionManifest>();
+  /**
+   * Out-of-process worker handles for the Deno backend's Worker-per-function
+   * execution model. Treated as live, dispatchable functions: `has()` /
+   * `knownNames()` / `manifestFor()` all surface them, but they live in a
+   * separate Map so the in-process `handlers` / `candidates` paths used by
+   * tests and the legacy in-isolate model stay unaffected.
+   */
+  private workerHandles = new Map<string, WorkerFunctionHandle>();
   /** In-flight import dedupe: many concurrent first-requests await the same Promise. */
   private loading = new Map<string, Promise<RegisteredFunction | null>>();
 
@@ -153,16 +184,18 @@ export class FunctionRegistry {
     return (
       this.handlers.has(name) ||
       this.candidates.has(name) ||
-      this.externalManifests.has(name)
+      this.externalManifests.has(name) ||
+      this.workerHandles.has(name)
     );
   }
 
-  /** Names visible to dispatch (loaded handlers + unloaded candidates). */
+  /** Names visible to dispatch (loaded handlers + unloaded candidates + worker handles). */
   knownNames(): string[] {
     const out = new Set<string>();
     for (const k of this.handlers.keys()) out.add(k);
     for (const k of this.candidates.keys()) out.add(k);
     for (const k of this.externalManifests.keys()) out.add(k);
+    for (const k of this.workerHandles.keys()) out.add(k);
     return [...out].sort();
   }
 
@@ -206,10 +239,28 @@ export class FunctionRegistry {
     return (
       this.handlers.get(name)?.manifest ??
       this.candidates.get(name)?.manifest ??
+      this.workerHandles.get(name)?.manifest ??
       this.externalManifests.get(name)
     );
   }
 
+  /**
+   * Register a Worker-backed function handle (Deno backend). Replaces any
+   * prior handle for `name` — callers are expected to terminate the old
+   * worker themselves; the registry doesn't own worker lifecycles.
+   */
+  setWorkerHandle(name: string, handle: WorkerFunctionHandle): void {
+    this.workerHandles.set(name, handle);
+  }
+
+  workerHandle(name: string): WorkerFunctionHandle | undefined {
+    return this.workerHandles.get(name);
+  }
+
+  clearWorkerHandle(name: string): boolean {
+    return this.workerHandles.delete(name);
+  }
+
   /**
    * Return the loaded handler if present, otherwise dynamically import the
    * candidate module (deduped across concurrent callers) and return the
@@ -253,6 +304,7 @@ export class FunctionRegistry {
     this.pendingManifests.delete(name);
     this.candidates.delete(name);
     this.loading.delete(name);
+    this.workerHandles.delete(name);
     return this.handlers.delete(name);
   }
 
@@ -261,6 +313,7 @@ export class FunctionRegistry {
     this.pendingManifests.clear();
     this.candidates.clear();
     this.loading.clear();
+    this.workerHandles.clear();
   }
 
   list(): string[] {