dinou 6.1.0 → 7.0.0

package/dinou/core/request-context.js

@@ -4,19 +4,39 @@ const DINOU_CONTEXT_KEY = Symbol.for("dinou.request.context.storage");
 let requestStorage;
 
 if (typeof window === "undefined") {
-  const nodeRequire =
-    typeof module !== "undefined" && typeof module.require === "function"
-      ? module.require.bind(module)
-      : null;
+  let AsyncLocalStorageClass;
 
-  if (nodeRequire) {
-    const { AsyncLocalStorage } = nodeRequire("node:async_hooks");
+  if (typeof globalThis.AsyncLocalStorage !== "undefined") {
+    AsyncLocalStorageClass = globalThis.AsyncLocalStorage;
+  }
 
-    if (!global[DINOU_CONTEXT_KEY]) {
-      global[DINOU_CONTEXT_KEY] = new AsyncLocalStorage();
-    }
+  if (!AsyncLocalStorageClass) {
+    try {
+      if (typeof globalThis.__dinou_require__ === "function") {
+        AsyncLocalStorageClass = globalThis.__dinou_require__("node:async_hooks")?.AsyncLocalStorage;
+      } else if (typeof process !== "undefined" && process.versions && (process.versions.node || process.versions.bun)) {
+        const getRequire = new Function("return typeof require !== 'undefined' ? require : null");
+        const nodeRequire = getRequire();
+        if (nodeRequire) {
+          AsyncLocalStorageClass = nodeRequire("node:async_hooks")?.AsyncLocalStorage;
+        }
+      }
+    } catch (e) {}
+  }
 
-    requestStorage = global[DINOU_CONTEXT_KEY];
+  if (AsyncLocalStorageClass) {
+    if (typeof globalThis.AsyncLocalStorage === "undefined") {
+      globalThis.AsyncLocalStorage = AsyncLocalStorageClass;
+    }
+    if (!globalThis[DINOU_CONTEXT_KEY]) {
+      globalThis[DINOU_CONTEXT_KEY] = new AsyncLocalStorageClass();
+    }
+    requestStorage = globalThis[DINOU_CONTEXT_KEY];
+  } else {
+    requestStorage = {
+      run: (store, callback) => callback(),
+      getStore: () => undefined,
+    };
   }
 } else {
   requestStorage = {
@@ -25,6 +45,19 @@ if (typeof window === "undefined") {
   };
 }
 
+function setCurrentContext(ctx) {
+  if (typeof globalThis !== "undefined") {
+    globalThis[Symbol.for("dinou.request.context.current")] = ctx;
+  }
+}
+
+function getCurrentContext() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis[Symbol.for("dinou.request.context.current")];
+  }
+  return undefined;
+}
+
 function getContext() {
   if (typeof window !== "undefined") {
     console.error(
@@ -32,12 +65,13 @@ function getContext() {
     );
     return {};
   }
-  if (!requestStorage) return undefined;
-  const store = requestStorage.getStore();
-  return store;
+  const store = requestStorage?.getStore();
+  return store || getCurrentContext() || {};
 }
 
 module.exports = {
   requestStorage,
   getContext,
+  setCurrentContext,
+  getCurrentContext,
 };

package/dinou/core/resolve-module-ppr.js

@@ -0,0 +1,32 @@
+// dinou/core/resolve-module-ppr.js
+// Resolves the PPR configuration from an imported module (page_functions, layout_functions).
+// Supports constants (export const ppr = true/false), sync functions (export function ppr()),
+// and async functions (export async function ppr()).
+
+async function resolveModulePpr(mod) {
+  if (!mod) return null;
+  const raw =
+    mod.ppr !== undefined
+      ? mod.ppr
+      : mod.default?.ppr !== undefined
+      ? mod.default.ppr
+      : undefined;
+
+  if (raw === undefined || raw === null) return null;
+
+  if (typeof raw === "function") {
+    try {
+      const res = await raw();
+      return res !== null && res !== undefined ? Boolean(res) : null;
+    } catch (e) {
+      console.error("[Dinou PPR] Error evaluating ppr() function:", e);
+      return null;
+    }
+  }
+
+  return Boolean(raw);
+}
+
+module.exports = {
+  resolveModulePpr,
+};

package/dinou/core/revalidating.js

@@ -1,9 +1,21 @@
 const path = require("path");
 const fs = require("fs").promises;
 const { existsSync, copyFileSync } = require("fs");
-const generateStaticPage = require("./generate-static-page");
-const { buildStaticPage } = require("./build-static-pages");
-const generateStaticRSC = require("./generate-static-rsc");
+let _generateStaticPage = null;
+function getGenerateStaticPage() {
+  if (!_generateStaticPage) _generateStaticPage = require("./generate-static-page");
+  return _generateStaticPage;
+}
+let _buildStaticPage = null;
+function getBuildStaticPage() {
+  if (!_buildStaticPage) _buildStaticPage = require("./build-static-pages").buildStaticPage;
+  return _buildStaticPage;
+}
+let _generateStaticRSC = null;
+function getGenerateStaticRSC() {
+  if (!_generateStaticRSC) _generateStaticRSC = require("./generate-static-rsc");
+  return _generateStaticRSC;
+}
 const { safeRename } = require("./safe-rename");
 const { updateStatus } = require("./status-manifest");
 
@@ -22,8 +34,8 @@ function revalidating(reqPath, isDynamicFromServer) {
 
       const isExpired =
         typeof revalidate === "number" &&
-        revalidate > 0 &&
-        Date.now() > generatedAt + revalidate;
+        revalidate >= 1 &&
+        Date.now() > generatedAt + revalidate * 1000;
 
       if (isExpired && !regenerating.has(reqPath)) {
         try {
@@ -32,6 +44,11 @@ function revalidating(reqPath, isDynamicFromServer) {
               path.join(dist2Folder, reqPath, "index.html"),
               path.join(dist2Folder, reqPath, "index._old.html")
             );
+          if (existsSync(path.join(dist2Folder, reqPath, "page.rsc")))
+            copyFileSync(
+              path.join(dist2Folder, reqPath, "page.rsc"),
+              path.join(dist2Folder, reqPath, "page._old.rsc")
+            );
           if (existsSync(path.join(dist2Folder, reqPath, "rsc.rsc")))
             copyFileSync(
               path.join(dist2Folder, reqPath, "rsc.rsc"),
@@ -47,7 +64,7 @@ function revalidating(reqPath, isDynamicFromServer) {
           try {
             console.log(`[ISR] Starting regeneration for ${reqPath}...`);
             const isDynamic = {};
-            await buildStaticPage(reqPath, isDynamic);
+            await getBuildStaticPage()(reqPath, isDynamic);
             if (isDynamic.value) {
               isDynamicFromServer.value = true;
               console.log(
@@ -57,7 +74,7 @@ function revalidating(reqPath, isDynamicFromServer) {
               return;
             }
 
-            const rscResult = await generateStaticRSC(reqPath);
+            const rscResult = await getGenerateStaticRSC()(reqPath);
             if (!rscResult.success) {
               console.warn(`⚠️ [ISR] RSC generation failed for ${reqPath}. Aborting.`);
               await fs.unlink(rscResult.tempPath).catch(() => { });
@@ -67,7 +84,7 @@ function revalidating(reqPath, isDynamicFromServer) {
             // Commit the RSC payload immediately so that generateStaticPage can read it
             await safeRename(rscResult.tempPath, rscResult.finalPath);
 
-            const pageResult = await generateStaticPage(reqPath);
+            const pageResult = await getGenerateStaticPage()(reqPath);
             if (pageResult.success) {
               await safeRename(pageResult.tempPath, pageResult.finalPath);
               updateStatus(reqPath, pageResult.status);
@@ -91,4 +108,6 @@ function revalidating(reqPath, isDynamicFromServer) {
     }).catch((err) => { });
 }
 
-module.exports = { revalidating, regenerating };
+const inFlightGenerations = new Map();
+
+module.exports = { revalidating, regenerating, inFlightGenerations };

package/dinou/core/route-generator.js

@@ -0,0 +1,107 @@
+const fs = require("fs");
+const path = require("path");
+const parseExports = require("./parse-exports.js");
+
+function collectSourceFiles(dir, baseDir = dir) {
+  if (!fs.existsSync(dir)) return [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  let files = [];
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files = files.concat(collectSourceFiles(fullPath, baseDir));
+    } else if (/\.[jt]sx?$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+      const relPath = path.relative(baseDir, fullPath).replace(/\\/g, "/");
+      files.push({
+        relPath: "src/" + relPath,
+        fullPath: fullPath.replace(/\\/g, "/"),
+      });
+    }
+  }
+  return files;
+}
+
+/**
+ * Generates JS code that registers all src/ modules into globalThis.__DINOU_ROUTE_MODULES__
+ * and their metadata (such as PPR support) into globalThis.__DINOU_ROUTE_METADATA__.
+ * @param {string} projectRoot Root directory of the project
+ * @param {string} relativeImportBase Relative path from generated output file to projectRoot
+ * @returns {string} JavaScript code
+ */
+function generateRouteModulesCode(projectRoot = process.cwd(), relativeImportBase = "../..") {
+  const srcDir = path.resolve(projectRoot, "src");
+  const files = collectSourceFiles(srcDir);
+
+  const configFilenames = ["dinou.config.js", "dinou.config.mjs", "dinou.config.cjs", "dinou.config.ts"];
+  let foundConfig = null;
+  for (const cf of configFilenames) {
+    if (fs.existsSync(path.resolve(projectRoot, cf))) {
+      foundConfig = cf;
+      break;
+    }
+  }
+
+  const lines = [
+    "// Auto-generated by Dinou Route Generator for Edge/Workers bundling",
+  ];
+
+  if (foundConfig) {
+    const configImportPath = `${relativeImportBase}/${foundConfig}`.replace(/\/+/g, "/");
+    lines.push(`import dinouConfigModule from ${JSON.stringify(configImportPath)};`);
+  }
+
+  lines.push("export const routeModules = {");
+
+  const routeMetadata = {};
+
+  for (const file of files) {
+    const importPath = `${relativeImportBase}/${file.relPath}`.replace(/\/+/g, "/");
+    lines.push(`  ${JSON.stringify(file.relPath)}: () => import(${JSON.stringify(importPath)}),`);
+
+    // Detect PPR from page_functions or layout_functions ONLY
+    if (/(?:^|\/)(?:page_functions|layout_functions|page\.functions|layout\.functions)\.[jt]sx?$/.test(file.relPath)) {
+      try {
+        const content = fs.readFileSync(file.fullPath, "utf8");
+        const isPpr = parseExports.parsePprConfig ? parseExports.parsePprConfig(content) : null;
+        if (isPpr !== null) {
+          routeMetadata[file.relPath] = { ppr: Boolean(isPpr) };
+        }
+      } catch (e) {}
+    }
+  }
+
+  lines.push("};");
+  lines.push("");
+  lines.push("export const routeMetadata = " + JSON.stringify(routeMetadata, null, 2) + ";");
+  lines.push("");
+  lines.push("if (typeof globalThis !== 'undefined') {");
+  lines.push("  globalThis.__DINOU_ROUTE_MODULES__ = {");
+  lines.push("    ...(globalThis.__DINOU_ROUTE_MODULES__ || {}),");
+  lines.push("    ...routeModules,");
+  lines.push("  };");
+  lines.push("  globalThis.__DINOU_ROUTE_METADATA__ = {");
+  lines.push("    ...(globalThis.__DINOU_ROUTE_METADATA__ || {}),");
+  lines.push("    ...routeMetadata,");
+  lines.push("  };");
+  if (foundConfig) {
+    lines.push("  const resolvedConfig = (dinouConfigModule && dinouConfigModule.default) ? dinouConfigModule.default : dinouConfigModule;");
+    lines.push("  globalThis.__DINOU_CONFIG__ = resolvedConfig;");
+  }
+  lines.push("}");
+  lines.push("");
+  if (foundConfig) {
+    lines.push("export const dinouConfig = (dinouConfigModule && dinouConfigModule.default) ? dinouConfigModule.default : dinouConfigModule;");
+  }
+  lines.push("export default routeModules;");
+
+  return lines.join("\n");
+}
+
+const { generateRouteTypes } = require("./generate-route-types.js");
+
+module.exports = {
+  collectSourceFiles,
+  generateRouteModulesCode,
+  generateRouteTypes,
+};

package/dinou/core/rsc-renderer.js

@@ -0,0 +1,90 @@
+// dinou/core/rsc-renderer.js
+// Universal RSC Stream Renderer supporting Node Streams and Web Streams (Cloudflare Workers / Edge).
+
+const { pathToFileURL } = require("url");
+
+const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+
+function isEdgeRuntime(options = {}) {
+  const rt =
+    (options && options.runtime) ||
+    (typeof globalThis !== "undefined" && globalThis.__DINOU_RUNTIME__) ||
+    (typeof process !== "undefined" && process.env && process.env.DINOU_RUNTIME);
+  if (
+    typeof rt === "string" &&
+    (rt === "edge" || rt === "deno-edge" || rt === "bun" || rt === "bun-bundle" || rt === "node-bundle" || rt.includes("edge") || rt.includes("bundle"))
+  ) {
+    return true;
+  }
+  return false;
+}
+
+let nodeRender = null;
+function getNodeRenderer() {
+  if (!nodeRender) {
+    nodeRender = isWebpack
+      ? require("react-server-dom-webpack/server")
+      : require("@roggc/react-server-dom-esm/server");
+  }
+  return nodeRender;
+}
+
+let edgeRender = null;
+function getEdgeRenderer() {
+  if (!edgeRender) {
+    try {
+      edgeRender = require("react-server-dom-webpack/server.edge");
+    } catch (e) {
+      edgeRender = require("react-server-dom-webpack/server");
+    }
+  }
+  return edgeRender;
+}
+
+/**
+ * Renders JSX / Model to an RSC Stream based on runtime environment.
+ * @param {*} model The React element tree or value to render
+ * @param {object} manifest The client component manifest
+ * @param {object} options Runtime options ({ runtime: "node" | "edge" })
+ * @returns {ReadableStream | { pipe: Function, abort: Function }}
+ */
+function renderRSCStream(model, manifest, options = {}) {
+  if (isEdgeRuntime(options)) {
+    const edge = getEdgeRenderer();
+    const clientManifest =
+      manifest ||
+      (typeof globalThis !== "undefined" && globalThis.__DINOU_CLIENT_MANIFEST__) ||
+      {};
+    return edge.renderToReadableStream(model, clientManifest, options);
+  }
+
+  const node = getNodeRenderer();
+  const manifestOrUrl = isWebpack
+    ? manifest
+    : (pathToFileURL(process.cwd()).href + "/");
+  return node.renderToPipeableStream(model, manifestOrUrl, options);
+}
+
+/**
+ * Pipes RSC rendering to a response bridge or returns a native Web Response directly.
+ * @param {*} model
+ * @param {object} bridge WebResponseBridge instance
+ * @param {object} manifest
+ * @param {object} options
+ */
+function pipeRSC(model, bridge, manifest, options = {}) {
+  if (isEdgeRuntime(options)) {
+    const stream = renderRSCStream(model, manifest, options);
+    bridge.setEdgeStream(stream);
+    return;
+  }
+
+  const { pipe } = renderRSCStream(model, manifest, options);
+  pipe(bridge);
+}
+
+module.exports = {
+  isEdgeRuntime,
+  renderRSCStream,
+  pipeRSC,
+};

package/dinou/core/run-ssg.js

@@ -0,0 +1,19 @@
+// dinou/core/run-ssg.js
+// Standalone Static Site Generation (SSG) runner for Dinou.
+process.env.NODE_ENV = "production";
+process.env.DINOU_RUNTIME = "node-bundle";
+
+const generateStatic = require("./generate-static.js");
+
+async function runSSG() {
+  await generateStatic();
+}
+
+if (require.main === module) {
+  runSSG().catch((err) => {
+    console.error("❌ [SSG] Static generation failed:", err);
+    process.exit(1);
+  });
+}
+
+module.exports = { runSSG };

package/dinou/core/scan-dependency-components.js

@@ -0,0 +1,218 @@
+// dinou/core/scan-dependency-components.js
+// Scans dependencies for React "use client" directives without recursively walking massive trees.
+
+const fs = require("fs");
+const path = require("path");
+
+function isSupportedClientModule(filePath, content) {
+  const norm = filePath.replace(/\\/g, "/");
+  if (!norm.includes("node_modules")) return true;
+  if (content === undefined && fs.existsSync(filePath)) {
+    try {
+      content = fs.readFileSync(filePath, "utf8");
+    } catch (e) {
+      return false;
+    }
+  }
+  if (typeof content !== "string") return false;
+  if (content.includes("System.register(") || content.includes("System.registerDynamic(")) return false;
+  if (content.includes("define.amd") && !content.includes("export ") && !content.includes("module.exports")) return false;
+  return true;
+}
+
+function scanDependencyForClientComponents(depDir, clientFiles, useClientRegex) {
+  const pkgJsonPath = path.join(depDir, "package.json");
+  if (!fs.existsSync(pkgJsonPath)) return;
+  let depPkg;
+  try {
+    depPkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+  } catch (e) {
+    return;
+  }
+
+  const depName = depPkg.name || "";
+  const hasReact =
+    depPkg.dependencies?.react ||
+    depPkg.peerDependencies?.react ||
+    depPkg.devDependencies?.react ||
+    (Array.isArray(depPkg.keywords) && depPkg.keywords.includes("react")) ||
+    depName.toLowerCase().includes("react");
+  if (!hasReact) return;
+
+  const candidateFiles = new Set();
+  if (typeof depPkg.main === "string") candidateFiles.add(path.resolve(depDir, depPkg.main));
+  if (typeof depPkg.module === "string") candidateFiles.add(path.resolve(depDir, depPkg.module));
+  if (depPkg.exports) {
+    function addExport(exp) {
+      if (typeof exp === "string") {
+        if (/\.[jt]sx?$/.test(exp)) candidateFiles.add(path.resolve(depDir, exp));
+      } else if (typeof exp === "object" && exp !== null) {
+        for (const v of Object.values(exp)) addExport(v);
+      }
+    }
+    addExport(depPkg.exports);
+  }
+
+  try {
+    const rootEntries = fs.readdirSync(depDir, { withFileTypes: true });
+    for (const entry of rootEntries) {
+      if (!entry.isDirectory() && /\.[jt]sx?$/.test(entry.name)) {
+        candidateFiles.add(path.join(depDir, entry.name));
+      }
+    }
+  } catch (e) {}
+
+  for (const filePath of candidateFiles) {
+    if (!fs.existsSync(filePath)) continue;
+    try {
+      const content = fs.readFileSync(filePath, "utf8");
+      if (useClientRegex.test(content.trim()) && isSupportedClientModule(filePath, content)) {
+        clientFiles.add(path.resolve(filePath));
+      }
+    } catch (e) {}
+  }
+}
+
+function scanProjectDependenciesForClientComponents(projectRoot, clientFiles, useClientRegex) {
+  try {
+    const pkgPath = path.resolve(projectRoot, "package.json");
+    if (!fs.existsSync(pkgPath)) return;
+
+    // Cache check based on package-lock.json or package.json
+    const cacheDir = path.resolve(projectRoot, ".dinou");
+    const cacheFile = path.join(cacheDir, "deps-client-cache.json");
+
+    const lockPath = path.resolve(projectRoot, "package-lock.json");
+    const targetLock = fs.existsSync(lockPath) ? lockPath : pkgPath;
+    let lockStat;
+    try {
+      lockStat = fs.statSync(targetLock);
+    } catch (e) {}
+
+    const signature = lockStat ? `${lockStat.size}-${Math.round(lockStat.mtimeMs)}` : null;
+
+    if (signature && fs.existsSync(cacheFile)) {
+      try {
+        const cache = JSON.parse(fs.readFileSync(cacheFile, "utf8"));
+        if (cache.signature === signature && Array.isArray(cache.clientFiles)) {
+          let allExist = true;
+          for (const f of cache.clientFiles) {
+            if (!fs.existsSync(f)) {
+              allExist = false;
+              break;
+            }
+          }
+          if (allExist) {
+            for (const f of cache.clientFiles) {
+              clientFiles.add(path.resolve(f));
+            }
+            return;
+          }
+        }
+      } catch (e) {}
+    }
+
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    const deps = Object.keys(pkg.dependencies || {});
+    for (const dep of deps) {
+      if (dep === "react" || dep === "react-dom" || dep === "dinou") continue;
+      const depDir = path.resolve(projectRoot, "node_modules", dep);
+      if (fs.existsSync(depDir)) {
+        scanDependencyForClientComponents(depDir, clientFiles, useClientRegex);
+      }
+    }
+
+    // Save discovered files to cache
+    if (signature) {
+      try {
+        if (!fs.existsSync(cacheDir)) {
+          fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        const discovered = [];
+        for (const f of clientFiles) {
+          const norm = f.replace(/\\/g, "/");
+          if (norm.includes("/node_modules/")) {
+            discovered.push(f);
+          }
+        }
+        fs.writeFileSync(cacheFile, JSON.stringify({ signature, clientFiles: discovered }), "utf8");
+      } catch (e) {}
+    }
+  } catch (e) {}
+}
+
+async function scanProjectDependenciesForClientComponentsAsync(projectRoot, clientFiles, useClientRegex) {
+  try {
+    const pkgPath = path.resolve(projectRoot, "package.json");
+    if (!fs.existsSync(pkgPath)) return;
+
+    // Cache check based on package-lock.json or package.json
+    const cacheDir = path.resolve(projectRoot, ".dinou");
+    const cacheFile = path.join(cacheDir, "deps-client-cache.json");
+
+    const lockPath = path.resolve(projectRoot, "package-lock.json");
+    const targetLock = fs.existsSync(lockPath) ? lockPath : pkgPath;
+    let lockStat;
+    try {
+      lockStat = fs.statSync(targetLock);
+    } catch (e) {}
+
+    const signature = lockStat ? `${lockStat.size}-${Math.round(lockStat.mtimeMs)}` : null;
+
+    if (signature && fs.existsSync(cacheFile)) {
+      try {
+        const cache = JSON.parse(fs.readFileSync(cacheFile, "utf8"));
+        if (cache.signature === signature && Array.isArray(cache.clientFiles)) {
+          let allExist = true;
+          for (const f of cache.clientFiles) {
+            if (!fs.existsSync(f)) {
+              allExist = false;
+              break;
+            }
+          }
+          if (allExist) {
+            for (const f of cache.clientFiles) {
+              clientFiles.add(path.resolve(f));
+            }
+            return;
+          }
+        }
+      } catch (e) {}
+    }
+
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    const deps = Object.keys(pkg.dependencies || {});
+    for (const dep of deps) {
+      if (dep === "react" || dep === "react-dom" || dep === "dinou") continue;
+      const depDir = path.resolve(projectRoot, "node_modules", dep);
+      if (fs.existsSync(depDir)) {
+        scanDependencyForClientComponents(depDir, clientFiles, useClientRegex);
+        await new Promise((resolve) => setImmediate(resolve));
+      }
+    }
+
+    // Save discovered files to cache
+    if (signature) {
+      try {
+        if (!fs.existsSync(cacheDir)) {
+          fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        const discovered = [];
+        for (const f of clientFiles) {
+          const norm = f.replace(/\\/g, "/");
+          if (norm.includes("/node_modules/")) {
+            discovered.push(f);
+          }
+        }
+        fs.writeFileSync(cacheFile, JSON.stringify({ signature, clientFiles: discovered }), "utf8");
+      } catch (e) {}
+    }
+  } catch (e) {}
+}
+
+module.exports = {
+  isSupportedClientModule,
+  scanDependencyForClientComponents,
+  scanProjectDependenciesForClientComponents,
+  scanProjectDependenciesForClientComponentsAsync,
+};

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

@@ -21,6 +21,9 @@ function createServerFunctionProxy(id) {
       const headers = {
         "x-server-function-call": "1",
       };
+      if (typeof window !== "undefined" && window.location) {
+        headers["x-dinou-current-path"] = window.location.pathname;
+      }
 
       const formDataIndex = args.findIndex((arg) => arg instanceof FormData);
 

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

@@ -21,6 +21,9 @@ export function createServerFunctionProxy(id) {
       const headers = {
         "x-server-function-call": "1",
       };
+      if (typeof window !== "undefined" && window.location) {
+        headers["x-dinou-current-path"] = window.location.pathname;
+      }
 
       const formDataIndex = args.findIndex((arg) => arg instanceof FormData);