dinou 7.1.0 → 7.3.0

package/CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [7.3.0]
+
+### Added
+- **Universal Setup Files & Environment Polyfills**:
+  - Early-stage execution guarantee: Setup scripts are injected at Line 1 of all compilation bundles before any module imports or engine code run, enabling browser/canvas polyfills (`DOMMatrix`, `ImageData`, `Path2D`) and APM/telemetry agents without ejecting.
+  - Unified configuration hierarchy: `plugin.setupFiles` (plugins run first) -> explicit `setupFiles: [...]` in `dinou.config.*` (strict source of truth; replaces convention) -> zero-config root convention `./dinou.setup.(mjs|js|ts)`.
+  - Comprehensive multi-platform support: Injected uniformly across Node.js (`Pass A`, `Pass B`, `Pass C`), Bun native AOT, Cloudflare Workers, Deno / Deno Deploy, Static Site Generation (SSG), and Hot-Reload Dev Server.
+  - Added TypeScript definitions for `setupFiles?: string[]` in both `DinouConfig` and `DinouPlugin`.
+
+### Fixed
+- **Bun Standalone Compilation Port Collision (`EADDRINUSE`)**:
+  - Resolved port binding conflict when compiling the Node.js orchestrator into a standalone executable using `bun build --compile`.
+  - Separated exports in `.dinou/node/server.mjs`: `fetch` is now exported exclusively as a named export (`export { fetch }`), while `export default` exposes `{ port, startServer }`, preventing Bun's runtime from launching a duplicate background `Bun.serve` instance over Node's `http.createServer()`.
+  - Robust `isMain` execution detection supporting both Node.js (`process.argv[1]`) and compiled Bun binaries (`import.meta.main`).
+
+## [7.2.0]
+
+### Added
+- **Plugin Hook `configureServer`**: Attach WebSockets (Socket.IO, WS) and native Node.js HTTP middlewares before server startup without ejecting.
+- **Node Standalone Binary Compilation**: Added `dinou build:node:compile` and cross-compilation matrix (`:linux`, `:linux_arm`, `:mac`, `:win`).
+- **Client-Side Server Function Auth Hooks**: Added `window.__DINOU_SERVER_FUNCTION_HEADERS__` and `window.__DINOU_GET_AUTH_TOKEN__` to inject dynamic JWT/Bearer authorization headers into `"use server"` calls.
+- **Esbuild-Powered Config Loader**: `dinou.config.*` is automatically pre-bundled with Esbuild, enabling native `tsconfig.json` path aliases (`@/*`) and TypeScript configuration files out of the box.
+
+### Changed
+- Removed legacy `babel-esm-loader.js` and cleaned up residual loader registrations.
+
 ## [7.1.0] - 2026-10-16
 
 ### Added

package/README.md

@@ -1,6 +1,6 @@
 # **Dinou**
 
