1tube 0.1.26 → 0.1.28

package/deno.lock

@@ -14,8 +14,8 @@
     "npm:es-module-lexer@2": "2.1.0",
     "npm:esbuild@0.28": "0.28.0",
     "npm:esbuild@~0.25.5": "0.25.12",
-    "npm:hono@4": "4.12.15",
-    "npm:hono@^4.12.14": "4.12.15"
+    "npm:hono@4": "4.12.18",
+    "npm:hono@^4.12.18": "4.12.18"
   },
   "jsr": {
     "@deno/esbuild-plugin@1.2.1": {
@@ -387,8 +387,8 @@
       "scripts": true,
       "bin": true
     },
-    "hono@4.12.15": {
-      "integrity": "sha512-qM0jDhFEaCBb4TxoW7f53Qrpv9RBiayUHo0S52JudprkhvpjIrGoU1mnnr29Fvd1U335ZFPZQY1wlkqgfGXyLg=="
+    "hono@4.12.18": {
+      "integrity": "sha512-RWzP96k/yv0PQfyXnWjs6zot20TqfpfsNXhOnev8d1InAxubW93L11/oNUc3tQqn2G0bSdAOBpX+2uDFHV7kdQ=="
     }
   },
   "workspace": {
@@ -404,7 +404,7 @@
     ],
     "packageJson": {
       "dependencies": [
-        "npm:hono@^4.12.14"
+        "npm:hono@^4.12.18"
       ]
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "1tube",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "private": false,
   "description": "Self-hosted Supabase Edge Functions gateway for Deno, plus an ESLint plugin for consumers",
   "license": "MIT",
@@ -42,6 +42,6 @@
     "prepublishOnly": "bun run typecheck && bun run check && bun run smoke:bin"
   },
   "dependencies": {
-    "hono": "^4.12.14"
+    "hono": "^4.12.18"
   }
 }

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

