@webjsdev/server 0.8.28 → 0.8.29

package/package.json

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

package/src/action-seed-bun.js

@@ -0,0 +1,67 @@
+/**
+ * Bun install for SSR action-result seeding (#472, #529).
+ *
+ * Bun has no `module.registerHooks`, so the seed facade is installed via a
+ * `Bun.plugin` `onLoad`, the Bun analog of the Node load hook in
+ * `action-seed.js`. This module is dynamically imported by `registerSeedHooks`
+ * ONLY when `serverRuntime()` is `'bun'`, so the `Bun.*` global is never
+ * referenced on Node (the same isolation as `listener-bun.js`).
+ *
+ * The faceting DECISION (`isSeedCandidate`) and the facade SOURCE
+ * (`buildSeedFacade`) are the shared, runtime-neutral helpers passed in, so Node
+ * and Bun emit byte-identical facades that feed the same `AsyncLocalStorage`
+ * collector. The only Bun-specific glue here is the plugin shell + reading the
+ * source via `Bun.file`.
+ *
+ * Bun's `onLoad` `args.path` includes any query (verified), so the facade's
+ * `?webjs-seed-orig` passthrough and a dev `?t=` re-import are both seen, exactly
+ * like the Node hook's URL.
+ *
+ * UNLIKE Node's hook, a Bun `onLoad` registered for a filter MUST return a
+ * `{ contents, loader }` object for EVERY match; returning `undefined` to defer
+ * to the default loader is an error ("onLoad() expects an object returned"). So
+ * the non-facet cases (the `?webjs-seed-orig` passthrough, a `.server.*` with no
+ * `'use server'`, an unenumerable `export *`) are handled by reading and
+ * RETURNING the real source ourselves with the extension's loader, which is the
+ * same module Bun would have loaded.
+ */
+
+/**
+ * Install the `Bun.plugin` seed `onLoad`. Idempotency is the caller's
+ * responsibility (`registerSeedHooks` guards on `_registered`).
+ *
+ * @param {{
+ *   isSeedCandidate: (specifier: string) => boolean,
+ *   buildSeedFacade: (origSpec: string, absPath: string, src: string) => (string | null),
+ *   serverFileRe: RegExp,
+ * }} helpers
+ */
+export function installBunSeedPlugin({ isSeedCandidate, buildSeedFacade, serverFileRe }) {
+  Bun.plugin({
+    name: 'webjs-action-seed',
+    setup(build) {
+      // The filter is a cheap path pre-screen (`*.server.*`, optional query).
+      build.onLoad({ filter: serverFileRe }, async (args) => {
+        const absPath = args.path.split('?')[0];
+        // `.ts` / `.mts` strip via the `ts` loader; `.js` / `.mjs` via `js`.
+        const loader = /\.m?ts$/.test(absPath) ? 'ts' : 'js';
+        // Read the real source. A genuine read failure (missing file) propagates,
+        // which Bun reports as a load error exactly as it would without the plugin.
+        const src = await Bun.file(absPath).text();
+        try {
+          // Facet only a `'use server'` candidate (not the `?webjs-seed-orig`
+          // passthrough); a non-candidate or a passthrough falls through to the
+          // raw source below.
+          if (isSeedCandidate(args.path)) {
+            const source = buildSeedFacade(args.path, absPath, src);
+            if (source != null) return { contents: source, loader: 'js' };
+          }
+        } catch {
+          // Fail-open: any faceting error serves the raw source (no seeding for
+          // this module), the Bun analog of the Node hook's `nextLoad` fallback.
+        }
+        return { contents: src, loader };
+      });
+    },
+  });
+}

package/src/action-seed.js

@@ -18,11 +18,18 @@
  * The framework promise is "what you write is what you see in the browser source
  * tab", not "what you write is the exact function object that runs server-side"
  * (the RPC stub already replaces the action on the client). So we install a
- * SERVER-SIDE transparent facade via Node's synchronous `module.registerHooks`
- * (Node 24+, main-thread): for a `'use server'` `*.server.*` module, the load
- * hook returns a facade that re-exports each function wrapped in a `Proxy`. The
- * Proxy records `(file, fn, args) -> result` into an ambient `AsyncLocalStorage`
- * collector WHENEVER a collector is active, and is a pure passthrough otherwise.
+ * SERVER-SIDE transparent facade at module load: for a `'use server'`
+ * `*.server.*` module, the load hook returns a facade that re-exports each
+ * function wrapped in a `Proxy`. The Proxy records `(file, fn, args) -> result`
+ * into an ambient `AsyncLocalStorage` collector WHENEVER a collector is active,
+ * and is a pure passthrough otherwise.
+ *
+ * The facade SOURCE and the wrapping (`__seedWrap`, `buildSeedFacade`) are
+ * runtime-neutral; only the INSTALL mechanism differs by runtime (`#529`), chosen
+ * by `serverRuntime()`: Node uses the synchronous `module.registerHooks` load
+ * hook (Node 24+, main-thread); Bun uses a `Bun.plugin` `onLoad` (Bun has no
+ * `module.registerHooks`). Both feed the same `AsyncLocalStorage` collector and
+ * emit the same seed wire, so a page seeds identically on either runtime.
  *
  * Recording is gated entirely by the ALS collector, which is established ONLY
  * around the SSR page render (`collectSeeds`). The RPC endpoint path runs with