-[![Documentation](https://img.shields.io/badge/docs-dinou.dev-blue?style=flat-square)](https://dinou.dev) [![Version](https://img.shields.io/badge/version-7.0.0-orange?style=flat-square)](https://www.npmjs.com/package/dinou)
+[![Documentation](https://img.shields.io/badge/docs-dinou.dev-blue?style=flat-square)](https://dinou.dev) [![Version](https://img.shields.io/badge/version-7.3.0-orange?style=flat-square)](https://www.npmjs.com/package/dinou)
 
 ### **Full-Stack React 19 Framework**
 

package/cli.js

@@ -121,6 +121,91 @@ program
     runCommand(`cross-env NODE_ENV=production DINOU_BUILD_TOOL=webpack node ${p("adapters/node.mjs")}`);
   });
 
+// --- NODE (COMPILE VIA BUN) ---
+
+const nodeTargets = [
+  { name: "", flags: "", outfile: "dist/server" },
+  { name: ":linux", flags: "--target=bun-linux-x64 ", outfile: "dist/server-linux" },
+  { name: ":linux_arm", flags: "--target=bun-linux-arm64 ", outfile: "dist/server-linux-arm" },
+  { name: ":mac", flags: "--target=bun-darwin-arm64 ", outfile: "dist/server-mac" },
+  { name: ":win", flags: "--target=bun-windows-x64 ", outfile: "dist/server-win" },
+];
+
+const runNodeBuild = (bundler) => {
+  const bundlerCmd = bundler === "rollup"
+    ? `cross-env NODE_ENV=production npx rollup -c ${p("rollup/rollup.config.js")}`
+    : bundler === "webpack"
+    ? `cross-env NODE_ENV=production npx webpack --config ${p("webpack/webpack.config.js")}`
+    : `cross-env NODE_ENV=production node ${p("esbuild/build.mjs")}`;
+
+  const envPrefix = bundler === "webpack" ? "cross-env DINOU_BUILD_TOOL=webpack " : "";
+  return `${bundlerCmd} && ${envPrefix}node ${p("node/build.mjs")}`;
+};
+
+for (const t of nodeTargets) {
+  for (const b of ["esbuild", "rollup", "webpack"]) {
+    const cmdNames = b === "esbuild"
+      ? [`build:node:compile${t.name}`, `build:node:compile${t.name}:esbuild`]
+      : [`build:node:compile${t.name}:${b}`];
+    for (const cmdName of cmdNames) {
+      program
+        .command(cmdName)
+        .description(`Compile standalone Node.js server executable with Bun (${t.name || "host"}, ${b})`)
+        .action(() => {
+          runCommand(`${runNodeBuild(b)} && bun build --compile ${t.flags}.dinou/node/server.mjs --outfile ${t.outfile}`);
+        });
+    }
+  }
+}
+
+// --- NODE (PURE BUN RUNNER COMPILE) ---
+
+const runNodePureBuild = (bundler) => {
+  if (bundler === "rollup") {
+    return `cross-env NODE_ENV=production npx rollup -c ${p("rollup/rollup.config.js")} && bun ${p("node/build.mjs")}`;
+  }
+  if (bundler === "webpack") {
+    return `cross-env NODE_ENV=production npx webpack --config ${p("webpack/webpack.config.js")} && cross-env DINOU_BUILD_TOOL=webpack bun ${p("node/build.mjs")}`;
+  }
+  return `cross-env NODE_ENV=production bun ${p("esbuild/build.mjs")} && bun ${p("node/build.mjs")}`;
+};
+
+program
+  .command("build:node:pure")
+  .description("Build the app for Node.js with 100% Bun (using esbuild)")
+  .action(() => { runCommand(runNodePureBuild("esbuild")); });
+
+program
+  .command("build:node:pure:esbuild")
+  .description("Build the app for Node.js with 100% Bun (Esbuild)")
+  .action(() => { runCommand(runNodePureBuild("esbuild")); });
+
+program
+  .command("build:node:pure:rollup")
+  .description("Build the app for Node.js with 100% Bun (Rollup)")
+  .action(() => { runCommand(runNodePureBuild("rollup")); });
+
+program
+  .command("build:node:pure:webpack")
+  .description("Build the app for Node.js with 100% Bun (Webpack)")
+  .action(() => { runCommand(runNodePureBuild("webpack")); });
+
+for (const t of nodeTargets) {
+  for (const b of ["esbuild", "rollup", "webpack"]) {
+    const cmdNames = b === "esbuild"
+      ? [`build:node:pure:compile${t.name}`, `build:node:pure:compile${t.name}:esbuild`]
+      : [`build:node:pure:compile${t.name}:${b}`];
+    for (const cmdName of cmdNames) {
+      program
+        .command(cmdName)
+        .description(`Compile standalone Node.js server executable with 100% Bun (${t.name || "host"}, ${b})`)
+        .action(() => {
+          runCommand(`${runNodePureBuild(b)} && bun build --compile ${t.flags}.dinou/node/server.mjs --outfile ${t.outfile}`);
+        });
+    }
+  }
+}
+
 // --- CLOUDFLARE WORKERS ---
 
 program

package/dinou/adapters/netlify.js

@@ -3,21 +3,9 @@
 // Automatically routes all requests to Dinou's universal Web Standards handler.
 Object.assign(process.env, { NODE_ENV: "production" });
 
-import { register } from "node:module";
-import { pathToFileURL } from "node:url";
 import path from "node:path";
 import Module from "node:module";
 
-import { dinouCoreDir } from "../core/dinou-paths.js";
-
-if (typeof register === "function") {
-  try {
-    const loaderPath = path.join(dinouCoreDir, "babel-esm-loader.js");
-    register(pathToFileURL(loaderPath).href, pathToFileURL("./"));
-  } catch (e) {
-    console.error("[Dinou Adapter] Loader registration failed:", e);
-  }
-}
 
 let reactServerPath, reactDomServerPath, reactJsxRuntimePath, reactJsxDevRuntimePath;
 let roggcServerNodePath, webpackServerNodePath;
@@ -30,17 +18,17 @@ try {
 
   const reactDomPkgJson = require.resolve("react-dom/package.json");
   reactDomServerPath = path.join(path.dirname(reactDomPkgJson), "react-dom.react-server.js");
-} catch (e) {}
+} catch (e) { }
 
 try {
   const roggcPkgJson = require.resolve("@roggc/react-server-dom-esm/package.json");
   roggcServerNodePath = path.join(path.dirname(roggcPkgJson), "server.node.js");
-} catch (e) {}
+} catch (e) { }
 
 try {
   const webpackPkgJson = require.resolve("react-server-dom-webpack/package.json");
   webpackServerNodePath = path.join(path.dirname(webpackPkgJson), "server.node.js");
-} catch (e) {}
+} catch (e) { }
 
 if (Module && Module._resolveFilename) {
   const originalResolveFilename = Module._resolveFilename;

package/dinou/bun/build.mjs

@@ -19,11 +19,19 @@ const {
   isSupportedClientModule,
   scanProjectDependenciesForClientComponents,
 } = require("../core/scan-dependency-components.js");
+const { getDinouConfig } = require("../core/load-dinou-config.js");
+const { resolveSetupFiles } = require("../core/resolve-setup-files.js");
 
 const projectRoot = process.cwd();
 const bunDir = path.resolve(projectRoot, ".dinou/bun");
 fs.mkdirSync(bunDir, { recursive: true });
 
+const dinouConfig = await getDinouConfig(projectRoot);
+const setupFiles = resolveSetupFiles(projectRoot, dinouConfig);
+if (setupFiles.length > 0) {
+  console.log(`  🔌 [Dinou Setup] Active setup files (${setupFiles.length}): ${setupFiles.map((f) => path.basename(f)).join(", ")}`);
+}
+
 try {
   generateRouteTypes(projectRoot);
 } catch (e) {}
@@ -1012,6 +1020,7 @@ try {
     alias: commonAlias,
     loader: commonLoader,
     jsx: "automatic",
+    inject: setupFiles.length > 0 ? setupFiles : undefined,
     define: {
       "process.env.NODE_ENV": '"production"',
       "process.env.DINOU_RUNTIME": '"bun-bundle"',
@@ -1035,6 +1044,7 @@ try {
     alias: commonAlias,
     loader: commonLoader,
     jsx: "automatic",
+    inject: setupFiles.length > 0 ? setupFiles : undefined,
     define: {
       "process.env.NODE_ENV": '"production"',
       "process.env.DINOU_RUNTIME": '"bun-bundle"',
@@ -1056,6 +1066,7 @@ try {
     conditions: ["bun", "worker", "browser"],
     external: externalList,
     banner,
+    inject: setupFiles.length > 0 ? setupFiles : undefined,
     alias: commonAlias,
     loader: commonLoader,
     define: {

package/dinou/cloudflare/build.mjs

@@ -19,11 +19,19 @@ const {
   isSupportedClientModule,
   scanProjectDependenciesForClientComponents,
 } = require("../core/scan-dependency-components.js");
+const { getDinouConfig } = require("../core/load-dinou-config.js");
+const { resolveSetupFiles } = require("../core/resolve-setup-files.js");
 
 const projectRoot = process.cwd();
 const cloudflareDir = path.resolve(projectRoot, ".dinou/cloudflare");
 fs.mkdirSync(cloudflareDir, { recursive: true });
 
+const dinouConfig = await getDinouConfig(projectRoot);
+const setupFiles = resolveSetupFiles(projectRoot, dinouConfig);
+if (setupFiles.length > 0) {
+  console.log(`  🔌 [Dinou Setup] Active setup files (${setupFiles.length}): ${setupFiles.map((f) => path.basename(f)).join(", ")}`);
+}
+
 try {
   generateRouteTypes(projectRoot);
 } catch (e) {}
@@ -819,6 +827,7 @@ const commonAlias = {
   "@": path.resolve(projectRoot, "src"),
   "dinou/config": path.resolve(dinouDir, "core/config.js"),
   dinou: dinouDir,
+  esbuild: path.resolve(shimsDir, "empty.js"),
   fs: path.resolve(shimsDir, "fs.js"),
   "node:fs": path.resolve(shimsDir, "fs.js"),
   "fs/promises": path.resolve(shimsDir, "fs.js"),
@@ -1056,6 +1065,7 @@ try {
     alias: commonAlias,
     loader: commonLoader,
     jsx: "automatic",
+    inject: setupFiles.length > 0 ? setupFiles : undefined,
     define: {
       "process.env.NODE_ENV": '"production"',
       "process.env.DINOU_RUNTIME": '"edge"',
@@ -1079,6 +1089,7 @@ try {
     alias: commonAlias,
     loader: commonLoader,
     jsx: "automatic",
+    inject: setupFiles.length > 0 ? setupFiles : undefined,
     define: {
       "process.env.NODE_ENV": '"production"',
       "process.env.DINOU_RUNTIME": '"edge"',
@@ -1100,6 +1111,7 @@ try {
     conditions: ["workerd", "worker", "browser"],
     external: externalList,
     banner,
+    inject: setupFiles.length > 0 ? setupFiles : undefined,
     alias: commonAlias,
     loader: commonLoader,
     define: {

package/dinou/core/load-dinou-config.js

@@ -1,5 +1,5 @@
 const path = require("path");
-const { existsSync } = require("fs");
+const { existsSync, mkdirSync } = require("fs");
 const { pathToFileURL } = require("url");
 
 let dinouConfig = { plugins: [] };
@@ -12,13 +12,45 @@ async function getDinouConfig() {
   if (dinouConfigPromise) return dinouConfigPromise;
   dinouConfigPromise = (async () => {
     const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : ".";
-    for (const filename of ["dinou.config.js", "dinou.config.mjs", "dinou.config.cjs", "dinou.config.ts"]) {
+    for (const filename of ["dinou.config.ts", "dinou.config.mjs", "dinou.config.js", "dinou.config.cjs"]) {
       const p = path.resolve(cwd, filename);
       if (existsSync(p)) {
         try {
           let loaded;
           const isDev = process.env.NODE_ENV !== "production";
-          if (p.endsWith(".mjs")) {
+          let esbuild;
+          if (
+            typeof process !== "undefined" &&
+            process.versions &&
+            process.versions.node &&
+            process.env.DINOU_RUNTIME !== "edge"
+          ) {
+            try {
+              const req = typeof require === "function" ? require : null;
+              const esbuildPkg = "esbuild";
+              if (req) {
+                esbuild = req(esbuildPkg);
+              }
+            } catch (e) {}
+          }
+
+          if (esbuild && typeof esbuild.build === "function") {
+            const outDir = path.resolve(cwd, ".dinou");
+            if (!existsSync(outDir)) {
+              mkdirSync(outDir, { recursive: true });
+            }
+            const bundledPath = path.resolve(outDir, "dinou.config.bundled.mjs");
+            await esbuild.build({
+              entryPoints: [p],
+              outfile: bundledPath,
+              bundle: true,
+              format: "esm",
+              platform: "node",
+              packages: "external",
+              sourcemap: "inline",
+            });
+            loaded = await import(pathToFileURL(bundledPath).href + (isDev ? `?t=${Date.now()}` : ""));
+          } else if (p.endsWith(".mjs")) {
             loaded = await import(pathToFileURL(p).href + (isDev ? `?t=${Date.now()}` : ""));
           } else {
             const nodeReq =

package/dinou/core/resolve-setup-files.js

@@ -0,0 +1,69 @@
+// dinou/core/resolve-setup-files.js
+const fs = require("node:fs");
+const path = require("node:path");
+
+/**
+ * Resolves setup files according to Dinou's configuration hierarchy:
+ * 1. Plugin setup files (plugin.setupFiles) always execute first.
+ * 2. User setup files:
+ *    - If config.setupFiles is explicitly provided in dinou.config.mjs, it is the sole source of truth.
+ *    - Otherwise, falls back to checking the project root for dinou.setup.mjs, dinou.setup.js, or dinou.setup.ts.
+ *
+ * @param {string} projectRoot
+ * @param {object} config - Dinou config object
+ * @returns {string[]} Array of absolute file paths to inject/execute
+ */
+function resolveSetupFiles(projectRoot, config = {}) {
+  const pluginSetupFiles = [];
+  if (config.plugins && Array.isArray(config.plugins)) {
+    for (const plugin of config.plugins) {
+      if (plugin && Array.isArray(plugin.setupFiles)) {
+        for (const file of plugin.setupFiles) {
+          const resolved = path.isAbsolute(file)
+            ? file
+            : path.resolve(projectRoot, file);
+          if (fs.existsSync(resolved)) {
+            pluginSetupFiles.push(resolved);
+          } else {
+            console.warn(
+              `⚠️ [Dinou] Plugin "${plugin.name || "unnamed"}" specified setup file not found: ${file}`,
+            );
+          }
+        }
+      }
+    }
+  }
+
+  let userSetupFiles = [];
+  if (Array.isArray(config.setupFiles)) {
+    // Explicit configuration takes precedence over convention
+    for (const file of config.setupFiles) {
+      const resolved = path.isAbsolute(file)
+        ? file
+        : path.resolve(projectRoot, file);
+      if (fs.existsSync(resolved)) {
+        userSetupFiles.push(resolved);
+      } else {
+        console.warn(`⚠️ [Dinou] Configured setupFile not found: ${file}`);
+      }
+    }
+  } else {
+    // Convention: check ONLY project root
+    const rootCandidates = [
+      "dinou.setup.mjs",
+      "dinou.setup.js",
+      "dinou.setup.ts",
+    ];
+    for (const name of rootCandidates) {
+      const fullPath = path.resolve(projectRoot, name);
+      if (fs.existsSync(fullPath)) {
+        userSetupFiles.push(fullPath);
+        break; // Only pick the highest priority extension match
+      }
+    }
+  }
+
+  return [...new Set([...pluginSetupFiles, ...userSetupFiles])];
+}
+
+module.exports = { resolveSetupFiles };

package/dinou/core/server-function-proxy-webpack.js

@@ -17,14 +17,33 @@ function executeRedirect(url) {
 function createServerFunctionProxy(id) {
   return new Proxy(() => { }, {
     apply: async (_target, _thisArg, args) => {
-      let body;
+      let customHeaders = {};
+      if (typeof window !== "undefined") {
+        if (typeof window.__DINOU_SERVER_FUNCTION_HEADERS__ === "function") {
+          try {
+            customHeaders = window.__DINOU_SERVER_FUNCTION_HEADERS__() || {};
+          } catch (e) {
+            console.error("[Dinou] Error getting custom headers for server function:", e);
+          }
+        } else if (typeof window.__DINOU_GET_AUTH_TOKEN__ === "function") {
+          try {
+            const token = window.__DINOU_GET_AUTH_TOKEN__();
+            if (token) customHeaders = { Authorization: `Bearer ${token}` };
+          } catch (e) {
+            console.error("[Dinou] Error getting auth token for server function:", e);
+          }
+        }
+      }
+
       const headers = {
         "x-server-function-call": "1",
+        ...customHeaders,
       };
       if (typeof window !== "undefined" && window.location) {
         headers["x-dinou-current-path"] = window.location.pathname;
       }
 
+      let body;
       const formDataIndex = args.findIndex((arg) => arg instanceof FormData);
 
       if (formDataIndex !== -1) {

package/dinou/core/server-function-proxy.js

@@ -17,14 +17,33 @@ function executeRedirect(url) {
 export function createServerFunctionProxy(id) {
   return new Proxy(() => { }, {
     apply: async (_target, _thisArg, args) => {
-      let body;
+      let customHeaders = {};
+      if (typeof window !== "undefined") {
+        if (typeof window.__DINOU_SERVER_FUNCTION_HEADERS__ === "function") {
+          try {
+            customHeaders = window.__DINOU_SERVER_FUNCTION_HEADERS__() || {};
+          } catch (e) {
+            console.error("[Dinou] Error getting custom headers for server function:", e);
+          }
+        } else if (typeof window.__DINOU_GET_AUTH_TOKEN__ === "function") {
+          try {
+            const token = window.__DINOU_GET_AUTH_TOKEN__();
+            if (token) customHeaders = { Authorization: `Bearer ${token}` };
+          } catch (e) {
+            console.error("[Dinou] Error getting auth token for server function:", e);
+          }
+        }
+      }
+
       const headers = {
         "x-server-function-call": "1",
+        ...customHeaders,
       };
       if (typeof window !== "undefined" && window.location) {
         headers["x-dinou-current-path"] = window.location.pathname;
       }
 
+      let body;
       const formDataIndex = args.findIndex((arg) => arg instanceof FormData);
 
       if (formDataIndex !== -1) {

package/dinou/deno/build.mjs

@@ -19,11 +19,19 @@ const {
   isSupportedClientModule,
   scanProjectDependenciesForClientComponents,
 } = require("../core/scan-dependency-components.js");
+const { getDinouConfig } = require("../core/load-dinou-config.js");
+const { resolveSetupFiles } = require("../core/resolve-setup-files.js");
 
 const projectRoot = process.cwd();
 const denoDir = path.resolve(projectRoot, ".dinou/deno");
 fs.mkdirSync(denoDir, { recursive: true });
 
+const dinouConfig = await getDinouConfig(projectRoot);
+const setupFiles = resolveSetupFiles(projectRoot, dinouConfig);
+if (setupFiles.length > 0) {
+  console.log(`  🔌 [Dinou Setup] Active setup files (${setupFiles.length}): ${setupFiles.map((f) => path.basename(f)).join(", ")}`);
+}
+
 try {
   generateRouteTypes(projectRoot);
 } catch (e) {}
@@ -1046,6 +1054,7 @@ try {
     alias: commonAlias,
     loader: commonLoader,
     jsx: "automatic",
+    inject: setupFiles.length > 0 ? setupFiles : undefined,
     define: {
       "process.env.NODE_ENV": '"production"',
       "process.env.DINOU_RUNTIME": '"deno-edge"',
@@ -1069,6 +1078,7 @@ try {
     alias: commonAlias,
     loader: commonLoader,
     jsx: "automatic",
+    inject: setupFiles.length > 0 ? setupFiles : undefined,
     define: {
       "process.env.NODE_ENV": '"production"',
       "process.env.DINOU_RUNTIME": '"deno-edge"',
@@ -1090,6 +1100,7 @@ try {
     conditions: ["deno", "worker", "browser"],
     external: externalList,
     banner,
+    inject: setupFiles.length > 0 ? setupFiles : undefined,
     alias: commonAlias,
     loader: commonLoader,
     define: {

package/dinou/index.d.ts

@@ -120,8 +120,35 @@ export interface RequestContextStore {
 // DINOU CONFIGURATION & PLUGIN INTERFACES
 // ====================================================================
 
+export type NodeMiddleware = (
+  req: import("node:http").IncomingMessage,
+  res: import("node:http").ServerResponse,
+  next: () => void
+) => void | Promise<void>;
+
+export interface ServerHookContext {
+  /** The underlying Node.js http.Server instance */
+  server: import("node:http").Server;
+  /** Whether the server is running in development mode */
+  isDev: boolean;
+  /** Register a raw Node.js middleware (req, res, next) executed before Dinou routes */
+  use(middleware: NodeMiddleware): void;
+}
+
 export interface DinouPlugin {
   name?: string;
+  /**
+   * Hook invoked when the Node.js HTTP server is instantiated,
+   * allowing plugins to attach WebSockets (Socket.IO, ws), listeners, or raw Node middlewares.
+   */
+  configureServer?(context: ServerHookContext): Promise<void> | void;
+
+  /**
+   * Array of setup/polyfill file paths to be executed at the earliest stage
+   * and injected into all bundled engines before any modules are loaded.
+   */
+  setupFiles?: string[];
+
   /**
    * Universal Web Standards middleware and webhook handler.
    * Runs on every incoming HTTP request before React rendering.
@@ -161,6 +188,13 @@ export interface DinouConfig {
    */
   storage?: any;
 
+  /**
+   * Array of setup/polyfill file paths to be executed at the earliest stage
+   * before any server or client components are imported.
+   * If provided, overrides the root `dinou.setup.(mjs|js|ts)` convention.
+   */
+  setupFiles?: string[];
+
   /**
    * Array of Dinou plugins.
    */

package/dinou/node/build.mjs

@@ -23,7 +23,7 @@ try {
     outDir: ".dinou/node",
   });
 
-  const { dinouDirSlash, externalList, banner, commonAlias, commonLoader, isWebpackBuild } = engineResult;
+  const { dinouDirSlash, externalList, banner, commonAlias, commonLoader, isWebpackBuild, setupFiles } = engineResult;
 
   // Pass C: Node Orchestrator Entry
   const nodeEntryContent = `// Auto-generated main entry for Node.js (Dual-Bundle)
@@ -119,12 +119,32 @@ export async function fetch(req) {
 
 const PORT = Number(process.env.PORT || 3000);
 
-export function startServer(port = PORT, host = "0.0.0.0") {
+const nodeMiddlewares = [];
+
+export async function startServer(port = PORT, host = "0.0.0.0") {
   const server = http.createServer(async (req, res) => {
     try {
+      if (res.writableEnded || res.headersSent) {
+        return;
+      }
+
+      if (nodeMiddlewares.length > 0) {
+        for (const mw of nodeMiddlewares) {
+          let continued = false;
+          await mw(req, res, () => {
+            continued = true;
+          });
+          if (!continued || res.writableEnded || res.headersSent) {
+            return;
+          }
+        }
+      }
+
       const webReq = nodeToWebRequest(req);
       const webRes = await fetch(webReq);
-      await sendWebResponseToNode(webRes, res);
+      if (!res.writableEnded && !res.headersSent) {
+        await sendWebResponseToNode(webRes, res);
+      }
     } catch (err) {
       console.error("[Dinou Node Server] Request error:", err);
       if (!res.headersSent) {
@@ -135,6 +155,29 @@ export function startServer(port = PORT, host = "0.0.0.0") {
     }
   });
 
+  try {
+    const { getDinouConfig } = await import("${dinouDirSlash}/core/load-dinou-config.js");
+    const cfg = await getDinouConfig();
+    if (cfg.plugins && Array.isArray(cfg.plugins)) {
+      const serverContext = {
+        server,
+        isDev: false,
+        use(middleware) {
+          if (typeof middleware === "function") {
+            nodeMiddlewares.push(middleware);
+          }
+        },
+      };
+      for (const plugin of cfg.plugins) {
+        if (typeof plugin.configureServer === "function") {
+          await plugin.configureServer(serverContext);
+        }
+      }
+    }
+  } catch (err) {
+    console.error("❌ [Dinou Node Server] Error running configureServer plugins:", err);
+  }
+
   return new Promise((resolve, reject) => {
     server.on("error", reject);
     server.listen(port, () => {
@@ -146,17 +189,20 @@ export function startServer(port = PORT, host = "0.0.0.0") {
 
 export default {
   port: PORT,
-  fetch,
   startServer,
 };
 
-const isMain = typeof process !== "undefined" &&
-  process.argv[1] &&
-  (path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url)));
+const isMain = Boolean(
+  (typeof import.meta !== "undefined" && import.meta.main) ||
+  (typeof process !== "undefined" &&
+    process.argv[1] &&
+    (path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))))
+);
 
 if (isMain) {
   startServer(PORT);
 }
+
 `;
   const nodeEntryPath = path.join(nodeDir, "node-entry.mjs");
   fs.writeFileSync(nodeEntryPath, nodeEntryContent, "utf8");
@@ -175,6 +221,7 @@ if (isMain) {
     conditions: ["node", "worker", "browser"],
     external: [...externalList, "./rsc-engine.mjs", "./ssr-engine.mjs"],
     banner,
+    inject: setupFiles,
     alias: commonAlias,
     loader: commonLoader,
     define: {

package/dinou/node/bundle-dual-engine.mjs

@@ -20,6 +20,8 @@ const {
   isSupportedClientModule,
   scanProjectDependenciesForClientComponents,
 } = require("../core/scan-dependency-components.js");
+const { getDinouConfig } = require("../core/load-dinou-config.js");
+const { resolveSetupFiles } = require("../core/resolve-setup-files.js");
 
 export async function bundleDualEngine(options = {}) {
   const isDev = Boolean(options.isDev);
@@ -27,6 +29,12 @@ export async function bundleDualEngine(options = {}) {
   const nodeDir = path.resolve(projectRoot, options.outDir || ".dinou/node");
   fs.mkdirSync(nodeDir, { recursive: true });
 
+  const dinouConfig = await getDinouConfig();
+  const setupFiles = resolveSetupFiles(projectRoot, dinouConfig);
+  if (setupFiles.length > 0) {
+    console.log(`  🔌 [Dinou Setup] Active setup files (${setupFiles.length}):`, setupFiles.map((f) => path.relative(projectRoot, f)).join(", "));
+  }
+
   try {
     generateRouteTypes(projectRoot);
   } catch (e) {}
@@ -956,6 +964,7 @@ var __webpack_chunk_load__ = function(chunkId) {
     conditions: ["node", "worker", "react-server"],
     external: externalList,
     banner,
+    inject: setupFiles,
     plugins: [clientReferencesPlugin, serverReferencesPlugin, serverAssetPlugin],
     alias: commonAlias,
     loader: commonLoader,
@@ -980,6 +989,7 @@ var __webpack_chunk_load__ = function(chunkId) {
     conditions: ["node", "worker", "browser"],
     external: externalList,
     banner,
+    inject: setupFiles,
     plugins: [serverReferencesPluginSsr, serverAssetPlugin],
     alias: commonAlias,
     loader: commonLoader,
@@ -1006,6 +1016,7 @@ var __webpack_chunk_load__ = function(chunkId) {
     commonAlias,
     commonLoader,
     isWebpackBuild,
+    setupFiles,
   };
 }
 

package/dinou/node/dev.mjs

@@ -76,6 +76,22 @@ const dinouDir = fs.existsSync(path.resolve(projectRoot, "dinou"))
   : path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const dinouDirSlash = dinouDir.replace(/\\/g, "/");
 
+// Resolve and execute setupFiles immediately before any compilation
+const { getDinouConfig } = require(path.join(dinouDir, "core/load-dinou-config.js"));
+const { resolveSetupFiles } = require(path.join(dinouDir, "core/resolve-setup-files.js"));
+const dinouConfig = await getDinouConfig();
+const setupFiles = resolveSetupFiles(projectRoot, dinouConfig);
+if (setupFiles.length > 0) {
+  console.log(`  🔌 [Dinou Setup] Executing setup files (${setupFiles.length}):`, setupFiles.map((f) => path.relative(projectRoot, f)).join(", "));
+  for (const f of setupFiles) {
+    try {
+      await dynamicImportWithRetry(pathToFileURL(f).href);
+    } catch (e) {
+      console.error(`❌ [Dinou Dev] Error executing setupFile "${f}":`, e);
+    }
+  }
+}
+
 function getFallbackChunkId(absPath) {
   const norm = absPath.replace(/\\/g, "/");
   const name = path.basename(absPath, path.extname(absPath));
@@ -1463,6 +1479,7 @@ const ctxA = await esbuild.context({
   conditions: ["node", "worker", "react-server"],
   external: externalList,
   banner,
+  inject: setupFiles,
   plugins: [clientReferencesPlugin, serverReferencesPlugin, serverAssetPlugin, createDevExternalPackagesPlugin(true)],
   alias: commonAlias,
   loader: commonLoader,
@@ -1490,6 +1507,7 @@ const ctxB = await esbuild.context({
   conditions: ["node", "worker", "browser"],
   external: externalList,
   banner,
+  inject: setupFiles,
   plugins: [serverReferencesPluginSsr, serverAssetPlugin, createDevExternalPackagesPlugin(false)],
   alias: commonAlias,
   loader: commonLoader,
@@ -2302,9 +2320,52 @@ async function startClientBundler(tool) {
   throw new Error(`Unsupported DINOU_BUILD_TOOL: ${tool}`);
 }
 
+// Node.js Middlewares registered by plugins via configureServer
+const nodeMiddlewares = [];
+
+async function applyServerPlugins(serverInstance) {
+  try {
+    const { getDinouConfig } = require(path.join(dinouDir, "core/load-dinou-config.js"));
+    const config = await getDinouConfig();
+    if (config.plugins && Array.isArray(config.plugins)) {
+      const serverContext = {
+        server: serverInstance,
+        isDev: true,
+        use(middleware) {
+          if (typeof middleware === "function") {
+            nodeMiddlewares.push(middleware);
+          }
+        },
+      };
+      for (const plugin of config.plugins) {
+        if (typeof plugin.configureServer === "function") {
+          await plugin.configureServer(serverContext);
+        }
+      }
+    }
+  } catch (err) {
+    console.error("❌ [Dinou Dev] Error applying plugin configureServer hooks:", err);
+  }
+}
+
 // HTTP Server
 const server = http.createServer(async (req, res) => {
   try {
+    if (res.writableEnded || res.headersSent) {
+      return;
+    }
+
+    if (nodeMiddlewares.length > 0) {
+      for (const mw of nodeMiddlewares) {
+        let continued = false;
+        await mw(req, res, () => {
+          continued = true;
+        });
+        if (!continued || res.writableEnded || res.headersSent) {
+          return;
+        }
+      }
+    }
     if (clientBundlerPromise) {
       await clientBundlerPromise;
     }
@@ -2493,7 +2554,9 @@ const server = http.createServer(async (req, res) => {
       console.log(`[DEV 404] ${req.method} ${pathname}`);
     }
 
-    await sendWebResponseToNode(webRes, res);
+    if (!res.writableEnded && !res.headersSent) {
+      await sendWebResponseToNode(webRes, res);
+    }
   } catch (err) {
     console.error("[Dinou Dev Server] Request error:", err);
     if (!res.headersSent) {
@@ -2515,6 +2578,8 @@ server.on("error", (err) => {
   process.exit(1);
 });
 
+await applyServerPlugins(server);
+
 server.listen(PORT, async () => {
   const buildTool = isWebpackBuild ? "webpack" : (process.env.DINOU_BUILD_TOOL || "esbuild");
 

package/dinou/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dinou-ejected",
-  "version": "7.1.0",
+  "version": "7.3.0",
   "main": "index.js",
   "private": true,
   "exports": {

package/eject.js

@@ -28,6 +28,50 @@ const ejectedScripts = {
   "build:node:esbuild": "npm run build:node",
   "build:node:rollup": "npm run build:client:rollup && node ./dinou/node/build.mjs",
   "build:node:webpack": "npm run build:client:webpack && cross-env DINOU_BUILD_TOOL=webpack node ./dinou/node/build.mjs",
+  "build:node:compile": "npm run build:node:compile:esbuild",
+  "build:node:compile:esbuild": "npm run build:node:esbuild && bun build --compile .dinou/node/server.mjs --outfile dist/server",
+  "build:node:compile:rollup": "npm run build:node:rollup && bun build --compile .dinou/node/server.mjs --outfile dist/server",
+  "build:node:compile:webpack": "npm run build:node:webpack && bun build --compile .dinou/node/server.mjs --outfile dist/server",
+  "build:node:compile:linux": "npm run build:node:compile:linux:esbuild",
+  "build:node:compile:linux:esbuild": "npm run build:node:esbuild && bun build --compile --target=bun-linux-x64 .dinou/node/server.mjs --outfile dist/server-linux",
+  "build:node:compile:linux:rollup": "npm run build:node:rollup && bun build --compile --target=bun-linux-x64 .dinou/node/server.mjs --outfile dist/server-linux",
+  "build:node:compile:linux:webpack": "npm run build:node:webpack && bun build --compile --target=bun-linux-x64 .dinou/node/server.mjs --outfile dist/server-linux",
+  "build:node:compile:linux_arm": "npm run build:node:compile:linux_arm:esbuild",
+  "build:node:compile:linux_arm:esbuild": "npm run build:node:esbuild && bun build --compile --target=bun-linux-arm64 .dinou/node/server.mjs --outfile dist/server-linux-arm",
+  "build:node:compile:linux_arm:rollup": "npm run build:node:rollup && bun build --compile --target=bun-linux-arm64 .dinou/node/server.mjs --outfile dist/server-linux-arm",
+  "build:node:compile:linux_arm:webpack": "npm run build:node:webpack && bun build --compile --target=bun-linux-arm64 .dinou/node/server.mjs --outfile dist/server-linux-arm",
+  "build:node:compile:mac": "npm run build:node:compile:mac:esbuild",
+  "build:node:compile:mac:esbuild": "npm run build:node:esbuild && bun build --compile --target=bun-darwin-arm64 .dinou/node/server.mjs --outfile dist/server-mac",
+  "build:node:compile:mac:rollup": "npm run build:node:rollup && bun build --compile --target=bun-darwin-arm64 .dinou/node/server.mjs --outfile dist/server-mac",
+  "build:node:compile:mac:webpack": "npm run build:node:webpack && bun build --compile --target=bun-darwin-arm64 .dinou/node/server.mjs --outfile dist/server-mac",
+  "build:node:compile:win": "npm run build:node:compile:win:esbuild",
+  "build:node:compile:win:esbuild": "npm run build:node:esbuild && bun build --compile --target=bun-windows-x64 .dinou/node/server.mjs --outfile dist/server-win",
+  "build:node:compile:win:rollup": "npm run build:node:rollup && bun build --compile --target=bun-windows-x64 .dinou/node/server.mjs --outfile dist/server-win",
+  "build:node:compile:win:webpack": "npm run build:node:webpack && bun build --compile --target=bun-windows-x64 .dinou/node/server.mjs --outfile dist/server-win",
+  "build:node:pure": "npm run build:node:pure:esbuild",
+  "build:node:pure:esbuild": "cross-env NODE_ENV=production bun dinou/esbuild/build.mjs && bun ./dinou/node/build.mjs",
+  "build:node:pure:rollup": "cross-env NODE_ENV=production rollup -c ./dinou/rollup/rollup.config.js && bun ./dinou/node/build.mjs",
+  "build:node:pure:webpack": "cross-env NODE_ENV=production webpack --config dinou/webpack/webpack.config.js && cross-env DINOU_BUILD_TOOL=webpack bun ./dinou/node/build.mjs",
+  "build:node:pure:compile": "npm run build:node:pure:compile:esbuild",
+  "build:node:pure:compile:esbuild": "cross-env NODE_ENV=production bun dinou/esbuild/build.mjs && bun ./dinou/node/build.mjs && bun build --compile .dinou/node/server.mjs --outfile dist/server",
+  "build:node:pure:compile:rollup": "cross-env NODE_ENV=production rollup -c ./dinou/rollup/rollup.config.js && bun ./dinou/node/build.mjs && bun build --compile .dinou/node/server.mjs --outfile dist/server",
+  "build:node:pure:compile:webpack": "cross-env NODE_ENV=production webpack --config dinou/webpack/webpack.config.js && cross-env DINOU_BUILD_TOOL=webpack bun ./dinou/node/build.mjs && bun build --compile .dinou/node/server.mjs --outfile dist/server",
+  "build:node:pure:compile:linux": "npm run build:node:pure:compile:linux:esbuild",
+  "build:node:pure:compile:linux:esbuild": "cross-env NODE_ENV=production bun dinou/esbuild/build.mjs && bun ./dinou/node/build.mjs && bun build --compile --target=bun-linux-x64 .dinou/node/server.mjs --outfile dist/server-linux",
+  "build:node:pure:compile:linux:rollup": "cross-env NODE_ENV=production rollup -c ./dinou/rollup/rollup.config.js && bun ./dinou/node/build.mjs && bun build --compile --target=bun-linux-x64 .dinou/node/server.mjs --outfile dist/server-linux",
+  "build:node:pure:compile:linux:webpack": "cross-env NODE_ENV=production webpack --config dinou/webpack/webpack.config.js && cross-env DINOU_BUILD_TOOL=webpack bun ./dinou/node/build.mjs && bun build --compile --target=bun-linux-x64 .dinou/node/server.mjs --outfile dist/server-linux",
+  "build:node:pure:compile:linux_arm": "npm run build:node:pure:compile:linux_arm:esbuild",
+  "build:node:pure:compile:linux_arm:esbuild": "cross-env NODE_ENV=production bun dinou/esbuild/build.mjs && bun ./dinou/node/build.mjs && bun build --compile --target=bun-linux-arm64 .dinou/node/server.mjs --outfile dist/server-linux-arm",
+  "build:node:pure:compile:linux_arm:rollup": "cross-env NODE_ENV=production rollup -c ./dinou/rollup/rollup.config.js && bun ./dinou/node/build.mjs && bun build --compile --target=bun-linux-arm64 .dinou/node/server.mjs --outfile dist/server-linux-arm",
+  "build:node:pure:compile:linux_arm:webpack": "cross-env NODE_ENV=production webpack --config dinou/webpack/webpack.config.js && cross-env DINOU_BUILD_TOOL=webpack bun ./dinou/node/build.mjs && bun build --compile --target=bun-linux-arm64 .dinou/node/server.mjs --outfile dist/server-linux-arm",
+  "build:node:pure:compile:mac": "npm run build:node:pure:compile:mac:esbuild",
+  "build:node:pure:compile:mac:esbuild": "cross-env NODE_ENV=production bun dinou/esbuild/build.mjs && bun ./dinou/node/build.mjs && bun build --compile --target=bun-darwin-arm64 .dinou/node/server.mjs --outfile dist/server-mac",
+  "build:node:pure:compile:mac:rollup": "cross-env NODE_ENV=production rollup -c ./dinou/rollup/rollup.config.js && bun ./dinou/node/build.mjs && bun build --compile --target=bun-darwin-arm64 .dinou/node/server.mjs --outfile dist/server-mac",
+  "build:node:pure:compile:mac:webpack": "cross-env NODE_ENV=production webpack --config dinou/webpack/webpack.config.js && cross-env DINOU_BUILD_TOOL=webpack bun ./dinou/node/build.mjs && bun build --compile --target=bun-darwin-arm64 .dinou/node/server.mjs --outfile dist/server-mac",
+  "build:node:pure:compile:win": "npm run build:node:pure:compile:win:esbuild",
+  "build:node:pure:compile:win:esbuild": "cross-env NODE_ENV=production bun dinou/esbuild/build.mjs && bun ./dinou/node/build.mjs && bun build --compile --target=bun-windows-x64 .dinou/node/server.mjs --outfile dist/server-win",
+  "build:node:pure:compile:win:rollup": "cross-env NODE_ENV=production rollup -c ./dinou/rollup/rollup.config.js && bun ./dinou/node/build.mjs && bun build --compile --target=bun-windows-x64 .dinou/node/server.mjs --outfile dist/server-win",
+  "build:node:pure:compile:win:webpack": "cross-env NODE_ENV=production webpack --config dinou/webpack/webpack.config.js && cross-env DINOU_BUILD_TOOL=webpack bun ./dinou/node/build.mjs && bun build --compile --target=bun-windows-x64 .dinou/node/server.mjs --outfile dist/server-win",
   "start:node": "cross-env NODE_ENV=production node dinou/adapters/node.mjs",
   "start:node:esbuild": "npm run start:node",
   "start:node:rollup": "npm run start:node",
@@ -146,7 +190,7 @@ function detectPackageManager() {
 
   if (fs.existsSync(path.join(projectRoot, "yarn.lock"))) return "yarn";
   if (fs.existsSync(path.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs.existsSync(path.join(projectRoot, "bun.lockb"))) return "bun";
+  if (fs.existsSync(path.join(projectRoot, "bun.lockb")) || fs.existsSync(path.join(projectRoot, "bun.lock"))) return "bun";
   if (fs.existsSync(path.join(projectRoot, "package-lock.json"))) return "npm";
 
   return "npm";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dinou",
-  "version": "7.1.0",
+  "version": "7.3.0",
   "description": "Full-stack React 19 framework with native RSC, Server Functions, progressive streaming, and zero vendor lock-in.",
   "main": "index.js",
   "bin": {

package/dinou/core/babel-esm-loader.js

@@ -1,267 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const { transformAsync } = require("@babel/core");
-const { fileURLToPath, pathToFileURL } = require("url");
-const createScopedName = require("./createScopedName");
-const { extensionsWithDot } = require("./asset-extensions.js");
-const { getAbsPathWithExt } = require("./get-abs-path-with-ext.js");
-
-const { normalizePathCase } = require("./path-utils.js");
-
-const Module = require("module");
-const originalResolveFilename = Module._resolveFilename;
-const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
-
-let reactServerPath, reactDomServerPath, reactJsxRuntimePath, reactJsxDevRuntimePath;
-
-const reactPkgJson = require.resolve("react/package.json");
-reactServerPath = path.join(path.dirname(reactPkgJson), "react.react-server.js");
-reactJsxRuntimePath = path.join(path.dirname(reactPkgJson), "jsx-runtime.react-server.js");
-reactJsxDevRuntimePath = path.join(path.dirname(reactPkgJson), "jsx-dev-runtime.react-server.js");
-
-const reactDomPkgJson = require.resolve("react-dom/package.json");
-reactDomServerPath = path.join(path.dirname(reactDomPkgJson), "react-dom.react-server.js");
-
-let roggcServerNodePath, webpackServerNodePath;
-try {
-  const roggcPkg = require.resolve("@roggc/react-server-dom-esm/package.json");
-  roggcServerNodePath = path.join(path.dirname(roggcPkg), "server.node.js");
-} catch (e) {}
-
-try {
-  const wpPkg = require.resolve("react-server-dom-webpack/package.json");
-  webpackServerNodePath = path.join(path.dirname(wpPkg), "server.node.js");
-} catch (e) {}
-
-Module._resolveFilename = function (request, parent, isMain, options) {
-  if (request === "react") {
-    return reactServerPath;
-  } else if (request === "react-dom") {
-    return reactDomServerPath;
-  } else if (request === "react/jsx-runtime") {
-    return reactJsxRuntimePath;
-  } else if (request === "react/jsx-dev-runtime") {
-    return reactJsxDevRuntimePath;
-  } else if (request === "@roggc/react-server-dom-esm/server" && roggcServerNodePath) {
-    return roggcServerNodePath;
-  } else if (request === "react-server-dom-webpack/server" && webpackServerNodePath) {
-    return webpackServerNodePath;
-  }
-  return originalResolveFilename.call(this, request, parent, isMain, options);
-};
-
-require("./css-require-hook.js")();
-
-function getMtimeParam(absPath) {
-  try {
-    const stats = fs.statSync(absPath);
-    return Math.round(stats.mtimeMs);
-  } catch (e) {
-    return Date.now();
-  }
-}
-
-exports.resolve = async function resolve(specifier, context, defaultResolve) {
-  if (process.env.DINOU_PROCESS !== "ssr-html") {
-    if (specifier === "react") {
-      return { url: pathToFileURL(reactServerPath).href, shortCircuit: true };
-    }
-    if (specifier === "react/jsx-runtime") {
-      return { url: pathToFileURL(reactJsxRuntimePath).href, shortCircuit: true };
-    }
-    if (specifier === "react/jsx-dev-runtime") {
-      return { url: pathToFileURL(reactJsxDevRuntimePath).href, shortCircuit: true };
-    }
-    if (specifier === "react-dom") {
-      return { url: pathToFileURL(reactDomServerPath).href, shortCircuit: true };
-    }
-    if (specifier === "@roggc/react-server-dom-esm/server" && roggcServerNodePath) {
-      return { url: pathToFileURL(roggcServerNodePath).href, shortCircuit: true };
-    }
-    if (specifier === "react-server-dom-webpack/server" && webpackServerNodePath) {
-      return { url: pathToFileURL(webpackServerNodePath).href, shortCircuit: true };
-    }
-  }
-
-  const absPathWithExt = getAbsPathWithExt(specifier, context);
-  if (absPathWithExt) {
-    let url = pathToFileURL(absPathWithExt).href;
-    if (process.env.NODE_ENV !== "production") {
-      url += `?mtime=${getMtimeParam(absPathWithExt)}`;
-    }
-
-    return {
-      url,
-      shortCircuit: true,
-    };
-  }
-
-  // Fallback to default resolver
-  return defaultResolve(specifier, context, defaultResolve);
-};
-
-exports.load = async function load(url, context, defaultLoad) {
-  // --- 🟢 Handle non-JS assets (png, jpg, etc.)
-  const assetExts = extensionsWithDot;
-  const ext = path.extname(url.split("?")[0]); // remove search params if any
-
-  if (assetExts.includes(ext)) {
-    // Return a tiny stub that mimics what asset-require-hook would do
-    const filepath = fileURLToPath(url.split("?")[0]);
-    const localName = path.basename(filepath, ext);
-    const hashedName = createScopedName(localName, filepath);
-    const virtualExport = `export default "/assets/${hashedName}${ext}";`;
-
-    return {
-      format: "module",
-      source: virtualExport,
-      shortCircuit: true,
-      url,
-    };
-  }
-
-  if (ext === ".css") {
-    const mod = require(fileURLToPath(url.split("?")[0]));
-    const source = `export default ${JSON.stringify(mod)};`;
-    return { format: "module", source, shortCircuit: true, url };
-  }
-
-  const cleanUrl = url.split("?")[0];
-  if (/\.(jsx|tsx|ts|js)$/.test(cleanUrl)) {
-    let filename;
-    try {
-      filename = fileURLToPath(
-        cleanUrl.startsWith("file://") ? cleanUrl : pathToFileURL(cleanUrl).href
-      );
-    } catch (e) {
-      throw e;
-    }
-    const rel = path.relative(
-      normalizePathCase(process.cwd()),
-      normalizePathCase(filename)
-    );
-    const source = fs.readFileSync(filename, "utf-8");
-    const urlToReturn = pathToFileURL(filename).href;
-
-    const useClientRegex =
-      /^\s*(?:(?:\/\/[^\n]*\n\s*)|(?:\/\*[\s\S]*?\*\/\s*))*['"]use client['"]/;
-    const hasUseClient = useClientRegex.test(source);
-
-    const esmSyntaxRegex = /^(?:import|export)\b/m;
-    const hasESMSyntax = esmSyntaxRegex.test(source);
-
-    if (ext === ".js" && !rel.startsWith("src" + path.sep) && !hasESMSyntax) {
-      return defaultLoad(url, context, defaultLoad);
-    }
-
-    const isReactServer = process.env.DINOU_PROCESS !== "ssr-html";
-    if (isReactServer && hasUseClient) {
-      const parseExports = require("./parse-exports.js");
-      const exports = parseExports(source);
-      const clientPkgPath = isWebpack
-        ? require.resolve("react-server-dom-webpack/package.json")
-        : require.resolve("@roggc/react-server-dom-esm/package.json");
-      const clientServerNodePath = path.join(path.dirname(clientPkgPath), "server.node.js");
-      const clientServerNodeUrl = pathToFileURL(clientServerNodePath).href;
-      let newSrc = `import pkg from ${JSON.stringify(clientServerNodeUrl)};\n`;
-      newSrc += 'const {registerClientReference} = pkg;\n';
-      for (const name of exports) {
-        if (name === 'default') {
-          newSrc += 'export default ';
-          newSrc += 'registerClientReference(function() {';
-          newSrc += 'throw new Error(' + JSON.stringify("Attempted to call the default export of " + urlToReturn + " from the server but it's on the client.") + ');';
-          newSrc += '},';
-          newSrc += JSON.stringify(urlToReturn) + ',';
-          newSrc += JSON.stringify(name) + ');\n';
-        } else {
-          newSrc += 'export const ' + name + ' = ';
-          newSrc += 'registerClientReference(function() {';
-          newSrc += 'throw new Error(' + JSON.stringify("Attempted to call " + name + "() from the server but " + name + " is on the client.") + ');';
-          newSrc += '},';
-          newSrc += JSON.stringify(urlToReturn) + ',';
-          newSrc += JSON.stringify(name) + ');\n';
-        }
-      }
-      return {
-        format: "module",
-        source: newSrc,
-        shortCircuit: true,
-        url,
-      };
-    }
-
-    const { useServerRegex } = require("../constants.js");
-    const hasUseServer = useServerRegex.test(source);
-
-    if (isReactServer && hasUseServer) {
-      const parseExports = require("./parse-exports.js");
-      const exports = parseExports(source);
-
-      const { code } = await transformAsync(source, {
-        filename,
-        presets: [
-          ["@babel/preset-react", { runtime: "automatic" }],
-          "@babel/preset-typescript",
-        ],
-        sourceMaps: "inline",
-        ast: false,
-      });
-
-      let newSrc = code + "\n\n";
-
-      const serverPkgPath = isWebpack
-        ? require.resolve("react-server-dom-webpack/package.json")
-        : require.resolve("@roggc/react-server-dom-esm/package.json");
-      const serverNodePath = path.join(path.dirname(serverPkgPath), "server.node.js");
-      const serverNodeUrl = pathToFileURL(serverNodePath).href;
-      newSrc += `import pkgServer from ${JSON.stringify(serverNodeUrl)};\n`;
-      newSrc += 'const {registerServerReference} = pkgServer;\n';
-
-      const relativeFileUrl = "file:///" + rel.replace(/\\/g, "/");
-      for (const name of exports) {
-        if (name !== 'default') {
-          newSrc += `registerServerReference(${name}, ${JSON.stringify(relativeFileUrl)}, ${JSON.stringify(name)});\n`;
-        }
-      }
-
-      return {
-        format: "module",
-        source: newSrc,
-        shortCircuit: true,
-        url,
-      };
-    }
-
-    if (ext === ".js") {
-      return {
-        format: "module",
-        source,
-        shortCircuit: true,
-        url,
-      };
-    }
-
-    const { code } = await transformAsync(source, {
-      filename,
-      presets: [
-        ["@babel/preset-react", { runtime: "automatic" }],
-        "@babel/preset-typescript",
-      ],
-      sourceMaps: "inline",
-      ast: false,
-    });
-
-    // const urlToReturn = pathToFileURL(filename).href;
-
-    return {
-      format: "module",
-      source: code,
-      shortCircuit: true,
-      url,
-    };
-  }
-
-  if (url) {
-    return defaultLoad(url, context, defaultLoad);
-  }
-};