dinou 6.1.1 → 7.1.0

package/cli.js

@@ -3,10 +3,8 @@
 const { program } = require("commander");
 const { execSync } = require("child_process");
 const path = require("path");
-const { pathToFileURL } = require("url");
 
 const dinouPath = path.resolve(__dirname, "dinou");
-const corePath = path.resolve(dinouPath, "core");
 const projectRoot = process.cwd();
 
 const runCommand = (command, options = {}) => {
@@ -18,146 +16,371 @@ const runCommand = (command, options = {}) => {
   }
 };
 
+// Helper paths
+const p = (rel) => path.join(dinouPath, rel);
+
+// --- DEV ---
+
 program
   .command("dev")
-  .description("Starts")
+  .description("Start development server with Esbuild")
+  .action(() => {
+    runCommand(`cross-env DINOU_BUILD_TOOL=esbuild node ${p("node/dev.mjs")}`);
+  });
+
+program
+  .command("dev:esbuild")
+  .description("Start development server with Esbuild")
+  .action(() => {
+    runCommand(`cross-env DINOU_BUILD_TOOL=esbuild node ${p("node/dev.mjs")}`);
+  });
+
+program
+  .command("dev:rollup")
+  .description("Start development server with Rollup")
+  .action(() => {
+    runCommand(`cross-env DINOU_BUILD_TOOL=rollup node ${p("node/dev.mjs")}`);
+  });
+
+program
+  .command("dev:webpack")
+  .description("Start development server with Webpack")
   .action(() => {
-    console.log("Starting...");
-    const startExpress = `node --conditions react-server --import ${
-      pathToFileURL(path.join(corePath, "register-loader.mjs")).href
-    } ${path.join(corePath, "server.js")}`;
-    const startDevServer = `node ${path.join(dinouPath, "esbuild/dev.mjs")}`;
-    runCommand(`npx concurrently "${startExpress}" "${startDevServer}"`);
+    runCommand(`cross-env DINOU_BUILD_TOOL=webpack node ${p("node/dev.mjs")}`);
   });
 
+// --- NODE (BUILD & START) ---
+
 program
   .command("build")
-  .description("Builds the app for production")
+  .description("Build the app for Node.js production (using esbuild)")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production node ${p("esbuild/build.mjs")} && node ${p("node/build.mjs")}`);
+  });
+
+program
+  .command("build:node")
+  .description("Build the app for Node.js production (using esbuild)")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production node ${p("esbuild/build.mjs")} && node ${p("node/build.mjs")}`);
+  });
+
+program
+  .command("build:node:esbuild")
+  .description("Build the app for Node.js with Esbuild")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production node ${p("esbuild/build.mjs")} && node ${p("node/build.mjs")}`);
+  });
+
+program
+  .command("build:node:rollup")
+  .description("Build the app for Node.js with Rollup")
   .action(() => {
-    console.log("Building the app...");
-    const esbuildPath = path.join(dinouPath, "esbuild/build.mjs");
-    runCommand(`cross-env NODE_ENV=production node ${esbuildPath}`);
+    runCommand(`cross-env NODE_ENV=production npx rollup -c ${p("rollup/rollup.config.js")} && node ${p("node/build.mjs")}`);
+  });
+
+program
+  .command("build:node:webpack")
+  .description("Build the app for Node.js with Webpack")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production npx webpack --config ${p("webpack/webpack.config.js")} && cross-env DINOU_BUILD_TOOL=webpack node ${p("node/build.mjs")}`);
   });
 
 program
   .command("start")
-  .description("Start the app in production mode")
+  .description("Start the app in production mode (Node.js)")
   .action(() => {
-    console.log("Starting the app...");
-    runCommand(
-      `cross-env NODE_ENV=production node --conditions react-server --import ${
-        pathToFileURL(path.join(corePath, "register-loader.mjs")).href
-      } ${path.join(corePath, "server.js")}`
-    );
+    runCommand(`cross-env NODE_ENV=production node ${p("adapters/node.mjs")}`);
   });
 
 program
