@webjsdev/server 0.8.0 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjsdev/server",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "type": "module",
   "description": "webjs dev/prod server: SSR, router, API, server actions, live reload",
   "main": "index.js",

package/src/actions.js

@@ -46,8 +46,9 @@ async function rpcResponse(payload, init = {}) {
  * ignored.
  *
  * The server:
- *   1. Scans the app tree on boot, classifying server files into
- *      RPC-callable actions vs. server-only utilities.
+ *   1. Scans the app tree lazily on the first request (in `ensureReady`),
+ *      classifying server files into RPC-callable actions vs. server-only
+ *      utilities. Hashing is eager-per-file; only `expose()` files load.
  *   2. Serves a generated ES-module stub when the browser imports
  *      the file URL (an RPC stub for actions, a throw-at-load stub
  *      for server-only utilities).
@@ -106,7 +107,22 @@ export async function buildActionIndex(appDir, dev) {
     const h = await hashFile(file);
     hashToFile.set(h, file);
     fileToHash.set(file, h);
-    // Load module once at scan time to pick up any expose() tags.
+    // Pure-RPC actions are NOT executed at boot: invokeAction and
+    // serveActionStub import the module on demand (first RPC call / first stub
+    // fetch), so the hash index above is all the analysis needs. Eagerly
+    // running every server module (and its transitive Prisma init, DB
+    // connects, etc.) would be wasted work. The one thing that DOES need eager loading is expose(),
+    // which registers a REST route the router must know before any request can
+    // hit it. So load only files that REFERENCE expose. We match the bare
+    // `expose` identifier (not `expose(`) so an aliased import
+    // (`import { expose as exp }`, whose import clause still names `expose`) is
+    // not missed: missing it would silently 404 that file's REST route. A stray
+    // mention in a comment or string only over-matches, costing one harmless
+    // extra module load; the common pure-RPC file never names `expose` and so
+    // still defers entirely.
+    let src = '';
+    try { src = await readFile(file, 'utf8'); } catch {}
+    if (!/\bexpose\b/.test(src)) continue;
     try {
       const mod = await loadModule(file, dev);
       for (const [name, fn] of Object.entries(mod)) {

package/src/check.js

@@ -62,7 +62,7 @@ export const RULES = [
   {
     name: 'components-have-register',
     description:
-      'Component files that define a class extending WebComponent must register the class with ClassName.register(\'tag\') (or customElements.define). The server-side scanner derives the module URL from the file path at boot.',
+      'Component files that define a class extending WebComponent must register the class with ClassName.register(\'tag\') (or customElements.define). The server-side scanner derives the module URL from the file path.',
   },
   {
     name: 'no-server-env-in-components',

package/src/component-elision.js

@@ -648,28 +648,80 @@ export async function analyzeElision(components, routeModules, moduleGraph, read
     }
   }
 
-  // Ship any component whose transitive import closure does client work,
-  // through ANY import (not just npm): a relative helper that imports a
-  // reactive primitive (shared module-scope signal), enables the client
-  // router, references a browser global, or side-effect imports a package.
-  // Same closure rule the route analysis applies, so a display-only
-  // component that pulls in a client-effecting helper still ships.
-  const closureIsClientEffecting = (d) =>
-    reactiveFiles.has(d) || clientRouterFiles.has(d) || clientGlobalOrBareFiles.has(d);
+  // Reverse import edges (who imports each file), built once from the graph.
+  // Drives both the closure-client-work reachability below and the fixpoint's
+  // import rule, each in O(N+E) rather than a per-component closure walk.
+  /** @type {Map<string, Set<string>>} */
+  const importersOf = new Map();
+  for (const [file, deps] of moduleGraph) {
+    for (const dep of deps) {
+      let set = importersOf.get(dep);
+      if (!set) { set = new Set(); importersOf.set(dep, set); }
+      set.add(file);
+    }
+  }
+
+  // Files that reach client work through their imports: a reactive primitive,
+  // the client router, a browser global, an `@event` binding, or a side-effect
+  // npm import. Computed by propagating BACKWARD from the client-effecting
+  // files through the reverse edges, stopping at `.server` files (the forward
+  // closure skips them, since the browser only ever sees their stub). This is
+  // O(N+E) instead of a full transitive-closure walk per component, which was
+  // the second O(N^2) on a deep component chain.
+  /** @type {Set<string>} */
+  const reachesClientWork = new Set();
+  {
+    const work = [];
+    for (const f of [...reactiveFiles, ...clientRouterFiles, ...clientGlobalOrBareFiles]) {
+      if (!reachesClientWork.has(f)) { reachesClientWork.add(f); work.push(f); }
+    }
+    while (work.length) {
+      const node = /** @type {string} */ (work.pop());
+      const importers = importersOf.get(node);
+      if (!importers) continue;
+      for (const imp of importers) {
+        if (serverFiles.has(imp)) continue;  // a server file blocks the forward closure
+        if (!reachesClientWork.has(imp)) { reachesClientWork.add(imp); work.push(imp); }
+      }
+    }
+  }
+
+  // Ship any component whose transitive import closure does client work (the
+  // helper-imports-a-signal case): it ships if any of its direct, non-server
+  // deps reaches client work. Equivalent to the old per-component closure walk
+  // (a component that is itself client-effecting is already shipping via
+  // analyzeComponentSource), but linear.
   if (appDir) {
     for (const file of componentFiles) {
       if (mustShip.has(file)) continue;
-      const deps = transitiveDeps(moduleGraph, [file], appDir, serverFiles);
-      if (deps.some(closureIsClientEffecting)) mustShip.add(file);
+      const deps = moduleGraph.get(file);
+      if (!deps) continue;
+      for (const dep of deps) {
+        if (serverFiles.has(dep)) continue;
+        if (reachesClientWork.has(dep)) { mustShip.add(file); break; }
+      }
     }
   }
 
-  // Tags each component can emit on a client re-render (own + helper closure).
+  // Tags each component can emit on a client re-render: its OWN rendered tags
+  // plus tags returned by the template HELPERS it imports (the lib/utils/ui.ts
+  // pattern). The closure deliberately SKIPS component and server files:
+  // importing another component does not mean rendering its tag (a rendered tag
+  // is already in the importer's own source via extractRenderedTags), and a
+  // server file renders nothing client-side. Following component edges here
+  // makes the closure O(N^2) in time AND memory on a deep component chain
+  // (every component would accumulate every downstream tag); helper-only
+  // closures keep it linear. This is verdict-SAFE: it never elides a component
+  // that the render rule requires to ship (so it can never break a page), and
+  // it actually elides strictly MORE in some shapes, because following
+  // component edges made the old version over-ship components whose tags
+  // nothing actually renders client-side.
+  const tagClosureSkip = new Set([...componentFiles, ...serverFiles]);
   /** @type {Map<string, Set<string>>} */
   const emittableTags = new Map();
   for (const file of componentFiles) {
     const tags = new Set(fileTags.get(file));
-    const deps = appDir ? transitiveDeps(moduleGraph, [file], appDir) : [];
+    const deps = appDir ? transitiveDeps(moduleGraph, [file], appDir, tagClosureSkip) : [];
     for (const dep of deps) {
       const dt = fileTags.get(dep);
       if (dt) for (const t of dt) tags.add(t);
@@ -677,24 +729,26 @@ export async function analyzeElision(components, routeModules, moduleGraph, read
     emittableTags.set(file, tags);
   }
 
-  // Fixpoint: render rule + import rule.
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const parent of mustShip) {
-      const tags = emittableTags.get(parent);
-      if (!tags) continue;
+  // Fixpoint by worklist (render rule + import rule), O(N+E). Seed with the
+  // components already known to ship; each shipping node forces the components
+  // whose tags it can emit (render rule) and the COMPONENT files that import it
+  // (import rule). Replaces the old iterate-until-stable double loop, which was
+  // O(N^2) per pass and O(N^3) / out-of-memory on a deep render chain.
+  const queue = [...mustShip];
+  while (queue.length) {
+    const node = /** @type {string} */ (queue.pop());
+    const tags = emittableTags.get(node);
+    if (tags) {
       for (const tag of tags) {
         const childFile = tagToFile.get(tag);
-        if (childFile && !mustShip.has(childFile)) { mustShip.add(childFile); changed = true; }
+        if (childFile && !mustShip.has(childFile)) { mustShip.add(childFile); queue.push(childFile); }
       }
     }
-    for (const file of componentFiles) {
-      if (mustShip.has(file)) continue;
-      const deps = moduleGraph.get(file);
-      if (!deps) continue;
-      for (const dep of deps) {
-        if (componentFiles.has(dep) && mustShip.has(dep)) { mustShip.add(file); changed = true; break; }
+    const importers = importersOf.get(node);
+    if (importers) {
+      for (const imp of importers) {
+        if (!componentFiles.has(imp)) continue;  // import rule is component -> component
+        if (!mustShip.has(imp)) { mustShip.add(imp); queue.push(imp); }
       }
     }
   }

package/src/component-scanner.js

@@ -2,7 +2,7 @@
  * Server-side scanner that walks the app tree and records the
  * browser-visible URL for every webjs component module.
  *
- * Called once at server boot. Results are used to prime the core
+ * Called once on the first request (lazily, via `ensureReady`), then memoized. Results are used to prime the core
  * registry (`primeModuleUrl`) BEFORE any SSR render: so when a page
  * renders a component tag, `lookupModuleUrl(tag)` already has the URL
  * ready for `<link rel="modulepreload">` hints.
@@ -18,11 +18,24 @@
  * we only need `{ tag, className, moduleUrl }` tuples.
  */
 
-import { readFile } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import { sep } from 'node:path';
 import { walk } from './fs-walk.js';
 import { primeModuleUrl } from '@webjsdev/core';
 
+/**
+ * mtime-keyed cache of extracted components per file, so a rebuild re-reads
+ * only files that changed (an unchanged file reuses its cached component list
+ * after a single `stat`). Makes the component scan incremental for large apps.
+ * Keyed by mtime AND size (a same-tick length-changing edit is caught even on
+ * coarse-mtime filesystems).
+ * @type {Map<string, { mtimeMs: number, size: number, comps: Array<{ tag: string, className: string }> }>}
+ */
+const SCAN_CACHE = new Map();
+
+/** Introspection for tests/ops: is `file` currently in the scan cache? */
+export function _scanCacheHas(file) { return SCAN_CACHE.has(file); }
+
 /**
  * Recognise either registration pattern:
  *
@@ -70,21 +83,39 @@ export function extractComponents(src) {
 export async function scanComponents(appDir) {
   /** @type {Array<{ tag: string, className: string, moduleUrl: string, file: string }>} */
   const components = [];
+  /** @type {Set<string>} live component files this scan, for cache eviction */
+  const seen = new Set();
   const filter = (p) =>
     /\.m?[jt]sx?$/.test(p) &&
     !/\.(test|spec)\.m?[jt]sx?$/.test(p) &&
     !/\.server\.m?[jt]s$/.test(p);
 
   for await (const file of walk(appDir, filter)) {
-    let src;
-    try { src = await readFile(file, 'utf8'); } catch { continue; }
-    const comps = extractComponents(src);
+    let mtimeMs, size;
+    try { const st = await stat(file); mtimeMs = st.mtimeMs; size = st.size; } catch { continue; }
+    seen.add(file); // mark live (hit and miss) for cache eviction
+    let comps;
+    const cached = SCAN_CACHE.get(file);
+    if (cached && cached.mtimeMs === mtimeMs && cached.size === size) {
+      comps = cached.comps;
+    } else {
+      let src;
+      try { src = await readFile(file, 'utf8'); } catch { continue; }
+      comps = extractComponents(src);
+      SCAN_CACHE.set(file, { mtimeMs, size, comps });
+    }
     if (!comps.length) continue;
     const moduleUrl = toUrlPath(file, appDir);
     for (const c of comps) {
       components.push({ ...c, moduleUrl, file });
     }
   }
+  // Evict scan-cache entries for files no longer walked (renamed/deleted),
+  // scoped to this app so a multi-app process keeps other apps' entries.
+  const prefix = appDir.endsWith(sep) ? appDir : appDir + sep;
+  for (const key of SCAN_CACHE.keys()) {
+    if ((key === appDir || key.startsWith(prefix)) && !seen.has(key)) SCAN_CACHE.delete(key);
+  }
   return components;
 }
 

package/src/dev.js

@@ -212,149 +212,271 @@ export async function createRequestHandler(opts) {
     existsSync(join(distDir, 'webjs-core-browser.js'));
   await setCoreInstall(coreDir, distComplete);
 
-  // Build module dependency graph for transitive preload hints.
-  const moduleGraph = await buildModuleGraph(appDir);
-
-  // Scan for component classes and prime their module URLs into the
-  // core registry. SSR uses this for modulepreload hints without
-  // requiring authors to pass `import.meta.url` themselves. The same
-  // scan result feeds the browser-bound graph computation below,
-  // avoiding a duplicate appDir walk at boot.
-  const components = await scanComponents(appDir);
-  await primeComponentRegistry(appDir, components);
-
+  // Whole-app analysis (module graph, component scan, browser-bound gate,
+  // action index, middleware, elision, vendor) is NOT run at boot. It is
+  // computed on the first request via ensureReady() below and memoized, so the
+  // server starts without walking or reading the app's source, executing any
+  // server module, or hitting the network. Only the route table is built
+  // eagerly: it is a cheap directory scan (no code reads), and routing, Early
+  // Hints, and WebSocket lookups need it available before the first request.
   const routeTable = await buildRouteTable(appDir);
 
-  // Determine which component modules are display-only and which page/layout
-  // route modules are inert, so both can be elided from the browser (no JS
-  // download). Static analysis only; the sets bias conservatively toward
-  // shipping. See component-elision.js. The project-level `webjs.elide: false`
-  // switch in package.json skips the analysis entirely (empty sets, so nothing
-  // is stripped and the importmap keeps every vendor dep).
-  const elideEnabled = await readElideEnabled(appDir);
-  const { elidableComponents, inertRouteModules } = elideEnabled
-    ? await analyzeElision(
-        components,
-        collectRouteModules(routeTable),
-        moduleGraph,
-        (f) => readFile(f, 'utf8'),
-        appDir,
-      )
-    : { elidableComponents: new Set(), inertRouteModules: new Set() };
-
-  // Scan for bare npm imports and register vendor import map entries.
-  // Runs AFTER elision so vendor deps reachable only through display-only
-  // components are excluded from the importmap.
-  const bareImports = await scanBareImports(appDir, new Set([...elidableComponents, ...inertRouteModules]));
-  const initialVendor = await resolveVendorImports(bareImports, appDir);
-  await setVendorEntries(initialVendor.imports, initialVendor.integrity);
-
-  // Dev-time guardrail: warn about any class extending WebComponent
-  // that isn't registered via customElements.define() in its own
-  // module. Without registration, <my-tag> elements silently stay as
-  // HTMLUnknownElement in the browser: a common early-stage footgun.
-  if (dev) {
-    const orphans = await findOrphanComponents(appDir);
-    for (const { className, file } of orphans) {
-      logger.warn?.(
-        `[webjs] ${className} extends WebComponent but has no customElements.define(...) call in ${file}. ` +
-          `Add \`customElements.define('<tag-name>', ${className});\` at the bottom of the file ` +
-          `or <${kebab(className)}> tags won't upgrade in the browser.`,
-      );
-    }
-  }
-
   const state = {
     routeTable,
-    actionIndex: await buildActionIndex(appDir, dev),
-    middleware: await loadMiddleware(appDir, dev, logger),
+    actionIndex: null,
+    middleware: null,
     logger,
-    bareImports,
-    moduleGraph,
-    elidableComponents,
-    inertRouteModules,
-    browserBoundFiles: computeBrowserBoundFiles(routeTable, moduleGraph, components, appDir),
+    moduleGraph: null,
+    elidableComponents: new Set(),
+    inertRouteModules: new Set(),
+    browserBoundFiles: null,
   };
 
-  // Rebuilds are serialized so a slow rebuild #1 (e.g. waiting on a
-  // jspm.io fetch) cannot overwrite a fresher rebuild #2's
-  // setVendorEntries / route table when it finally finishes. Without
-  // this, two file edits inside one fs.watch debounce window could
-  // produce a permanently-stale importmap until the next rebuild.
-  // Each rebuild also gets a monotonic token; setVendorEntries is only
-  // applied if its token still matches the latest scheduled rebuild.
+  // All whole-app analysis is built lazily on the first request, memoized so
+  // boot does none of it. It runs in two stages. The deterministic analysis
+  // (module graph, component scan + prime, browser-bound gate, action index,
+  // middleware, elision) is network-free and, once built, never re-runs unless
+  // a rebuild invalidates it; readiness gates on it. Vendor resolution is a
+  // SEPARATE, best-effort stage: a pinned app reads a committed importmap file,
+  // an unpinned app auto-fetches from jspm. It does NOT gate readiness, so an
+  // offline or partially-unresolvable app still boots. A transient vendor
+  // failure is re-attempted on the NEXT ensureReady call (driven by an incoming
+  // request, a readiness probe, or the warm-up), with no background timer: the
+  // platform's traffic and probes are the retry loop. `readyError` holds a
+  // propagating analysis failure so /__webjs/ready can report it.
+  let analysisDone = false;        // deterministic analysis complete (readiness gate)
+  let vendorResolved = false;      // vendor map fully resolved (or permanently tolerated)
+  let vendorAttemptedOnce = false; // the first (blocking) vendor attempt has run
+  let vendorGen = 0;               // bumped on rebuild; a stale resolve cannot flip vendorResolved
+  let readyDone = false;           // mirrors analysisDone; the /__webjs/ready gate
+  /** @type {unknown} */
+  let readyError = null;
+  /** @type {Promise<void> | null} */
+  let readyInFlight = null;
+  async function ensureReady() {
+    // Fully warm: analysis done and vendor resolved. Nothing to do.
+    if (analysisDone && vendorResolved) return;
+    // Analysis warm but a prior vendor attempt failed: re-attempt WITHOUT
+    // blocking this request. The single-flight dedupes concurrent attempts;
+    // success flips the flag. This is the request/probe-driven retry (no timer).
+    if (analysisDone && vendorAttemptedOnce) {
+      const gen = vendorGen;
+      resolveAndApplyVendor().then((ok) => { if (ok && gen === vendorGen) vendorResolved = true; }).catch(() => {});
+      return;
+    }
+    // Otherwise run the (single-flighted) full warm: the analysis, then the
+    // first vendor attempt, awaited so the first response carries the import map.
+    if (!readyInFlight) {
+      readyInFlight = (async () => {
+        /** @type {Record<string, number>} */
+        const t = {};
+        let ranAnalysis = false, ranVendor = false;
+        const now = () => performance.now();
+        try {
+          if (!analysisDone) {
+            let m = now();
+            state.moduleGraph = await buildModuleGraph(appDir);
+            t.graph = now() - m; m = now();
+            const components = await scanComponents(appDir);
+            await primeComponentRegistry(appDir, components);
+            t.scan = now() - m; m = now();
+            state.browserBoundFiles = computeBrowserBoundFiles(state.routeTable, state.moduleGraph, components, appDir);
+            t.gate = now() - m; m = now();
+            state.actionIndex = await buildActionIndex(appDir, dev);
+            t.actions = now() - m; m = now();
+            state.middleware = await loadMiddleware(appDir, dev, logger);
+            t.middleware = now() - m; m = now();
+            const r = (await readElideEnabled(appDir))
+              ? await analyzeElision(components, collectRouteModules(state.routeTable),
+                  state.moduleGraph, (f) => readFile(f, 'utf8'), appDir)
+              : { elidableComponents: new Set(), inertRouteModules: new Set() };
+            state.elidableComponents = r.elidableComponents;
+            state.inertRouteModules = r.inertRouteModules;
+            t.elision = now() - m;
+            if (dev) {
+              for (const { className, file } of await findOrphanComponents(appDir)) {
+                logger.warn?.(
+                  `[webjs] ${className} extends WebComponent but has no customElements.define(...) call in ${file}. ` +
+                    `Add \`customElements.define('<tag-name>', ${className});\` or <${kebab(className)}> tags won't upgrade.`,
+                );
+              }
+            }
+            analysisDone = true;
+            ranAnalysis = true;
+          }
+          // Readiness gates on the analysis only; vendor is best-effort below.
+          readyDone = true;
+          readyError = null;
+          if (!vendorResolved) {
+            const m = now();
+            const gen = vendorGen;
+            vendorAttemptedOnce = true;
+            const ok = await resolveAndApplyVendor();
+            t.vendor = now() - m;
+            ranVendor = true;
+            // Only memoize success (and only if a rebuild didn't intervene). A
+            // transient failure leaves vendorResolved false; the next ensureReady
+            // call re-attempts it non-blocking. A permanent unresolvable (jspm
+            // 401) reports ok and is tolerated, so it does not loop.
+            if (ok && gen === vendorGen) vendorResolved = true;
+          }
+          if (ranAnalysis) {
+            const ms = (x) => Math.round(x || 0);
+            const total = ms(t.graph) + ms(t.scan) + ms(t.gate) + ms(t.actions) + ms(t.middleware) + ms(t.elision) + ms(t.vendor);
+            logger.info?.(
+              `[webjs] analysis warm in ${total}ms (graph ${ms(t.graph)}, scan ${ms(t.scan)}, ` +
+                `gate ${ms(t.gate)}, actions ${ms(t.actions)}, middleware ${ms(t.middleware)}, ` +
+                `elision ${ms(t.elision)}, vendor ${ms(t.vendor)})`,
+            );
+          } else if (ranVendor && vendorResolved) {
+            logger.info?.(`[webjs] vendor resolved in ${Math.round(t.vendor || 0)}ms`);
+          }
+        } catch (e) {
+          readyError = e;
+          throw e;
+        } finally {
+          readyInFlight = null;
+        }
+      })();
+    }
+    await readyInFlight;
+  }
+
+  // All vendor resolves funnel through one single-flight so two never overlap
+  // (resolveVendorImports reports a transient failure via a module-global flag
+  // that only one in-flight resolve may safely touch). Never rejects; returns
+  // the resolve's ok flag (false on a transient failure, applying whatever
+  // partial map resolved so the app is no worse off).
+  /** @type {Promise<boolean> | null} */
+  let vendorResolveInFlight = null;
+  function resolveAndApplyVendor() {
+    if (vendorResolveInFlight) return vendorResolveInFlight;
+    vendorResolveInFlight = (async () => {
+      try {
+        const v = await resolveVendorImports(appDir,
+          () => scanBareImports(appDir, new Set([...state.elidableComponents, ...state.inertRouteModules])));
+        await setVendorEntries(v.imports, v.integrity);
+        return v.ok;
+      } catch (e) {
+        logger.error?.(`[webjs] vendor resolve failed (will retry on the next request):`, e);
+        return false;
+      }
+    })().finally(() => { vendorResolveInFlight = null; });
+    return vendorResolveInFlight;
+  }
+
+  // Optional app-level readiness check. A `readiness.{js,ts}` file at the app
+  // root may default-export an async function; /__webjs/ready runs it once the
+  // analysis is warm, so readiness can reflect LIVE dependency health (a DB
+  // ping, a queue connection) that the static analysis cannot see. Returning
+  // false or throwing reports the instance not ready (503), so a readinessProbe
+  // holds traffic off an instance whose deps are down. Absent file => analysis-
+  // warm is the only gate. The module is cached per build (cleared on rebuild);
+  // the function itself runs on every probe so it reflects current state.
+  let readinessFn; // undefined = unloaded, null = no file, function = loaded
+  async function getReadinessCheck() {
+    if (readinessFn !== undefined) return readinessFn;
+    let file = null;
+    for (const name of ['readiness.ts', 'readiness.js', 'readiness.mts', 'readiness.mjs']) {
+      const p = join(appDir, name);
+      if (await exists(p)) { file = p; break; }
+    }
+    if (!file) { readinessFn = null; return null; }
+    try {
+      const url = pathToFileURL(file).toString();
+      const bust = dev ? `?t=${Date.now()}-${Math.random().toString(36).slice(2)}` : '';
+      const mod = await import(url + bust);
+      readinessFn = typeof mod.default === 'function' ? mod.default : null;
+    } catch (e) {
+      logger.error?.(`[webjs] failed to load readiness.{js,ts}`, { err: String(e) });
+      readinessFn = null;
+    }
+    return readinessFn;
+  }
+
+  // Rebuilds are serialized so a slow rebuild #1 cannot overwrite a fresher
+  // rebuild #2's route table when it finally finishes. Without this, two file
+  // edits inside one fs.watch debounce window could produce a permanently
+  // stale state until the next rebuild.
   let rebuildInFlight = Promise.resolve();
-  let latestRebuildToken = 0;
 
   async function rebuild() {
-    const token = ++latestRebuildToken;
-    rebuildInFlight = rebuildInFlight.then(() => doRebuild(token)).catch((e) => {
+    rebuildInFlight = rebuildInFlight.then(() => doRebuild()).catch((e) => {
       logger.error?.(`[webjs] rebuild failed:`, e);
     });
     return rebuildInFlight;
   }
 
-  async function doRebuild(token) {
+  async function doRebuild() {
+    // The route table is the only eager artifact (cheap directory scan); rebuild
+    // it so routing reflects added/removed route files immediately.
     state.routeTable = await buildRouteTable(appDir);
-    state.actionIndex = await buildActionIndex(appDir, dev);
-    state.middleware = await loadMiddleware(appDir, dev, logger);
     clearVendorCache();
-    state.moduleGraph = await buildModuleGraph(appDir);
-    // Re-scan components in case a new file was added or a tag renamed.
-    // Share the scan with the browser-bound graph computation so we
-    // don't walk appDir twice per rebuild.
-    const components = await scanComponents(appDir);
-    await primeComponentRegistry(appDir, components);
-    // Recompute which components are elidable and which route modules are
-    // inert. A dependency's edit can flip a verdict WITHOUT changing an
-    // importer's mtime, so the TS transform cache (keyed by mtime) must be
-    // dropped or it would serve a stale strip decision for the unchanged
-    // importer.
-    {
-      const r = (await readElideEnabled(appDir))
-        ? await analyzeElision(
-            components,
-            collectRouteModules(state.routeTable),
-            state.moduleGraph,
-            (f) => readFile(f, 'utf8'),
-            appDir,
-          )
-        : { elidableComponents: new Set(), inertRouteModules: new Set() };
-      state.elidableComponents = r.elidableComponents;
-      state.inertRouteModules = r.inertRouteModules;
-    }
     TS_CACHE.clear();
-    // Re-scan bare imports AFTER elision so the importmap drops vendor
-    // deps reachable only through display-only components.
-    state.bareImports = await scanBareImports(appDir, new Set([...state.elidableComponents, ...state.inertRouteModules]));
-    const v = await resolveVendorImports(state.bareImports, appDir);
-    // Defensive: if a newer rebuild has been queued while we were
-    // awaiting resolveVendorImports, drop our result. The newer one
-    // will overwrite anyway, but checking the token here avoids a
-    // brief window of stale entries.
-    if (token === latestRebuildToken) {
-      await setVendorEntries(v.imports, v.integrity);
-    }
-    // Recompute the browser-bound file set: the page / layout / error /
-    // loading / not-found / component entries plus their transitive imports.
-    // This drives the dev server's "is this file allowed to be served as
-    // source?" gate at the file-extension catch-all branch below.
-    state.browserBoundFiles = computeBrowserBoundFiles(state.routeTable, state.moduleGraph, components, appDir);
-    if (dev) {
-      const orphans = await findOrphanComponents(appDir);
-      for (const { className, file } of orphans) {
-        logger.warn?.(
-          `[webjs] ${className} extends WebComponent but has no customElements.define(...) call in ${file}. ` +
-            `Add \`customElements.define('<tag-name>', ${className});\` or <${kebab(className)}> tags won't upgrade.`,
-        );
-      }
-    }
+    // Invalidate the lazy analysis; the next request rebuilds the graph,
+    // component scan, gate, action index, middleware, elision, and vendor map.
+    // Wait out any in-flight build first so it cannot commit stale results
+    // after the reset. A dependency edit can flip an elision verdict without
+    // changing an importer's mtime, hence the TS_CACHE.clear above.
+    if (readyInFlight) { try { await readyInFlight; } catch {} }
+    // Bump the vendor generation so a vendor resolve still in flight from the
+    // previous build cannot flip vendorResolved against the fresh state.
+    vendorGen++;
+    analysisDone = false;
+    vendorResolved = false;
+    vendorAttemptedOnce = false;
+    readyDone = false;
+    readyError = null;
+    readinessFn = undefined; // reload readiness.{js,ts} after a rebuild
     opts.onReload?.();
   }
 
   /** @param {Request} req */
   function handle(req) {
     return withRequest(req, async () => {
+      // Health and readiness probes are answered BEFORE ensureReady so a probe
+      // never blocks on the analysis. `/__webjs/health` is liveness (the
+      // process is up and accepting connections). `/__webjs/ready` is 503 until
+      // the analysis is warm, then 200 unless an optional app readiness check
+      // (readiness.{js,ts}) reports a dependency down. So a readinessProbe holds
+      // traffic off a not-yet-warm or dependency-unhealthy instance. Probing
+      // `/__webjs/ready` also kicks off the warm in the background, so an
+      // embedder that never called warmup() still warms. A vendor CDN failure
+      // does NOT block readiness (vendor is best-effort, retried on the next request).
+      let probePath;
+      try { probePath = new URL(req.url).pathname; } catch { probePath = ''; }
+      if (probePath === '/__webjs/health') {
+        return Response.json({ status: 'ok' }, { headers: { 'cache-control': 'no-store' } });
+      }
+      if (probePath === '/__webjs/ready') {
+        const noStore = { 'cache-control': 'no-store' };
+        if (!readyDone) {
+          ensureReady().catch(() => {}); // drive the warm; never block the probe
+          const body = readyError
+            ? { status: 'error', error: String((readyError && readyError.message) || readyError) }
+            : { status: 'pending' };
+          return Response.json(body, { status: 503, headers: noStore });
+        }
+        // Analysis is warm. Consult the optional app readiness check (live
+        // dependency health, e.g. a DB ping) if the app provides one.
+        const check = await getReadinessCheck();
+        if (check) {
+          try {
+            if ((await check()) === false) {
+              return Response.json({ status: 'unready' }, { status: 503, headers: noStore });
+            }
+          } catch (e) {
+            return Response.json(
+              { status: 'unready', error: String((e && e.message) || e) },
+              { status: 503, headers: noStore },
+            );
+          }
+        }
+        return Response.json({ status: 'ok' }, { headers: noStore });
+      }
+      // Build all whole-app analysis on the first request (memoized), before
+      // any SSR, module serve, gate check, action dispatch, or middleware runs.
+      await ensureReady();
       const next = () => handleCore(req, { state, appDir, coreDir, dev });
       if (state.middleware) {
         try {
@@ -389,6 +511,21 @@ export async function createRequestHandler(opts) {
     handle,
     rebuild,
     routeFor,
+    /**
+     * Proactively run the first-request analysis (module graph, component
+     * scan, gate, action index, middleware, elision, vendor map) in the
+     * background, so a real first request finds it already memoized. Safe to
+     * call any number of times and concurrently: the work is single-flighted,
+     * so this never duplicates it or races a real request. It is a single
+     * best-effort kick: errors are caught and logged rather than thrown (a
+     * background warm-up must not crash the process), and whatever failed simply
+     * re-runs on the next request or readiness probe (the platform's traffic and
+     * probes are the retry loop, so there is no internal backoff). `startServer`
+     * calls this once the HTTP server is listening; embedders can call it after
+     * their own listen.
+     * @returns {Promise<void>}
+     */
+    warmup: () => ensureReady().catch((e) => logger.error?.(`[webjs] background warm-up failed (will retry on the next request):`, e)),
     /** current route table getter: used by the WebSocket subsystem */
     getRouteTable: () => state.routeTable,
     appDir,
@@ -533,6 +670,11 @@ export async function startServer(opts) {
 
   server.listen(port, () => {
     logger.info(`webjs ${dev ? 'dev' : 'prod'} server ready on http://localhost:${port}`);
+    // The server is now accepting connections; warm the first-request analysis
+    // in the background so a real first request finds it memoized. Fire-and-
+    // forget: listening (and thus readiness probes / load-balancer health) does
+    // not wait on it, and a failure here does not bring the process down.
+    app.warmup();
   });
 
   const shutdown = gracefulShutdown(server, sseClients, logger);
@@ -571,10 +713,8 @@ async function handleCore(req, ctx) {
   try { path = decodeURIComponent(url.pathname); } catch { path = url.pathname; }
   const method = req.method.toUpperCase();
 
-  // Health / readiness probes for orchestrators (k8s, fly, etc.)
-  if (path === '/__webjs/health' || path === '/__webjs/ready') {
-    return Response.json({ status: 'ok' }, { headers: { 'cache-control': 'no-store' } });
-  }
+  // Health / readiness probes (`/__webjs/health`, `/__webjs/ready`) are handled
+  // in `handle()` BEFORE ensureReady, so they are not repeated here.
 
   // Dev live-reload client
   if (path === '/__webjs/reload.js') {
@@ -712,8 +852,9 @@ async function handleCore(req, ctx) {
       // Server-file guardrail: a file matching `.server.{js,ts,mjs,mts}`
       // MUST NEVER be served as source to the browser. The extension is
       // the path-level boundary; we re-verify it on every request (not
-      // just the action-index snapshot taken at boot) so files created
-      // after boot, FS races, or developer error never punch through.
+      // just rely on the action-index snapshot, which is built on the first
+      // request and refreshed on rebuild) so files created later, FS races,
+      // or developer error never punch through.
       //
       // What the browser gets depends on the file's `'use server'` status:
       //   - With `'use server'` => server action: a generated RPC stub
@@ -1224,8 +1365,8 @@ function debounce(fn, ms) {
  * module graph into the full transitive closure.
  *
  * This is webjs's equivalent of Next.js's bundler-produced page
- * manifest, applied at boot time (and on every rebuild) instead of
- * compile time. The dev server's source-file branch uses the returned
+ * manifest, derived lazily on the first request (and re-derived on every
+ * rebuild) instead of at compile time. The dev server's source-file branch uses the returned
  * Set as an authorization gate: in-set → served (subject to the
  * .server.{js,ts} stub guardrail); out-of-set → 404.
  *
@@ -1245,7 +1386,7 @@ function debounce(fn, ms) {
  *
  * Components are passed in (rather than rescanned) so the caller can
  * share one scan with `primeComponentRegistry`. Saves a full
- * appDir walk at boot and on every rebuild.
+ * appDir walk on each analysis (the first request and every rebuild).
  *
  * @param {Awaited<ReturnType<typeof buildRouteTable>>} routeTable
  * @param {Awaited<ReturnType<typeof buildModuleGraph>>} moduleGraph

package/src/importmap.js

@@ -17,7 +17,8 @@ function escapeAttr(s) {
  * scanner discovers npm packages used by client code. The resolution
  * happens via `vendor.js`'s `resolveVendorImports`, which reads the
  * committed `.webjs/vendor/importmap.json` if present, else calls
- * `api.jspm.io/generate` once at boot. Browser fetches vendor packages
+ * `api.jspm.io/generate` once on the first request (memoized), never at
+ * boot. Browser fetches vendor packages
  * directly from jspm.io's CDN (default) or from local `/__webjs/vendor/`
  * paths (after `webjs vendor pin --download`).
  */
@@ -36,8 +37,8 @@ let _vendorIntegrity = {};
 /**
  * Merge additional vendor entries into the import map and precompute
  * the importmap-hash so `importMapHash()` can stay synchronous on the
- * per-request SSR hot path. Called by the dev server at boot and on
- * every vendor rebuild.
+ * per-request SSR hot path. Called from `ensureReady()` on the first
+ * request and on every vendor rebuild.
  *
  * @param {Record<string, string>} entries
  * @param {Record<string, string>} [integrity]  SRI hashes keyed by URL
@@ -64,8 +65,8 @@ export async function setVendorEntries(entries, integrity) {
  * the change and hard-reload before applying the swap.
  *
  * Synchronous accessor. The hash is precomputed eagerly inside
- * `setVendorEntries` (which the dev server `await`s during boot and
- * on every rebuild) so the per-request SSR hot path can return the
+ * `setVendorEntries` (which `ensureReady()` `await`s on the first request
+ * and on every rebuild) so the per-request SSR hot path can return the
  * cached string without crossing a Promise boundary.
  *
  * Returns an empty string if `setVendorEntries` has never run; the

package/src/module-graph.js

@@ -1,7 +1,7 @@
 /**
  * Lightweight module dependency graph.
  *
- * At startup, scans the app directory and builds an in-memory map of
+ * On the first request (lazily, via `ensureReady`), scans the app directory and builds an in-memory map of
  * `file → Set<imported files>`. The SSR pipeline queries this graph to
  * emit *complete* modulepreload hints: including transitive dependencies
  * of components: so the browser can fetch the entire tree in parallel
@@ -13,7 +13,7 @@
 
 import { readFile, readdir, stat } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
-import { join, resolve, dirname, extname } from 'node:path';
+import { join, resolve, dirname, extname, sep } from 'node:path';
 
 /** @type {RegExp} match static `import … from '…'` and `import '…'` */
 const IMPORT_RE = /\bimport\s+(?:(?:[\w*{}\s,]+)\s+from\s+)?['"]([^'"]+)['"]/g;
@@ -53,7 +53,18 @@ const EXPORT_FROM_RE = /\bexport\b[^'";]+?\sfrom\s+['"]([^'"]+)['"]/g;
 export async function buildModuleGraph(appDir) {
   /** @type {ModuleGraph} */
   const graph = new Map();
-  await walk(appDir, appDir, graph);
+  /** @type {Set<string>} every file walked this build (graph holds only files
+   * with deps, so a separate set is needed to know what is still live). */
+  const seen = new Set();
+  await walk(appDir, appDir, graph, seen);
+  // Evict parse-cache entries for files no longer in the tree (a rebuild after
+  // a rename or delete), so a long dev session does not accumulate dead
+  // entries. Scoped to appDir so a multi-app process (tests, dogfood smoke)
+  // keeps other apps' entries.
+  const prefix = appDir.endsWith(sep) ? appDir : appDir + sep;
+  for (const key of PARSE_CACHE.keys()) {
+    if ((key === appDir || key.startsWith(prefix)) && !seen.has(key)) PARSE_CACHE.delete(key);
+  }
   return graph;
 }
 
@@ -173,7 +184,7 @@ export function reachableFromEntries(graph, entryFiles, appDir) {
  * @param {string} appDir
  * @param {ModuleGraph} graph
  */
-async function walk(dir, appDir, graph) {
+async function walk(dir, appDir, graph, seen) {
   let entries;
   try { entries = await readdir(dir, { withFileTypes: true }); }
   catch { return; }
@@ -191,13 +202,28 @@ async function walk(dir, appDir, graph) {
     if (e.name.startsWith('.')) continue;
     const full = join(dir, e.name);
     if (e.isDirectory()) {
-      await walk(full, appDir, graph);
+      await walk(full, appDir, graph, seen);
     } else if (/\.(js|ts|mjs|mts)$/.test(e.name)) {
-      await parseFile(full, appDir, graph);
+      await parseFile(full, appDir, graph, seen);
     }
   }
 }
 
+/**
+ * mtime-keyed parse cache so a rebuild re-reads only files that actually
+ * changed. `buildModuleGraph` re-walks the (cheap) directory tree on every
+ * rebuild, but reading + regex-parsing each file is the cost; on an unchanged
+ * file the cached import set is reused after a single `stat`. This makes
+ * rebuilds incremental for large apps without restructuring the caller.
+ * Keyed by mtime AND size: a same-tick edit that also changes the file length
+ * is caught even on coarse-resolution filesystems where mtime alone could miss.
+ * @type {Map<string, { mtimeMs: number, size: number, deps: Set<string> }>}
+ */
+const PARSE_CACHE = new Map();
+
+/** Introspection for tests/ops: is `file` currently in the parse cache? */
+export function _parseCacheHas(file) { return PARSE_CACHE.has(file); }
+
 /**
  * Parse a single file's imports and add them to the graph.
  * Only resolves relative imports (bare specifiers are npm deps, not in the graph).
@@ -206,7 +232,17 @@ async function walk(dir, appDir, graph) {
  * @param {string} appDir
  * @param {ModuleGraph} graph
  */
-async function parseFile(file, appDir, graph) {
+async function parseFile(file, appDir, graph, seen) {
+  let mtimeMs, size;
+  try { const st = await stat(file); mtimeMs = st.mtimeMs; size = st.size; }
+  catch { return; }
+  seen?.add(file); // mark live (both cache-hit and miss paths) for cache eviction
+  const cached = PARSE_CACHE.get(file);
+  if (cached && cached.mtimeMs === mtimeMs && cached.size === size) {
+    if (cached.deps.size) graph.set(file, cached.deps);
+    return;
+  }
+
   let src;
   try { src = await readFile(file, 'utf8'); }
   catch { return; }
@@ -221,6 +257,7 @@ async function parseFile(file, appDir, graph) {
       if (resolved) deps.add(resolved);
     }
   }
+  PARSE_CACHE.set(file, { mtimeMs, size, deps });
   if (deps.size) graph.set(file, deps);
 }
 

package/src/vendor.js

@@ -25,11 +25,12 @@
  * returns metadata, not JavaScript. The correct entry file (e.g.,
  * `/dayjs.min.js`, `/index.js`) varies per package and must be
  * resolved from the JSPM Generator API. The Generator is called once
- * per server boot for the full set of bare imports; results are
+ * on the first request for the full set of bare imports; results are
  * cached in-memory for the process lifetime.
  *
- * Server boot connectivity: the Generator API call happens during
- * `setVendorEntries` at boot. If api.jspm.io is unreachable, the
+ * Connectivity: the Generator API call happens on the first request,
+ * inside `ensureReady` via `setVendorEntries`, never at boot. If
+ * api.jspm.io is unreachable, the
  * importmap will be missing vendor entries and the browser will
  * report "unresolved bare specifier" errors. The server itself still
  * boots and serves user routes; only vendor-importing pages break
@@ -269,6 +270,14 @@ export function getPackageVersion(pkgName, appDir) {
  */
 const jspmCache = new Map();
 
+// Set by jspmResolveOne whenever a LIVE resolution attempt fails (network
+// error, timeout, or a non-ok jspm response). resolveVendorImports resets it
+// before a scan and reads it after, so a caller can tell "resolved cleanly"
+// from "served a partial map because the CDN was unreachable" and avoid
+// memoizing the failure as done. Safe under the single-flighted ensureReady
+// (one live resolve at a time); the vendor CLI does not run alongside a server.
+let lastLiveResolveFailed = false;
+
 const JSPM_GENERATE_ENDPOINT = 'https://api.jspm.io/generate';
 const JSPM_GENERATE_TIMEOUT_MS = 10_000;
 
@@ -362,6 +371,13 @@ async function jspmResolveOne(install, provider = 'jspm') {
           `[webjs] could not vendor '${install}' via ${provider} (status ${response.status})${detail}`,
         );
         jspmCache.delete(cacheKey);
+        // A 5xx/429 is a transient jspm problem worth retrying. A 401/4xx means
+        // the install is genuinely unresolvable (jspm uses 401 for that): a
+        // private / workspace / server-only package (e.g. @webjsdev/server,
+        // @prisma/client) the browser never fetches anyway. That is tolerated
+        // exactly as before and must NOT block readiness, or an app with any
+        // such dep would never become ready.
+        if (response.status >= 500 || response.status === 429) lastLiveResolveFailed = true;
         return {};
       }
       const result = await response.json();
@@ -372,6 +388,7 @@ async function jspmResolveOne(install, provider = 'jspm') {
         : `${e && e.message}`;
       console.error(`[webjs] could not vendor '${install}' via ${provider}: ${msg}`);
       jspmCache.delete(cacheKey);
+      lastLiveResolveFailed = true;
       return {};
     } finally {
       clearTimeout(timer);
@@ -411,7 +428,8 @@ export async function jspmGenerate(installs, provider = 'jspm') {
  * api.jspm.io/generate for the full importmap fragment.
  *
  * Async because the Generator API call is networked. Called from
- * `setVendorEntries` during server boot and rebuild; not per request.
+ * `resolveVendorImports` on the first request (and after a rebuild),
+ * inside `ensureReady`; never at boot, and not on every request.
  *
  * @param {Set<string>} bareImports  from scanBareImports()
  * @param {string} appDir
@@ -1257,8 +1275,8 @@ function maxSemverVersion(versions) {
 
 /**
  * Resolve the vendor importmap fragment for runtime use. Prefers the
- * committed pin file over a live api.jspm.io call. Called by dev.js
- * at server boot.
+ * committed pin file over a live api.jspm.io call. Called from
+ * `ensureReady()` in dev.js on the first request, never at boot.
  *
  * Order of preference:
  *   1. `.webjs/vendor/importmap.json` (committed; no network needed)
@@ -1270,17 +1288,29 @@ function maxSemverVersion(versions) {
  * hash, defeating the live-mode speed advantage. Users who want SRI
  * run `webjs vendor pin`).
  *
- * @param {Set<string>} bareImports
  * @param {string} appDir
+ * @param {() => Promise<Set<string>>} getBareImports lazy scan, invoked ONLY
+ *   on the unpinned path (so a pinned app never pays the whole-app walk).
  * @returns {Promise<{ imports: Record<string, string>, integrity: Record<string, string> }>}
  */
-export async function resolveVendorImports(bareImports, appDir) {
+export async function resolveVendorImports(appDir, getBareImports) {
   const file = await readPinFile(appDir);
+  // A committed pin file IS the import map. The whole-app bare-import scan is
+  // discarded in that case, so it must never run (runtime-first boot: no
+  // static analysis when pinned). The scan is supplied as a thunk and invoked
+  // solely here, only when there is no pin file.
   if (file) {
-    return { imports: file.imports, integrity: file.integrity || {} };
+    // A pin file is a deterministic disk read: always "ok" (no live CDN call
+    // that could partially fail). This is the recommended prod posture.
+    return { imports: file.imports, integrity: file.integrity || {}, ok: true };
   }
+  lastLiveResolveFailed = false;
+  const bareImports = await getBareImports();
   const imports = await vendorImportMapEntries(bareImports, appDir);
-  return { imports, integrity: {} };
+  // ok=false means at least one install could not be resolved (CDN unreachable
+  // / timeout / non-ok), so `imports` is partial. The caller must not memoize
+  // this as done; it should retry once the CDN recovers.
+  return { imports, integrity: {}, ok: !lastLiveResolveFailed };
 }
 
 /**