@@ -48,6 +55,7 @@ import { fileURLToPath } from 'node:url';
 import { stringify } from '@webjsdev/core';
 import { hashFile } from './actions.js';
 import { isStreamable } from './action-stream.js';
+import { serverRuntime } from './listener-core.js';
 
 /** Ambient per-render seed collector. `Map<key, value>` or undefined. */
 const als = new AsyncLocalStorage();
@@ -205,6 +213,17 @@ function buildFacade(origUrl, absPath, exports) {
   const file = JSON.stringify(absPath);
   let out = `import * as __orig from ${origSpec};\n`;
   out += `import { __seedWrap as __w } from ${JSON.stringify(SELF_URL)};\n`;
+  // Fail-open catch-all (#535). Re-export every named binding of the real module.
+  // An explicit `export const NAME = __w(...)` below SHADOWS the matching star
+  // binding (an explicit export wins over a star re-export of the same name, with
+  // no SyntaxError), so an enumerated export is still wrapped and seeded. A named
+  // export the `extractExportNames` regex MISSED (exotic syntax, an unusual
+  // re-export form, a codegen-produced export) is NOT enumerated below, so it
+  // flows through this star unwrapped: it resolves and works over a normal RPC,
+  // just is not seeded, instead of being dropped and crashing the importer with
+  // `undefined`. `export *` does not carry `default`, which the explicit default
+  // line below still handles.
+  out += `export * from ${origSpec};\n`;
   for (const n of exports.names) {
     const k = JSON.stringify(n);
     out += `export const ${n} = __w(${file}, ${k}, __orig[${k}]);\n`;
@@ -215,13 +234,46 @@ function buildFacade(origUrl, absPath, exports) {
   return out;
 }
 
-/** Match `*.server.{js,ts,mjs,mts}` (optionally with a query). */
-const SERVER_FILE_RE = /\.server\.m?[jt]s(\?|$)/;
+/** Match `*.server.{js,ts,mjs,mts}` (optionally with a query). Also the Bun plugin filter. */
+export const SERVER_FILE_RE = /\.server\.m?[jt]s(\?|$)/;
 /** The `'use server'` directive in the file head. */
 const USE_SERVER_RE = /^\s*(['"])use server\1\s*;?\s*$/m;
 
 /**
- * The synchronous `module.registerHooks` load hook. For a `'use server'`
+ * Whether a load specifier (a Node file URL or a Bun file path, with an optional
+ * query) is a faceting candidate: a `*.server.*` module that is NOT the facade's
+ * own `?webjs-seed-orig` passthrough of the real module. Runtime-neutral.
+ * @param {string} specifier
+ * @returns {boolean}
+ */
+export function isSeedCandidate(specifier) {
+  return SERVER_FILE_RE.test(specifier) && !specifier.includes('webjs-seed-orig');
+}
+
+/**
+ * Build the wrapping facade for a candidate module's source, or null to pass it
+ * through unwrapped (no `'use server'`, a non-enumerable `export *`, or no
+ * exports). Runtime-neutral: the caller passes the load specifier (URL on Node,
+ * path on Bun) used as the facade's `?webjs-seed-orig` import base, plus the
+ * absolute file path (the hash basis) and the already-read source.
+ * @param {string} origSpec the real module's load specifier (URL or path), no seed query
+ * @param {string} absPath the real module's absolute file path
+ * @param {string} src the module source
+ * @returns {string | null} facade source, or null for passthrough
+ */
+export function buildSeedFacade(origSpec, absPath, src) {
+  const head = src.split('\n').slice(0, 5).join('\n');
+  if (!USE_SERVER_RE.test(head)) return null;
+  const exports = extractExportNames(src);
+  // A `export *` re-export cannot be enumerated; skip faceting (passthrough)
+  // so we never emit a facade that silently drops re-exported bindings.
+  if (exports.hasStar) return null;
+  if (exports.names.length === 0 && !exports.hasDefault) return null;
+  return buildFacade(origSpec, absPath, exports);
+}
+
+/**
+ * The synchronous `module.registerHooks` load hook (Node). For a `'use server'`
  * `*.server.*` module it returns a wrapping facade; for everything else
  * (including the `?webjs-seed-orig` passthrough of the real module) it defers to
  * `nextLoad`. Fail-open: any error defers to `nextLoad`, so a load that the hook
@@ -232,19 +284,11 @@ const USE_SERVER_RE = /^\s*(['"])use server\1\s*;?\s*$/m;
  */
 function seedLoadHook(url, context, nextLoad) {
   try {
-    if (!SERVER_FILE_RE.test(url)) return nextLoad(url, context);
-    // The facade's own `?webjs-seed-orig` import must load the REAL module.
-    if (url.includes('webjs-seed-orig')) return nextLoad(url, context);
+    if (!isSeedCandidate(url)) return nextLoad(url, context);
     const absPath = fileURLToPath(url.split('?')[0]);
     const src = readFileSync(absPath, 'utf8');
-    const head = src.split('\n').slice(0, 5).join('\n');
-    if (!USE_SERVER_RE.test(head)) return nextLoad(url, context);
-    const exports = extractExportNames(src);
-    // A `export *` re-export cannot be enumerated; skip faceting (passthrough)
-    // so we never emit a facade that silently drops re-exported bindings.
-    if (exports.hasStar) return nextLoad(url, context);
-    if (exports.names.length === 0 && !exports.hasDefault) return nextLoad(url, context);
-    const source = buildFacade(url, absPath, exports);
+    const source = buildSeedFacade(url, absPath, src);
+    if (source == null) return nextLoad(url, context);
     return { source, format: 'module', shortCircuit: true };
   } catch {
     return nextLoad(url, context);
@@ -253,27 +297,36 @@ function seedLoadHook(url, context, nextLoad) {
 
 /**
  * Install the seed load hook (idempotent). Called once at boot from `dev.js`
- * when seeding is enabled, BEFORE any action module is imported (ESM caches by
- * URL, so a module loaded before the hook would never be faceted). A no-op on a
- * second call.
+ * when seeding is enabled, BEFORE any action module is imported (a module loaded
+ * before the hook would already be cached unwrapped). The install mechanism is
+ * chosen by `serverRuntime()` (#529): Node's synchronous `module.registerHooks`,
+ * or a `Bun.plugin` `onLoad` on Bun. A no-op on a second call. Async because the
+ * Bun path dynamically imports `action-seed-bun.js` (so the `Bun.*` global is
+ * never referenced on Node); the Node path resolves synchronously.
+ * @returns {Promise<void>}
  */
-export function registerSeedHooks() {
-  // The seed facade rides Node's synchronous `module.registerHooks` (#472).
-  // Bun (and any runtime without that API, #508) cannot install the hook, so
-  // seeding simply stays OFF there: `seedingEnabled()` returns false, ssr.js
-  // emits no seed block, and the client RPC stub falls back to a normal fetch.
-  // This is the same fail-open posture as a key miss, never wrong data.
+export async function registerSeedHooks() {
+  if (_registered) return;
+  _registered = true;
+
+  if (serverRuntime() === 'bun') {
+    // Bun has no module.registerHooks; install the same facade via Bun.plugin.
+    const { installBunSeedPlugin } = await import('./action-seed-bun.js');
+    installBunSeedPlugin({ isSeedCandidate, buildSeedFacade, serverFileRe: SERVER_FILE_RE });
+    _enabled = true;
+    return;
+  }
+
+  // A runtime that is neither Node-with-registerHooks nor Bun: seeding stays
+  // OFF (fail-open). `seedingEnabled()` is false, ssr.js emits no seed block,
+  // and the client RPC stub falls back to a normal fetch. Never wrong data.
   if (typeof nodeModule.registerHooks !== 'function') {
-    if (!_registered) {
-      _registered = true;
-      console.warn('[webjs] SSR action-result seeding (#472) is disabled: module.registerHooks is unavailable on this runtime (e.g. Bun). Async-render components will re-fetch on hydration; no correctness impact.');
-    }
+    console.warn('[webjs] SSR action-result seeding (#472) is disabled: this runtime has neither module.registerHooks nor Bun.plugin. Async-render components re-fetch on hydration; no correctness impact.');
     return;
   }
-  _enabled = true;
-  if (_registered) return;
-  _registered = true;
+
   nodeModule.registerHooks({ load: seedLoadHook });
+  _enabled = true;
 }
 
 /**

package/src/dev.js

@@ -508,7 +508,7 @@ export async function createRequestHandler(opts) {
   // Read once (not per-rebuild): the hook is global and cannot be cleanly
   // un-installed, so toggling needs a restart. Disabled -> no hook, no ambient
   // collector wrap in ssr.js, and module loading stays byte-identical.
-  if (await readSeedEnabled(appDir)) registerSeedHooks();
+  if (await readSeedEnabled(appDir)) await registerSeedHooks();
 
   // When an app commits a vendor pin (.webjs/vendor/importmap.json) it carries a
   // deterministic vendor map that is cheap to read (one file, no analysis, no