-  .command("dev:esbuild")
-  .description("Starts")
+  .command("start:node")
+  .description("Start the app in production mode (Node.js)")
   .action(() => {
-    console.log("Starting...");
-    const startExpress = `node --conditions react-server --import ${
-      pathToFileURL(path.join(corePath, "register-loader.mjs")).href
-    } ${path.join(corePath, "server.js")}`;
-    const startDevServer = `node ${path.join(dinouPath, "esbuild/dev.mjs")}`;
-    runCommand(`npx concurrently "${startExpress}" "${startDevServer}"`);
+    runCommand(`cross-env NODE_ENV=production node ${p("adapters/node.mjs")}`);
   });
 
 program
-  .command("build:esbuild")
-  .description("Builds the app for production")
+  .command("start:node:esbuild")
+  .description("Start the app in production mode (Esbuild build)")
   .action(() => {
-    console.log("Building the app...");
-    const esbuildPath = path.join(dinouPath, "esbuild/build.mjs");
-    runCommand(`cross-env NODE_ENV=production node ${esbuildPath}`);
+    runCommand(`cross-env NODE_ENV=production node ${p("adapters/node.mjs")}`);
   });
 
 program
-  .command("start:esbuild")
-  .description("Start the app in production mode")
+  .command("start:node:rollup")
+  .description("Start the app in production mode (Rollup build)")
   .action(() => {
-    console.log("Starting the app...");
-    runCommand(
-      `cross-env NODE_ENV=production node --conditions react-server --import ${
-        pathToFileURL(path.join(corePath, "register-loader.mjs")).href
-      } ${path.join(corePath, "server.js")}`
-    );
+    runCommand(`cross-env NODE_ENV=production node ${p("adapters/node.mjs")}`);
   });
 
 program
-  .command("dev:rollup")
-  .description("Starts")
+  .command("start:node:webpack")
+  .description("Start the app in production mode (Webpack build)")
   .action(() => {
-    console.log("Starting...");
-    const startExpress = `node --conditions react-server --import ${
-      pathToFileURL(path.join(corePath, "register-loader.mjs")).href
-    } ${path.join(corePath, "server.js")}`;
-    const startDevServer = `rollup -c ${path.join(
-      dinouPath,
-      "rollup/rollup.config.js"
-    )} -w`;
-    runCommand(`npx concurrently "${startExpress}" "${startDevServer}"`);
+    runCommand(`cross-env NODE_ENV=production DINOU_BUILD_TOOL=webpack node ${p("adapters/node.mjs")}`);
   });
 
+// --- CLOUDFLARE WORKERS ---
+
 program
-  .command("build:rollup")
-  .description("Builds the app for production")
+  .command("build:cloudflare")
+  .description("Build the app for Cloudflare Workers (using esbuild)")
   .action(() => {
-    console.log("Building the app...");
-    const configPath = path.join(dinouPath, "rollup/rollup.config.js");
-    runCommand(`cross-env NODE_ENV=production npx rollup -c ${configPath}`);
+    runCommand(`cross-env NODE_ENV=production node ${p("esbuild/build.mjs")} && node ${p("cloudflare/build.mjs")}`);
   });
 
 program
-  .command("start:rollup")
-  .description("Start the app in production mode")
+  .command("build:cloudflare:esbuild")
+  .description("Build the app for Cloudflare Workers with Esbuild")
   .action(() => {
-    console.log("Starting the app...");
-    runCommand(
-      `cross-env NODE_ENV=production node --conditions react-server --import ${
-        pathToFileURL(path.join(corePath, "register-loader.mjs")).href
-      } ${path.join(corePath, "server.js")}`
-    );
+    runCommand(`cross-env NODE_ENV=production node ${p("esbuild/build.mjs")} && node ${p("cloudflare/build.mjs")}`);
   });
 
 program
