1tube 0.1.8 → 0.1.10

package/package.json

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

package/src/boot-progress.ts

@@ -0,0 +1,131 @@
+/**
+ * Append-only boot progress reporter for function discovery.
+ *
+ * Why not a live in-place spinner? With many functions importing in
+ * parallel, their top-level `console.log()` calls hit the same TTY as our
+ * renderer. Any cursor-rewrite scheme (\r + clear-line, ANSI cursor
+ * positioning, alt-screen, even Ink) corrupts the moment a foreign writer
+ * lands a line — you get flicker, half-erased frames, or text glued to
+ * the spinner. Below 200 ms of redraw cadence the eye also reads it as
+ * blinking, which the operator perceives as "broken UI".
+ *
+ * So we don't redraw. We print one normal newline-terminated line every
+ * `pulseMs` saying "still working, X/Y done, in progress: …". It's not
+ * animated, but it's:
+ *   - race-free with foreign stdout writers,
+ *   - zero-cost (one syscall every couple of seconds),
+ *   - safe to pipe to a file or capture in CI,
+ *   - and identical between TTY and non-TTY paths (no branching).
+ *
+ * Pulses self-suppress when no work has changed since the previous tick,
+ * so a wedged import won't spam the log either.
+ */
+
+const DEFAULT_PULSE_MS = 2000;
+/** Cap inflight names rendered inline so a long list doesn't wrap. */
+const MAX_INFLIGHT_RENDERED = 4;
+
+export interface BootProgress {
+  /** Reset and arm the heartbeat for a new batch of `total` items. */
+  start(total: number): void;
+  /** An import has begun. */
+  onStart(name: string): void;
+  /** Print a completion line and update internal counters. */
+  onFinish(line: string, name: string): void;
+  /** Stop the heartbeat. Safe to call repeatedly. */
+  stop(): void;
+}
+
+interface Sink {
+  writeSync(chunk: Uint8Array): number;
+  // Kept in the interface for future use / fakes; renderer ignores it.
+  isTerminal?(): boolean;
+}
+
+export interface BootProgressOptions {
+  /** Heartbeat cadence in ms. Default 2000. Set ≤0 to disable heartbeats. */
+  pulseMs?: number;
+}
+
+export function createBootProgress(
+  sink: Sink = Deno.stdout,
+  opts: BootProgressOptions = {},
+): BootProgress {
+  const enc = new TextEncoder();
+  const pulseMs = opts.pulseMs ?? DEFAULT_PULSE_MS;
+
+  const active = new Set<string>();
+  let completed = 0;
+  let total = 0;
+  let startedAt = 0;
+  let timer: number | undefined;
+  // Snapshot used to suppress a heartbeat when nothing has moved since the
+  // last pulse — important when a single slow import blocks the worker
+  // pool and we'd otherwise emit identical lines forever.
+  let lastSnapshot = "";
+
+  const write = (s: string) => {
+    try {
+      sink.writeSync(enc.encode(s));
+    } catch {
+      // Closed pipe — never crash boot over a broken stdout.
+    }
+  };
+
+  const renderInflight = (): string => {
+    if (active.size === 0) return "(idle)";
+    const names = [...active];
+    if (names.length <= MAX_INFLIGHT_RENDERED) return names.join(", ");
+    return (
+      names.slice(0, MAX_INFLIGHT_RENDERED).join(", ") +
+      ` +${names.length - MAX_INFLIGHT_RENDERED} more`
+    );
+  };
+
+  const pulse = () => {
+    if (total === 0) return;
+    if (completed >= total) return;
+    const snapshot = `${completed}|${[...active].sort().join(",")}`;
+    if (snapshot === lastSnapshot) return;
+    lastSnapshot = snapshot;
+    const elapsed = ((performance.now() - startedAt) / 1000).toFixed(1);
+    write(
+      `[1tube]    \x1b[2m… still working: ${completed}/${total} loaded, ` +
+        `${active.size} in progress (${renderInflight()}) (${elapsed}s)\x1b[0m\n`,
+    );
+  };
+
+  return {
+    start(t) {
+      total = t;
+      completed = 0;
+      active.clear();
+      startedAt = performance.now();
+      lastSnapshot = "";
+      if (timer !== undefined) {
+        clearInterval(timer);
+        timer = undefined;
+      }
+      if (pulseMs > 0 && t > 0) {
+        timer = setInterval(pulse, pulseMs) as unknown as number;
+      }
+    },
+    onStart(name) {
+      active.add(name);
+    },
+    onFinish(line, name) {
+      active.delete(name);
+      completed++;
+      write(line + "\n");
+      // Reset the snapshot so the next pulse always reflects the new state
+      // immediately rather than waiting another `pulseMs`.
+      lastSnapshot = "";
+    },
+    stop() {
+      if (timer !== undefined) {
+        clearInterval(timer);
+        timer = undefined;
+      }
+    },
+  };
+}