@@ -40,6 +40,8 @@ export interface DepGraphOptions {
    * only relative imports are tracked precisely.
    */
   importMap?: Readonly<Record<string, string>>;
+  /** Parsed `scopes` field from the host project's deno.json import map. */
+  importMapScopes?: Readonly<Record<string, Readonly<Record<string, string>>>>;
   /**
    * Absolute path of the deno.json the import map came from. Import
    * map values are resolved relative to this. Required when
@@ -56,6 +58,16 @@ export interface DepGraph {
    * burst with a half-written file doesn't crash the watcher.
    */
   refresh(name: string, entryFileUrl: string): Promise<void>;
+  /**
+   * Build one module graph for many function entries and populate each
+   * function's reachable file set from that shared graph. Initial eager boot
+   * uses this when shared-module rewriting needs every function's file list:
+   * it avoids N overlapping `deno_graph` walks over the same `_shared`, npm,
+   * and JSR dependencies.
+   */
+  refreshMany(
+    entries: Iterable<{ name: string; entryFileUrl: string }>,
+  ): Promise<void>;
   /** Drop a function's graph. Used when an `index.ts` is deleted. */
   forget(name: string): void;
   /**
@@ -113,6 +125,36 @@ function applyImportMap(
   return resolveAgainst(target, base);
 }
 
+function resolveImportMap(
+  specifier: string,
+  referrer: string,
+  importMap: Readonly<Record<string, string>> | undefined,
+  scopes:
+    | Readonly<Record<string, Readonly<Record<string, string>>>>
+    | undefined,
+  base: string,
+): string | null {
+  let bestScope: string | null = null;
+  if (scopes) {
+    for (const rawScope of Object.keys(scopes)) {
+      const scopeUrl = resolveAgainst(rawScope, base);
+      if (!referrer.startsWith(scopeUrl)) continue;
+      if (bestScope === null || scopeUrl.length > bestScope.length) {
+        bestScope = scopeUrl;
+      }
+    }
+  }
+  if (bestScope !== null && scopes) {
+    for (const rawScope of Object.keys(scopes)) {
+      if (resolveAgainst(rawScope, base) !== bestScope) continue;
+      const scoped = applyImportMap(specifier, scopes[rawScope], base);
+      if (scoped !== null) return scoped;
+      break;
+    }
+  }
+  return importMap ? applyImportMap(specifier, importMap, base) : null;
+}
+
 function resolveAgainst(target: string, base: string): string {
   // Bare URLs (npm:/jsr:/https:/file:) pass through unchanged. Relative
   // paths get resolved against the import map's deno.json directory so
@@ -127,11 +169,18 @@ export function createDepGraph(options?: DepGraphOptions): DepGraph {
   const reverse = new Map<string, Set<string>>();
 
   const importMap = options?.importMap;
+  const importMapScopes = options?.importMapScopes;
   const importMapBase = options?.importMapBase;
 
-  const resolve = importMap && importMapBase
+  const resolve = importMapBase && (importMap || importMapScopes)
     ? (specifier: string, referrer: string): string => {
-      const rewritten = applyImportMap(specifier, importMap, importMapBase);
+      const rewritten = resolveImportMap(
+        specifier,
+        referrer,
+        importMap,
+        importMapScopes,
+        importMapBase,
+      );
       if (rewritten !== null) return rewritten;
       // Fall through to standard resolution against the referrer.
       try {
@@ -158,6 +207,41 @@ export function createDepGraph(options?: DepGraphOptions): DepGraph {
     if (set.size === 0) reverse.delete(fileUrl);
   }
 
+  function replaceGraph(name: string, fresh: Set<string>): void {
+    const old = perName.get(name);
+    if (old) {
+      for (const f of old) {
+        if (!fresh.has(f)) indexRemove(name, f);
+      }
+    }
+    for (const f of fresh) {
+      if (!old || !old.has(f)) indexAdd(name, f);
+    }
+    perName.set(name, fresh);
+  }
+
+  function minimalGraph(entry: string): Set<string> {
+    return new Set<string>([entry]);
+  }
+
+  function fileDepsOf(mod: unknown): string[] {
+    const deps = (mod as { dependencies?: unknown[] })?.dependencies;
+    if (!Array.isArray(deps)) return [];
+    const out: string[] = [];
+    for (const dep of deps) {
+      const d = dep as {
+        code?: { specifier?: unknown };
+        type?: { specifier?: unknown };
+      };
+      for (const target of [d.code?.specifier, d.type?.specifier]) {
+        if (typeof target === "string" && target.startsWith("file://")) {
+          out.push(target);
+        }
+      }
+    }
+    return out;
+  }
+
   return {
     async refresh(name, entryFileUrl) {
       const entry = normalize(entryFileUrl);
@@ -169,13 +253,7 @@ export function createDepGraph(options?: DepGraphOptions): DepGraph {
         // disk; deno_graph throws. Drop the graph for `name` so the
         // affected-set reverts to "this entry only" and let the next
         // (clean) save rebuild it. Better than dying.
-        const old = perName.get(name);
-        if (old) {
-          for (const f of old) indexRemove(name, f);
-        }
-        const minimal = new Set<string>([entry]);
-        perName.set(name, minimal);
-        indexAdd(name, entry);
+        replaceGraph(name, minimalGraph(entry));
         return;
       }
 
@@ -189,17 +267,49 @@ export function createDepGraph(options?: DepGraphOptions): DepGraph {
       // Always include the entry, even if deno_graph short-circuited
       // due to a load error on a child.
       fresh.add(entry);
+      replaceGraph(name, fresh);
+    },
 
-      const old = perName.get(name);
-      if (old) {
-        for (const f of old) {
-          if (!fresh.has(f)) indexRemove(name, f);
-        }
+    async refreshMany(entries) {
+      const normalized = [...entries].map((e) => ({
+        name: e.name,
+        entry: normalize(e.entryFileUrl),
+      }));
+      if (normalized.length === 0) return;
+
+      let graph;
+      try {
+        graph = await createGraph(
+          normalized.map((e) => e.entry),
+          resolve ? { resolve } : undefined,
+        );
+      } catch {
+        for (const e of normalized) replaceGraph(e.name, minimalGraph(e.entry));
+        return;
       }
-      for (const f of fresh) {
-        if (!old || !old.has(f)) indexAdd(name, f);
+
+      const modules = new Map<string, unknown>();
+      const adjacency = new Map<string, string[]>();
+      for (const mod of graph.modules ?? []) {
+        const spec = (mod as { specifier?: unknown })?.specifier;
+        if (typeof spec !== "string" || !spec.startsWith("file://")) continue;
+        modules.set(spec, mod);
+        adjacency.set(spec, fileDepsOf(mod));
+      }
+
+      for (const e of normalized) {
+        const fresh = new Set<string>([e.entry]);
+        const stack = [e.entry];
+        while (stack.length > 0) {
+          const current = stack.pop()!;
+          for (const dep of adjacency.get(current) ?? []) {
+            if (fresh.has(dep)) continue;
+            fresh.add(dep);
+            if (modules.has(dep)) stack.push(dep);
+          }
+        }
+        replaceGraph(e.name, fresh);
       }
-      perName.set(name, fresh);
     },
 
     filesFor(name) {

package/src/backends/deno/hot-reloader.ts

@@ -32,6 +32,7 @@ import type { DenoWorkerHost, ReloadSummary } from "./worker-host.ts";
 import type { DepGraph } from "./dep-graph.ts";
 import type { DenoSharedRuntime } from "./shared-runtime.ts";
 import type { RewriteCache } from "./source-rewriter.ts";
+import { resolve } from "node:path";
 
 export type FsEventStream = AsyncIterable<{ paths: readonly string[] }> & {
   close(): void;
@@ -159,31 +160,30 @@ export function createDenoReloadDebouncer(
  *    changed file.
  * 2. Files matching `<functionsDir>/<name>/index.ts`: include `<name>`.
  *    Catches the entry's own edits.
- * 3. Path is the directory `<functionsDir>/<name>` itself or any path
- *    under it (subtree change). This is necessary for two cases the
- *    other rules miss:
+ * 3. Optionally, path is the directory `<functionsDir>/<name>` itself. This is
+ *    necessary for two cases the other rules miss:
  *      - **Linux**: `Deno.watchFs` is recursive only over the dirs
  *        that existed at start. A *new* function dir reports a single
  *        `<functionsDir>/<name>` create event — child file events
  *        never fire because inotify doesn't auto-watch the new subdir.
  *      - **Windows**: deleting a function dir tree emits dir-path
  *        events instead of `index.ts` events.
- *    Either way the affected name is the first path component after
- *    `functionsDir`. We let `discoverCandidates` filter out junk
- *    (e.g. `_shared`) on the reload pass so this rule stays simple
- *    and doesn't need the host's knownNames set.
+ *    Callers that can stat the candidate directory should disable this
+ *    fallback and decide new/removed/existing precisely. A plain parent-dir
+ *    event can also be emitted for a child sidecar edit, and reloading that
+ *    function would be noisy when the dep graph has no edge to the file.
  */
 export function computeAffected(
   paths: readonly string[],
   depGraph: DepGraph,
-  options: { functionsDir?: string } = {},
+  options: { functionsDir?: string; includeDirectoryEvents?: boolean } = {},
 ): Set<string> {
   const out = depGraph.affected(paths);
   for (const p of paths) {
     const m = /[\\/]([^\\/]+)[\\/]index\.ts$/.exec(p);
     if (m && m[1]) out.add(m[1]);
   }
-  if (options.functionsDir) {
+  if (options.functionsDir && options.includeDirectoryEvents !== false) {
     const fnDir = options.functionsDir.replace(/[\\/]$/, "");
     for (const p of paths) {
       // Strip the prefix; anything left should look like
@@ -194,7 +194,8 @@ export function computeAffected(
       else if (p.startsWith(fnDir + "\\")) rest = p.slice(fnDir.length + 1);
       else if (p === fnDir) continue;
       if (rest === null) continue;
-      const seg = rest.split(/[\\/]/, 1)[0];
+      if (/[\\/]/.test(rest)) continue;
+      const seg = rest;
       // Skip private/shared dirs the host already filters out — keeps
       // the affected set tight even before `reload()` runs.
       if (!seg || seg.startsWith("_") || seg.endsWith("_shared")) continue;
@@ -204,13 +205,32 @@ export function computeAffected(
   return out;
 }
 
+function directoryEventFunctionNames(
+  paths: readonly string[],
+  functionsDir: string,
+): Set<string> {
+  const out = new Set<string>();
+  const fnDir = functionsDir.replace(/[\\/]$/, "");
+  for (const p of paths) {
+    let rest: string | null = null;
+    if (p.startsWith(fnDir + "/")) rest = p.slice(fnDir.length + 1);
+    else if (p.startsWith(fnDir + "\\")) rest = p.slice(fnDir.length + 1);
+    else continue;
+    if (!rest || /[\\/]/.test(rest)) continue;
+    if (rest.startsWith("_") || rest.endsWith("_shared")) continue;
+    out.add(rest);
+  }
+  return out;
+}
+
 export function createDenoHotReloader(
   opts: DenoHotReloaderOptions,
 ): DenoHotReloader {
   const log = opts.log ?? ((line) => console.log(line));
-  const watcherFactory = opts.watch ?? ((dir: string) =>
-    Deno.watchFs(dir, { recursive: true }) as unknown as FsEventStream
-  );
+  const functionsDir = resolve(opts.functionsDir);
+  const watcherFactory = opts.watch ??
+    ((dir: string) =>
+      Deno.watchFs(dir, { recursive: true }) as unknown as FsEventStream);
 
   let stream: FsEventStream | null = null;
   let stopped = false;
@@ -252,7 +272,8 @@ export function createDenoHotReloader(
       }
 
       const raw = computeAffected(paths, opts.host.depGraph, {
-        functionsDir: opts.functionsDir,
+        functionsDir,
+        includeDirectoryEvents: false,
       });
       // Files that aren't owned by any single function (shared
       // modules, anything imported by ≥2 functions) need every
@@ -265,6 +286,17 @@ export function createDenoHotReloader(
       // `functionsDir` (README.md, .gitignore, …) so we don't spend
       // a reload pass producing an empty summary.
       const known = new Set(opts.host.list());
+      for (
+        const name of directoryEventFunctionNames(paths, functionsDir)
+      ) {
+        const indexPath = `${functionsDir}/${name}/index.ts`;
+        try {
+          const stat = await Deno.stat(indexPath);
+          if (stat.isFile && !known.has(name)) raw.add(name);
+        } catch {
+          if (known.has(name)) raw.add(name);
+        }
+      }
       const affected = new Set<string>();
       for (const name of raw) {
         if (known.has(name)) {
@@ -272,7 +304,7 @@ export function createDenoHotReloader(
           continue;
         }
         try {
-          const indexPath = `${opts.functionsDir}/${name}/index.ts`;
+          const indexPath = `${functionsDir}/${name}/index.ts`;
           const stat = await Deno.stat(indexPath);
           if (stat.isFile) affected.add(name);
         } catch {
@@ -307,16 +339,18 @@ export function createDenoHotReloader(
         opts.onReloaded?.(summary);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        log(`[1tube] HMR reload FAILED — keeping previous workers alive. Error: ${msg}`);
+        log(
+          `[1tube] HMR reload FAILED — keeping previous workers alive. Error: ${msg}`,
+        );
       }
     },
   });
 
   return {
-    async start() {
-      if (stream) return;
-      stream = watcherFactory(opts.functionsDir);
-      log(`[1tube] HMR watching: ${opts.functionsDir}`);
+    start() {
+      if (stream) return Promise.resolve();
+      stream = watcherFactory(functionsDir);
+      log(`[1tube] HMR watching: ${functionsDir}`);
       consumeLoop = (async () => {
         try {
           for await (const event of stream!) {
@@ -328,6 +362,7 @@ export function createDenoHotReloader(
           if (!stopped) log(`[1tube] HMR watcher disabled: ${err}`);
         }
       })();
+      return Promise.resolve();
     },
     async stop() {
       if (stopped) return;