-  .command("dev:webpack")
-  .description("Starts")
+  .command("build:cloudflare:rollup")
+  .description("Build the app for Cloudflare Workers with Rollup")
   .action(() => {
-    console.log("Starting...");
-    const startExpress = `cross-env DINOU_BUILD_TOOL=webpack node --conditions react-server --import ${
-      pathToFileURL(path.join(corePath, "register-loader.mjs")).href
-    } ${path.join(corePath, "server.js")}`;
-    const startDevServer = `webpack serve --config ${path.join(
-      dinouPath,
-      "webpack/webpack.config.js"
-    )}`;
-    runCommand(`npx concurrently "${startExpress}" "${startDevServer}"`);
+    runCommand(`cross-env NODE_ENV=production npx rollup -c ${p("rollup/rollup.config.js")} && node ${p("cloudflare/build.mjs")}`);
   });
 
 program
-  .command("build:webpack")
-  .description("Builds the app for production")
+  .command("build:cloudflare:webpack")
+  .description("Build the app for Cloudflare Workers with Webpack")
   .action(() => {
-    console.log("Building the app...");
-    const configPath = path.join(dinouPath, "webpack/webpack.config.js");
-    runCommand(
-      `cross-env NODE_ENV=production npx webpack --config ${configPath}`
-    );
+    runCommand(`cross-env NODE_ENV=production npx webpack --config ${p("webpack/webpack.config.js")} && cross-env DINOU_BUILD_TOOL=webpack node ${p("cloudflare/build.mjs")}`);
   });
 