package/src/discovery.ts

@@ -34,6 +34,14 @@ export interface DiscoveryOptions {
   concurrency?: number;
   /** Invoked once per function as it finishes (success or failure). */
   onProgress?: (p: DiscoveryProgress) => void;
+  /**
+   * Invoked once per function the moment its dynamic import is dispatched
+   * (or, in lazy mode, the moment it's registered as a candidate). Useful
+   * for live progress UIs that want to show what's currently in-flight,
+   * not just what's completed — important because a single transpile can
+   * block a worker for several seconds with no completion events.
+   */
+  onStart?: (p: { name: string; index: number; total: number }) => void;
   /**
    * When true, candidates are registered for lazy import on first dispatch.
    * Functions whose manifest sets `warm: true` are still imported eagerly
@@ -109,6 +117,7 @@ export async function discoverAndLoad(
   }
 
   const total = work.length;
+  let started = 0;
   let completed = 0;
 
   const loadOne = async (name: string): Promise<void> => {
@@ -121,6 +130,7 @@ export async function discoverAndLoad(
       moduleUrl.searchParams.set("v", options.cacheBust);
     }
 
+    options?.onStart?.({ name, index: ++started, total });
     const start = performance.now();
     try {
       // Load the manifest first so it is attached to the registry before the

package/src/server.ts

@@ -21,6 +21,7 @@ import { bodyLimit } from "npm:hono@4/body-limit";
 import { relative, sep as SEPARATOR } from "node:path";
 import { currentRequestStorage, FunctionRegistry } from "./registry.ts";
 import { discoverAndLoad, type DiscoveryProgress } from "./discovery.ts";
+import { createBootProgress } from "./boot-progress.ts";
 import { validateRequest } from "./gateway/auth.ts";
 import { watchdogBody } from "./gateway/body-watchdog.ts";
 import { corsMiddleware } from "./gateway/cors.ts";
@@ -64,9 +65,12 @@ function parseArgs(): CliOpts {
 
   let dev = envFlag("1TUBE_DEV");
   let hmr = envFlag("1TUBE_HMR");
-  // Lazy-load is on by default; opt out with --eager / 1TUBE_LAZY=0.
+  // Eager loading is the default — first-request latency reflects real
+  // function cost (no on-demand transpile tax). Opt in to lazy with
+  // --lazy or 1TUBE_LAZY=1 when boot speed matters more than first-hit
+  // latency (e.g. sites with hundreds of rarely-called functions).
   const lazyEnv = Deno.env.get("1TUBE_LAZY");
-  let lazy = lazyEnv === undefined ? true : !(lazyEnv === "0" || lazyEnv === "false");
+  let lazy = lazyEnv === undefined ? false : (lazyEnv === "1" || lazyEnv === "true");
   let port = parseInt(Deno.env.get("PORT") || "3100", 10);
   let host = (Deno.env.get("1TUBE_HOST") || "127.0.0.1").trim();
   let functionsPath = Deno.env.get("FUNCTIONS_PATH") || "./supabase/functions";
@@ -298,16 +302,40 @@ async function reloadFunctions(
   // HMR reloads always import eagerly so the change is observable on the
   // very next request — even when boot-time discovery was lazy.
   const useLazy = opts.lazy && isFullReload;
-  const { loaded, skipped, errors, removed, deferred } = await discoverAndLoad(
-    opts.functionsPath,
-    registry,
-    {
-      cacheBust,
-      only: isFullReload ? undefined : changedFunctionNames,
-      onProgress: (p) => console.log(progressLine(p)),
-      lazy: useLazy,
-    },
-  );
+
+  // Append-only "still working" heartbeat. Does not redraw, does not race
+  // with foreign console.log() from imported modules — see
+  // src/boot-progress.ts for the design rationale. Heartbeat is silent for
+  // tiny HMR reloads (≤2 functions) where the per-completion line is
+  // already enough signal.
+  const isTinyReload = changedFunctionNames instanceof Set &&
+    changedFunctionNames.size <= 2;
+  const progress = createBootProgress(Deno.stdout, {
+    pulseMs: isTinyReload ? 0 : 2000,
+  });
+
+  let result;
+  try {
+    result = await discoverAndLoad(
+      opts.functionsPath,
+      registry,
+      {
+        cacheBust,
+        only: isFullReload ? undefined : changedFunctionNames,
+        onStart: (p) => {
+          // Late-bind the total on the first start event — by then we
+          // know the real work-list size after `only`/exists filtering.
+          if (p.index === 1) progress.start(p.total);
+          progress.onStart(p.name);
+        },
+        onProgress: (p) => progress.onFinish(progressLine(p), p.name),
+        lazy: useLazy,
+      },
+    );
+  } finally {
+    progress.stop();
+  }
+  const { loaded, skipped, errors, removed, deferred } = result;
 
   for (const name of removed) {
     if (registry.delete(name)) {