+// --- DENO DEPLOY / EDGE ---
+
+const runDenoBuild = (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("deno/build.mjs")} && deno run --unstable-kv --allow-net --allow-read --allow-write --allow-env ${p("deno/seed-kv.js")}`;
+};
+
 program
-  .command("start:webpack")
-  .description("Start the app in production mode")
+  .command("build:deno")
+  .description("Build the app for Deno Deploy / Edge (using esbuild)")
+  .action(() => { runCommand(runDenoBuild("esbuild")); });
+
+program
+  .command("build:deno:esbuild")
+  .description("Build the app for Deno Deploy with Esbuild")
+  .action(() => { runCommand(runDenoBuild("esbuild")); });
+
+program
+  .command("build:deno:rollup")
+  .description("Build the app for Deno Deploy with Rollup")
+  .action(() => { runCommand(runDenoBuild("rollup")); });
+
+program
+  .command("build:deno:webpack")
+  .description("Build the app for Deno Deploy with Webpack")
+  .action(() => { runCommand(runDenoBuild("webpack")); });
+
+program
+  .command("start:deno")
+  .description("Start the app in production mode with Deno")
   .action(() => {
-    console.log("Starting the app...");
-    runCommand(
-      `cross-env NODE_ENV=production DINOU_BUILD_TOOL=webpack node --conditions react-server --import ${
-        pathToFileURL(path.join(corePath, "register-loader.mjs")).href
-      } ${path.join(corePath, "server.js")}`
-    );
+    runCommand(`deno run --unstable-kv --allow-net --allow-read --allow-write --allow-env --allow-sys ${p("adapters/deno.js")}`);
   });
 
+// Deno compile commands
+const denoTargets = [
+  { name: "", flags: "", outfile: "dist/deno-server" },
+  { name: ":linux", flags: "--target x86_64-unknown-linux-gnu ", outfile: "dist/deno-server-linux" },
+  { name: ":linux_arm", flags: "--target aarch64-unknown-linux-gnu ", outfile: "dist/deno-server-linux-arm" },
+  { name: ":mac", flags: "--target aarch64-apple-darwin ", outfile: "dist/deno-server-mac" },
+  { name: ":win", flags: "--target x86_64-pc-windows-msvc ", outfile: "dist/deno-server-win" },
+];
+
+for (const t of denoTargets) {
+  for (const b of ["esbuild", "rollup", "webpack"]) {
+    const cmdNames = b === "esbuild"
+      ? [`build:deno:compile${t.name}`, `build:deno:compile${t.name}:esbuild`]
+      : [`build:deno:compile${t.name}:${b}`];
+    for (const cmdName of cmdNames) {
+      program
+        .command(cmdName)
+        .description(`Compile standalone Deno executable (${t.name || "host"}, ${b})`)
+        .action(() => {
+          runCommand(`${runDenoBuild(b)} && deno compile ${t.flags}--no-check --no-config --allow-net --allow-read --allow-write --allow-env --allow-sys --output ${t.outfile} .dinou/deno/main.js`);
+        });
+    }
+  }
+}
+
+// --- BUN (STANDARD) ---
+
+const runBunBuild = (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("bun/build.mjs")}`;
+};
+
+program
+  .command("build:bun")
+  .description("Build the app for Bun (using esbuild)")
+  .action(() => { runCommand(runBunBuild("esbuild")); });
+
+program
+  .command("build:bun:esbuild")
+  .description("Build the app for Bun with Esbuild")
+  .action(() => { runCommand(runBunBuild("esbuild")); });
+
+program
+  .command("build:bun:rollup")
+  .description("Build the app for Bun with Rollup")
+  .action(() => { runCommand(runBunBuild("rollup")); });
+
+program
+  .command("build:bun:webpack")
+  .description("Build the app for Bun with Webpack")
+  .action(() => { runCommand(runBunBuild("webpack")); });
+
+program
+  .command("start:bun")
+  .description("Start the app in production mode with Bun")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production bun ${p("adapters/bun.js")}`);
+  });
+
+program
+  .command("start:bun:esbuild")
+  .description("Start the app in production mode with Bun (Esbuild)")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production bun ${p("adapters/bun.js")}`);
+  });
+
+program
+  .command("start:bun:rollup")
+  .description("Start the app in production mode with Bun (Rollup)")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production bun ${p("adapters/bun.js")}`);
+  });
+
+program
+  .command("start:bun:webpack")
+  .description("Start the app in production mode with Bun (Webpack)")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production DINOU_BUILD_TOOL=webpack bun ${p("adapters/bun.js")}`);
+  });
+
+const bunTargets = [
+  { 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" },
+];
+
+for (const t of bunTargets) {
+  for (const b of ["esbuild", "rollup", "webpack"]) {
+    const cmdNames = b === "esbuild"
+      ? [`build:bun:compile${t.name}`, `build:bun:compile${t.name}:esbuild`]
+      : [`build:bun:compile${t.name}:${b}`];
+    for (const cmdName of cmdNames) {
+      program
+        .command(cmdName)
+        .description(`Compile standalone Bun executable (${t.name || "host"}, ${b})`)
+        .action(() => {
+          runCommand(`${runBunBuild(b)} && bun build --compile ${t.flags}.dinou/bun/server.js --outfile ${t.outfile}`);
+        });
+    }
+  }
+}
+
+// --- BUN (PURE) ---
+
+const runBunPureBuild = (bundler) => {
+  if (bundler === "rollup") {
+    return `cross-env NODE_ENV=production npx rollup -c ${p("rollup/rollup.config.js")} && bun ${p("bun/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("bun/build.mjs")}`;
+  }
+  return `cross-env NODE_ENV=production bun ${p("esbuild/build.mjs")} && bun ${p("bun/build.mjs")}`;
+};
+
+program
+  .command("build:bun:pure")
+  .description("Build the app with 100% Bun (using esbuild)")
+  .action(() => { runCommand(runBunPureBuild("esbuild")); });
+
+program
+  .command("build:bun:pure:esbuild")
+  .description("Build the app with 100% Bun (Esbuild)")
+  .action(() => { runCommand(runBunPureBuild("esbuild")); });
+
+program
+  .command("build:bun:pure:rollup")
+  .description("Build the app with 100% Bun (Rollup)")
+  .action(() => { runCommand(runBunPureBuild("rollup")); });
+
+program
+  .command("build:bun:pure:webpack")
+  .description("Build the app with 100% Bun (Webpack)")
+  .action(() => { runCommand(runBunPureBuild("webpack")); });
+
+for (const t of bunTargets) {
+  for (const b of ["esbuild", "rollup", "webpack"]) {
+    const cmdNames = b === "esbuild"
+      ? [`build:bun:pure:compile${t.name}`, `build:bun:pure:compile${t.name}:esbuild`]
+      : [`build:bun:pure:compile${t.name}:${b}`];
+    for (const cmdName of cmdNames) {
+      program
+        .command(cmdName)
+        .description(`Compile standalone Bun Pure executable (${t.name || "host"}, ${b})`)
+        .action(() => {
+          runCommand(`${runBunPureBuild(b)} && bun build --compile ${t.flags}.dinou/bun/server.js --outfile ${t.outfile}`);
+        });
+    }
+  }
+}
+
+// --- EXPORT STATIC ---
+
+program
+  .command("export-static")
+  .description("Export standalone static website (using esbuild)")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production node ${p("esbuild/build.mjs")} && node ${p("core/export-static.mjs")}`);
+  });
+
+program
+  .command("export-static:esbuild")
+  .description("Export standalone static website with Esbuild")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production node ${p("esbuild/build.mjs")} && node ${p("core/export-static.mjs")}`);
+  });
+
+program
+  .command("export-static:rollup")
+  .description("Export standalone static website with Rollup")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production npx rollup -c ${p("rollup/rollup.config.js")} && node ${p("core/export-static.mjs")}`);
+  });
+
+program
+  .command("export-static:webpack")
+  .description("Export standalone static website with Webpack")
+  .action(() => {
+    runCommand(`cross-env NODE_ENV=production npx webpack --config ${p("webpack/webpack.config.js")} && node ${p("core/export-static.mjs")}`);
+  });
+
+// --- EJECT ---
+
 program
   .command("eject")
   .description("Copy the framework to the root of the project")

package/dinou/adapters/bun.js

@@ -0,0 +1,62 @@
+// dinou/adapters/bun.js
+// Native Bun Adapter for Dinou v7 (Pre-bundled AOT).
+// Serves the standalone pre-bundled server from .dinou/bun/server.js.
+
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { pathToFileURL } from "node:url";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+if (typeof globalThis.AsyncLocalStorage === "undefined" && typeof AsyncLocalStorage !== "undefined") {
+  globalThis.AsyncLocalStorage = AsyncLocalStorage;
+}
+
+const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : ".";
+const bundlePath = path.resolve(cwd, ".dinou/bun/server.js");
+
+let bundleModule = null;
+if (fs.existsSync(bundlePath)) {
+  try {
+    bundleModule = await import(pathToFileURL(bundlePath).href);
+  } catch (e) {
+    console.error("[Dinou Bun Adapter] Failed to load .dinou/bun/server.js:", e);
+  }
+}
+
+const PORT = Number(process.env.PORT || 3000);
+const IDLE_TIMEOUT = Number(process.env.IDLE_TIMEOUT || 120);
+
+export async function fetch(req) {
+  if (bundleModule && typeof bundleModule.fetch === "function") {
+    return bundleModule.fetch(req);
+  }
+  if (bundleModule && bundleModule.default && typeof bundleModule.default.fetch === "function") {
+    return bundleModule.default.fetch(req);
+  }
+  return new Response(
+    "Dinou Bun bundle not found. Please run 'npm run build:bun' first.",
+    {
+      status: 500,
+      headers: { "content-type": "text/plain; charset=utf-8" },
+    }
+  );
+}
+
+export default {
+  port: PORT,
+  fetch,
+  idleTimeout: IDLE_TIMEOUT,
+};
+
+if (typeof process !== "undefined") {
+  process.on("SIGTERM", () => process.exit(0));
+  process.on("SIGINT", () => process.exit(0));
+  if (process.stdin && typeof process.stdin.on === "function") {
+    process.stdin.on("end", () => process.exit(0));
+    process.stdin.on("close", () => process.exit(0));
+    if (typeof process.stdin.unref === "function") {
+      process.stdin.unref();
+    }
+  }
+}
+

package/dinou/adapters/cloudflare.js

@@ -0,0 +1,65 @@
+// dinou/adapters/cloudflare.js
+// Cloudflare Workers Adapter for Dinou v7.
+// Universal edge entry point with KV storage, route registry, and Web Streams.
+
+import { handleRequest } from "../core/handler.js";
+import {
+  getStorageAdapter,
+  setStorageAdapter,
+  CloudflareKVStorage,
+  MemoryStorage,
+} from "../core/storage-adapter.js";
+
+// Ensure Edge runtime flag is set globally
+if (typeof globalThis !== "undefined") {
+  globalThis.__DINOU_RUNTIME__ = "edge";
+}
+
+let storageInitialized = false;
+
+export default {
+  /**
+   * Cloudflare Workers fetch handler
+   * @param {Request} request 
+   * @param {object} env Bindings (KV, D1, Environment variables)
+   * @param {object} ctx Execution context (waitUntil, passThroughOnException)
+   * @returns {Promise<Response>}
+   */
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+    if (url.pathname.startsWith("/cdn-cgi/")) {
+      return new Response(null, { status: 404 });
+    }
+
+    if (!storageInitialized) {
+      if (env && env.DINOU_CACHE) {
+        setStorageAdapter(new CloudflareKVStorage(env.DINOU_CACHE));
+      } else {
+        setStorageAdapter(new MemoryStorage());
+      }
+      storageInitialized = true;
+    }
+
+    const isRSCPayload = url.pathname.includes("____rsc_");
+    const isServerFunction = url.pathname.includes("____server_function____") || request.headers.get("x-server-function-call") === "1";
+
+    // Static assets: files with extensions like .js, .css, .png, etc. (excluding document .html and RSC/server-functions)
+    const staticExtRegex = /\.(js|mjs|cjs|css|png|jpg|jpeg|gif|svg|ico|webp|avif|woff|woff2|ttf|eot|otf|wasm|map|txt|webmanifest)$/i;
+    const isStaticAsset = staticExtRegex.test(url.pathname) || url.pathname.startsWith("/assets/") || url.pathname.startsWith("/_dinou/");
+
+    if (!isRSCPayload && !isServerFunction && isStaticAsset && env && env.ASSETS && (request.method === "GET" || request.method === "HEAD")) {
+      try {
+        const assetRes = await env.ASSETS.fetch(request.clone ? request.clone() : request);
+        if (assetRes && assetRes.status < 400) {
+          return assetRes;
+        }
+      } catch (e) {}
+    }
+
+    return handleRequest(request, {
+      env,
+      ctx,
+      runtime: "edge",
+    });
+  },
+};

package/dinou/adapters/deno.js

@@ -0,0 +1,48 @@
+// dinou/adapters/deno.js
+// Native Deno & Deno Deploy Adapter for Dinou v7.
+// Supports standalone containers, Deno CLI, and Deno Deploy Edge.
+
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { pathToFileURL } from "node:url";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+if (typeof globalThis.AsyncLocalStorage === "undefined" && typeof AsyncLocalStorage !== "undefined") {
+  globalThis.AsyncLocalStorage = AsyncLocalStorage;
+}
+
+const cwd = typeof Deno !== "undefined" ? Deno.cwd() : process.cwd();
+const mainBundlePath = path.resolve(cwd, ".dinou/deno/main.js");
+
+let mainModule = null;
+if (fs.existsSync(mainBundlePath)) {
+  try {
+    mainModule = await import(pathToFileURL(mainBundlePath).href);
+  } catch (e) {
+    console.error("[Dinou Deno Adapter] Failed to load .dinou/deno/main.js:", e);
+  }
+}
+
+const PORT = Number(
+  (typeof Deno !== "undefined" ? Deno.env.get("PORT") : process.env.PORT) || 3000
+);
+
+export async function fetch(req) {
+  if (mainModule && typeof mainModule.fetch === "function") {
+    return mainModule.fetch(req);
+  }
+  return new Response("Dinou bundle not found. Please run 'npm run build:deno' first.", {
+    status: 500,
+    headers: { "content-type": "text/plain; charset=utf-8" },
+  });
+}
+
+// Start standalone server if run directly in Deno
+if (typeof Deno !== "undefined" && typeof Deno.serve === "function" && import.meta.main) {
+  Deno.serve({ port: PORT }, fetch);
+}
+
+export default {
+  port: PORT,
+  fetch,
+};