dinou 6.1.0 → 7.0.0

package/dinou/rollup/react-refresh/esm-hmr/client.js

@@ -96,35 +96,49 @@ class HotModuleState {
 }
 
 export function createHotContext(id) {
-  const existing = REGISTERED_MODULES[id];
+  const normId = id.startsWith("/") ? id : "/" + id;
+  const existing = REGISTERED_MODULES[normId] || REGISTERED_MODULES[id];
   if (existing) {
-    existing.lock();
+    existing.isLocked = false;
+    existing.acceptCallbacks = [];
     return existing;
   }
-  const state = new HotModuleState(id);
+  const state = new HotModuleState(normId);
+  REGISTERED_MODULES[normId] = state;
   REGISTERED_MODULES[id] = state;
   return state;
 }
 
 async function applyUpdate(id) {
-  const state = REGISTERED_MODULES[id];
+  const clean = id ? id.split("?")[0] : "";
+  const normId = clean.startsWith("/") ? clean : "/" + clean;
+  const state = REGISTERED_MODULES[normId] || REGISTERED_MODULES[clean] || REGISTERED_MODULES[id];
   if (!state || state.isDeclined) {
     return false;
   }
 
-  const acceptCallbacks = state.acceptCallbacks;
-  const disposeCallbacks = state.disposeCallbacks;
+  const acceptCallbacks = [...state.acceptCallbacks];
+  const disposeCallbacks = [...state.disposeCallbacks];
   state.disposeCallbacks = [];
   state.data = {};
 
-  disposeCallbacks.forEach((callback) => callback());
+  disposeCallbacks.forEach((callback) => {
+    try {
+      callback();
+    } catch (e) {
+      console.warn("[ESM-HMR] dispose callback error:", e);
+    }
+  });
 
   const updateID = Date.now();
 
   for (const { deps, callback: acceptCallback } of acceptCallbacks) {
     const [module, ...depModules] = await Promise.all([
-      import(`/${id}` + `?mtime=${updateID}`),
-      ...deps.map((d) => import(`/${d}` + `?mtime=${updateID}`)),
+      import(normId + `?mtime=${updateID}`),
+      ...deps.map((d) => {
+        const depId = d.startsWith("/") ? d : "/" + d;
+        return import(depId + `?mtime=${updateID}`);
+      }),
     ]);
     acceptCallback({ module, deps: depModules });
   }
@@ -142,18 +156,60 @@ socket.addEventListener("message", ({ data: _data }) => {
     return;
   }
 
+  if (data.type === "rsc-update") {
+    if (typeof window !== "undefined" && typeof window.__DINOU_ROUTER_REFRESH__ === "function") {
+      window.__DINOU_ROUTER_REFRESH__();
+      return;
+    }
+    reload();
+    return;
+  }
+
+  if (
+    data.type === "style-update" ||
+    (data.type === "update" && data.url && (data.url.endsWith(".css") || data.url.includes("styles.css")))
+  ) {
+    const targetUrl = data.url ? data.url.split("?")[0] : "";
+    const links = document.querySelectorAll('link[rel="stylesheet"]');
+    for (const link of links) {
+      const rawHref = link.getAttribute("href");
+      if (!rawHref) continue;
+      const cleanHref = rawHref.split("?")[0];
+      if (!targetUrl || cleanHref.endsWith(targetUrl) || targetUrl.endsWith(cleanHref) || cleanHref.includes("styles.css")) {
+        const nextUrl = new URL(link.href, window.location.origin);
+        nextUrl.searchParams.set("t", String(Date.now()));
+        link.href = nextUrl.href;
+      }
+    }
+    return;
+  }
+
   if (data.type !== "update") {
     return;
   }
 
+  const tRecv = Date.now();
+  const isDebug = typeof window !== "undefined" && Boolean(window.__DINOU_DEBUG__);
+
+  if (isDebug) {
+    console.log(`⏱️ [BROWSER HMR] Received update for ${data.url} at ${new Date().toTimeString().slice(0, 8)}.${String(Date.now() % 1000).padStart(3, '0')}`);
+  }
+
   applyUpdate(data.url)
     .then((ok) => {
       if (!ok) {
+        if (isDebug) console.warn(`⏱️ [BROWSER HMR] applyUpdate returned false, falling back to full reload!`);
         reload();
+      } else {
+        if (isDebug) {
+          console.log(`⏱️ [BROWSER HMR] Fast Refresh finished applying in ${Date.now() - tRecv}ms!`);
+        } else {
+          console.log(`[ESM-HMR] hot updated: ${data.url}`);
+        }
       }
     })
     .catch((err) => {
-      console.error(err);
+      console.error(`[ESM-HMR] applyUpdate error:`, err);
       reload();
     });
 });

package/dinou/rollup/react-refresh/esm-hmr/server.js

@@ -16,7 +16,7 @@ class EsmHmrEngine {
     this.dependencyTree = map;
     const wss = options.server
       ? new WebSocket.Server({ noServer: true })
-      : new WebSocket.Server({ port: 3001 });
+      : new WebSocket.Server({ port: options.port || Number(process.env.HMR_PORT) || 3001 });
 
     if (options.server) {
       options.server.on("upgrade", (req, socket, head) => {

package/dinou/rollup/react-refresh/is-react-refresh-boundary.js

@@ -9,13 +9,32 @@ export function isReactRefreshBoundary(RefreshRuntime, moduleExports) {
   let hasExports = false;
   let areAllExportsComponents = true;
   for (const key in moduleExports) {
-    if (key === "__esModule") continue;
+    if (
+      key === "__esModule" ||
+      key === "metadata" ||
+      key === "revalidate" ||
+      key === "dynamic" ||
+      key === "dynamicParams" ||
+      key === "fetchCache" ||
+      key === "preferredRegion" ||
+      key === "runtime" ||
+      key === "maxDuration" ||
+      key === "generateStaticParams" ||
+      key === "generateMetadata" ||
+      key === "frontmatter" ||
+      key === "toc" ||
+      key === "headings"
+    ) {
+      continue;
+    }
 
     hasExports = true;
-    const desc = Object.getOwnPropertyDescriptor(moduleExports, key);
-    if (desc && desc.get) return false;
-
-    const exportValue = moduleExports[key];
+    let exportValue;
+    try {
+      exportValue = moduleExports[key];
+    } catch (e) {
+      return false;
+    }
     if (!RefreshRuntime.isLikelyComponentType(exportValue)) {
       areAllExportsComponents = false;
     }

package/dinou/rollup/react-refresh/react-refresh-runtime.js

@@ -1,22 +1,29 @@
 import RefreshRuntime from "/refresh.js";
 import { isReactRefreshBoundary } from "./is-react-refresh-boundary";
 
+const runtime = RefreshRuntime?.default || RefreshRuntime;
+
 if (
   typeof window !== "undefined" &&
   !window.__REACT_REFRESH_RUNTIME_INSTALLED__
 ) {
-  RefreshRuntime.injectIntoGlobalHook(window);
-  window.$RefreshReg$ = () => {};
-  window.$RefreshSig$ = () => (type) => type;
+  runtime.injectIntoGlobalHook(window);
+  window.__reactRefreshRuntime = runtime;
+  window.$RefreshReg$ = (type, id) => {
+    runtime?.register(type, id);
+  };
+  window.$RefreshSig$ = runtime?.createSignatureFunctionForTransform
+    ? runtime.createSignatureFunctionForTransform.bind(runtime)
+    : () => (type) => type;
   window.__REACT_REFRESH_RUNTIME_INSTALLED__ = true;
 
   let refreshTimeout;
-  window.performReactRefresh = RefreshRuntime.performReactRefresh;
+  window.performReactRefresh = runtime.performReactRefresh;
   window.__debouncePerformReactRefresh = () => {
     clearTimeout(refreshTimeout);
     refreshTimeout = setTimeout(() => {
       try {
-        RefreshRuntime.performReactRefresh();
+        runtime.performReactRefresh();
       } catch (err) {
         console.warn("React Refresh failed:", err);
       }
@@ -24,5 +31,5 @@ if (
   };
 
   window.__isReactRefreshBoundary = (moduleExports) =>
-    isReactRefreshBoundary(RefreshRuntime, moduleExports);
+    isReactRefreshBoundary(runtime, moduleExports);
 }

package/dinou/rollup/react-refresh/react-refresh-wrap-modules.js

@@ -1,3 +1,15 @@
+const frameworkEntries = new Set([
+  "main.js",
+  "runtime.js",
+  "refresh.js",
+  "serverFunctionProxy.js",
+  "dinouClientRedirect.js",
+  "dinouLink.js",
+  "dinouSlot.js",
+  "__hmr_client__.js",
+  "_commonjsHelpers.js",
+]);
+
 function reactRefreshWrapModules() {
   return {
     name: "react-refresh-wrap-modules",
@@ -5,35 +17,67 @@ function reactRefreshWrapModules() {
       if (
         !chunk ||
         !/\.(jsx?|tsx?)$/.test(chunk.fileName) ||
+        frameworkEntries.has(chunk.fileName) ||
         chunk.fileName.includes("refresh.js") ||
         chunk.fileName.includes("runtime.js") ||
-        chunk.fileName.includes("_commonjsHelpers.js")
+        chunk.fileName.includes("_commonjsHelpers")
       ) {
         return null;
       }
-      const safeId = JSON.stringify(chunk.fileName);
-      const wrappedCode = `
-import RefreshRuntime from "/refresh.js";
 
+      // Only wrap user component chunks that contain actual app code (not third-party libraries)
+      const modulePaths = Object.keys(chunk.modules || {});
+      const hasUserCode = modulePaths.some(
+        (p) =>
+          !p.includes("node_modules") &&
+          !p.includes("dinou[\\/]core") &&
+          !p.includes("dinou[\\/]rollup") &&
+          !p.includes("dinou[\\/]esbuild") &&
+          !p.includes("dinou[\\/]webpack") &&
+          !p.includes("dinou/core") &&
+          !p.includes("dinou/rollup") &&
+          !p.includes("dinou/esbuild") &&
+          !p.includes("dinou/webpack")
+      );
+
+      if (!hasUserCode) {
+        return null;
+      }
+
+      const urlId = "/" + chunk.fileName;
+      const safeId = JSON.stringify(urlId);
+      const wrappedCode = `
+const RefreshRuntime = window.__reactRefreshRuntime;
+const actualRuntime = RefreshRuntime?.default || RefreshRuntime;
 let prevRefreshReg = window.$RefreshReg$;
 let prevRefreshSig = window.$RefreshSig$;
 
 window.$RefreshReg$ = (type, id) => {
-  RefreshRuntime.register(type, ${safeId} + '#' + id);
+  const fullId = (id && id.includes('#')) ? id : (${safeId} + '#' + id);
+  actualRuntime?.register(type, fullId);
 };
-window.$RefreshSig$ = RefreshRuntime?.createSignatureFunctionForTransform;
+window.$RefreshSig$ = (actualRuntime?.createSignatureFunctionForTransform)
+  ? actualRuntime.createSignatureFunctionForTransform.bind(actualRuntime)
+  : (prevRefreshSig || (() => (type) => type));
+
+if (!import.meta.hot) import.meta.hot = window.__hotContext?.(${safeId});
 
 // --- original code ---
 ${code}
 // --- end original code ---
 
-window.$RefreshReg$ = prevRefreshReg;
-window.$RefreshSig$ = prevRefreshSig;
-
 if (import.meta.hot) {
-  import.meta.hot.accept();
-  window.__debouncePerformReactRefresh?.();
+  import.meta.hot.accept(({ module }) => {
+    if (window.__isReactRefreshBoundary && window.__isReactRefreshBoundary(module)) {
+      window.__debouncePerformReactRefresh?.();
+    } else {
+      import.meta.hot.invalidate();
+    }
+  });
 }
+
+window.$RefreshReg$ = prevRefreshReg;
+window.$RefreshSig$ = prevRefreshSig;
 `;
 
       return {
@@ -45,3 +89,4 @@ if (import.meta.hot) {
 }
 
 module.exports = reactRefreshWrapModules;
+

package/dinou/rollup/react-refresh/rollup-plugin-esm-hmr.js

@@ -6,22 +6,40 @@ const { createServer } = require("node:http");
 const changedIds = new Set();
 const pendingUpdateUrls = new Set();
 let needsFullReload = false;
+let hasPendingCssUpdate = false;
+
+function normalizePath(p) {
+  return path.resolve(p).replace(/\\/g, "/").toLowerCase();
+}
+
+let activeServer = null;
+let activeHmrEngine = null;
+
 function esmHmrPlugin() {
-  let hmrEngine;
-  let serverStarted = false;
+  let hmrEngine = activeHmrEngine;
 
   return {
     name: "esm-hmr",
 
     buildStart() {
-      if (!serverStarted) {
-        const server = createServer();
-        hmrEngine = new EsmHmrEngine({ server });
-        server.listen(3001, () => {
-          // console.log("[esm-hmr] WebSocket server listening on port 3001");
+      if (!activeHmrEngine) {
+        const hmrPort = Number(
+          process.env.HMR_PORT || (Number(process.env.PORT || 3000) + 1)
+        );
+        activeServer = createServer();
+        activeServer.on("error", (err) => {
+          if (err.code === "EADDRINUSE") {
+            console.warn(`⚠️ [Rollup HMR] Port ${hmrPort} already in use, reusing existing listener.`);
+          } else {
+            console.error("❌ [Rollup HMR Server Error]:", err);
+          }
+        });
+        activeHmrEngine = new EsmHmrEngine({ server: activeServer });
+        activeServer.listen(hmrPort, () => {
+          // console.log(`[esm-hmr] WebSocket server listening on port ${hmrPort}`);
         });
-        serverStarted = true;
       }
+      hmrEngine = activeHmrEngine;
     },
 
     renderChunk(code, chunk) {
@@ -34,84 +52,194 @@ function esmHmrPlugin() {
         return null;
       }
 
-      const acceptsHmr = code.includes("import.meta.hot.accept");
       const imports = Array.from(code.matchAll(/import\s+["'](.+?)["']/g)).map(
         (m) => m[1]
       );
       const normalizedId = chunk.fileName;
-      hmrEngine.setEntry(normalizedId, imports, true);
+      const urlId = "/" + chunk.fileName;
+      hmrEngine?.setEntry(urlId, imports, true);
+      hmrEngine?.setEntry(normalizedId, imports, true);
 
       const isClientEntry = normalizedId === "main.js";
 
-      let injectCode = "";
-
-      // 🔥 Inject client HMR runtime if it's the entry
+      // Inject client HMR runtime if it's the entry
       if (isClientEntry && !code.includes("/__hmr_client__.js")) {
-        injectCode += `import { createHotContext } from "/__hmr_client__.js";window.__hotContext = createHotContext;\n`;
-      }
-
-      // 🔥 Inject import.meta.hot definition if user accepts HMR
-      if (acceptsHmr) {
-        const safeId = JSON.stringify(normalizedId);
-        injectCode += `if (!import.meta.hot) import.meta.hot = window.__hotContext?.(${safeId});\n`;
-      }
-
-      if (injectCode) {
-        code = injectCode + code;
+        return {
+          code: `import { createHotContext } from "/__hmr_client__.js";window.__hotContext = createHotContext;\n` + code,
+          map: null,
+        };
       }
 
-      return {
-        code,
-        map: null,
-      };
+      return null;
     },
 
     watchChange(id) {
-      changedIds.add(id);
+      changedIds.add(normalizePath(id));
     },
 
     generateBundle(options, bundle) {
       const clientPath = path.resolve(__dirname, "./esm-hmr/client.js");
+      let clientSource = fs.readFileSync(clientPath, "utf-8");
+      const isDebug =
+        process.env.DINOU_DEBUG === "true" ||
+        process.env.DINOU_DEBUG === "1" ||
+        process.env.DEBUG === "true" ||
+        process.env.DEBUG === "1";
+      if (isDebug) {
+        clientSource = "window.__DINOU_DEBUG__ = true;\n" + clientSource;
+      }
       this.emitFile({
         type: "asset",
         fileName: "__hmr_client__.js",
-        source: fs.readFileSync(clientPath, "utf-8"),
+        source: clientSource,
       });
-    },
-    writeBundle(_options, bundle) {
-      for (const [fileName, chunkInfo] of Object.entries(bundle)) {
-        for (const modulePath of Object.keys(chunkInfo.modules ?? {})) {
-          if (changedIds.has(path.resolve(modulePath))) {
-            const entry = hmrEngine.getEntry(fileName);
-            if (entry?.isHmrAccepted) {
-              pendingUpdateUrls.add(fileName);
-            } else {
-              needsFullReload = true;
+
+      if (changedIds.size > 0) {
+        hasPendingCssUpdate = Array.from(changedIds).some((id) => {
+          const lower = id.toLowerCase();
+          return lower.endsWith(".css") || lower.endsWith(".scss") || lower.endsWith(".less");
+        });
+
+        for (const [fileName, chunkInfo] of Object.entries(bundle)) {
+          if (fileName.endsWith(".css") || chunkInfo.type !== "chunk") {
+            continue;
+          }
+
+          let isChangedByJs = false;
+
+          // 1. Check facadeModuleId
+          if (chunkInfo.facadeModuleId) {
+            const facadeNorm = normalizePath(chunkInfo.facadeModuleId.replace(/\?.*$/, ""));
+            if (changedIds.has(facadeNorm)) {
+              isChangedByJs = true;
             }
           }
+
+          // 2. Check modules in chunk
+          if (!isChangedByJs && chunkInfo.modules) {
+            isChangedByJs = Object.keys(chunkInfo.modules).some((modPath) => {
+              const norm = normalizePath(modPath.replace(/\?.*$/, ""));
+              const lower = norm.toLowerCase();
+              if (
+                (lower.endsWith(".css") || lower.endsWith(".scss") || lower.endsWith(".less")) &&
+                !lower.endsWith(".module.css")
+              ) {
+                return false;
+              }
+              return changedIds.has(norm);
+            });
+          }
+
+          // 3. Fallback: match chunk filename with base name or relative path of changedId
+          if (!isChangedByJs) {
+            const chunkFileNameLower = fileName.toLowerCase().replace(/\.[jt]sx?$/, "");
+            for (const changedId of changedIds) {
+              const relClean = changedId
+                .replace(/^.*\/src\//, "")
+                .replace(/\.[jt]sx?$/, "")
+                .replace(/[^a-zA-Z0-9_-]/g, "_")
+                .toLowerCase();
+              if (relClean && chunkFileNameLower.includes(relClean)) {
+                isChangedByJs = true;
+                break;
+              }
+              const baseName = path.basename(changedId).replace(/\.[jt]sx?$/, "").toLowerCase();
+              if (baseName.length > 2 && baseName !== "page" && baseName !== "layout" && baseName !== "index" && chunkFileNameLower.includes(baseName)) {
+                isChangedByJs = true;
+                break;
+              }
+            }
+          }
+
+          if (isChangedByJs) {
+            const urlId = "/" + fileName;
+            pendingUpdateUrls.add(urlId);
+          }
         }
       }
     },
-    closeBundle() {
-      if (changedIds.size === 0) return;
 
-      if (needsFullReload || pendingUpdateUrls.size === 0) {
-        // console.log("[HMR] Full reload");
-        hmrEngine.broadcastMessage({ type: "reload" });
-      } else {
+    writeBundle(_options, _bundle) {
+      if (changedIds.size === 0 && pendingUpdateUrls.size === 0 && !hasPendingCssUpdate) return;
+
+      if (hasPendingCssUpdate) {
+        hmrEngine?.broadcastMessage({ type: "style-update", url: "/styles.css" });
+      }
+
+      const timelineTime = () =>
+        new Date().toTimeString().slice(0, 8) +
+        "." +
+        String(Date.now() % 1000).padStart(3, "0");
+      const timelineRel = () =>
+        globalThis.__TIMELINE_T0__
+          ? `[+${Date.now() - globalThis.__TIMELINE_T0__}ms]`
+          : ``;
+
+      const isDebug =
+        process.env.DINOU_DEBUG === "true" ||
+        process.env.DINOU_DEBUG === "1" ||
+        process.env.DEBUG === "true" ||
+        process.env.DEBUG === "1";
+
+      if (isDebug && changedIds.size > 0) {
+        console.log(
+          `⏱️ [TIMELINE ${timelineTime()}] ${timelineRel()} [HMR Rollup] Changed: [${Array.from(changedIds).join(", ")}] -> Chunks: [${Array.from(pendingUpdateUrls).join(", ")}]`
+        );
+      }
+
+      if (pendingUpdateUrls.size > 0 && !needsFullReload) {
         for (const url of pendingUpdateUrls) {
-          // console.log("[HMR] Broadcasting update for", url);
-          hmrEngine.broadcastMessage({ type: "update", url });
+          if (isDebug) {
+            console.log(
+              `⏱️ [TIMELINE ${timelineTime()}] ${timelineRel()} ⚡ [HMR Broadcast] Sending update to browser: ${url}`
+            );
+          } else {
+            console.log(`⚡ [HMR] Updating client component: ${url}`);
+          }
+          hmrEngine?.broadcastMessage({ type: "update", url });
         }
+      } else if (needsFullReload) {
+        if (isDebug) {
+          console.log(
+            `⏱️ [TIMELINE ${timelineTime()}] ${timelineRel()} ⚡ [HMR Broadcast] Full reload triggered`
+          );
+        } else {
+          console.log(`⚡ [HMR] Full reload triggered`);
+        }
+        hmrEngine?.broadcastMessage({ type: "reload" });
       }
 
       changedIds.clear();
       pendingUpdateUrls.clear();
+      hasPendingCssUpdate = false;
       needsFullReload = false;
     },
+
+    closeWatcher() {
+      // Shared server stays open across restarts
+    },
   };
 }
 
+function notifyFileChanged(absPath) {
+  if (absPath) {
+    changedIds.add(normalizePath(absPath));
+  }
+}
+
 module.exports = {
   esmHmrPlugin,
+  getHmrEngine: () => activeHmrEngine,
+  notifyFileChanged,
+  closeHmrServer: () => {
+    if (activeServer) {
+      try {
+        activeServer.close();
+      } catch (e) {}
+      activeServer = null;
+      activeHmrEngine = null;
+    }
+  },
 };
+
+

package/dinou/rollup/rollup-plugins/dinou-asset-plugin.js

@@ -17,11 +17,15 @@ function dinouAssetPlugin({ include = regex } = {}) {
 
       const fileName = `assets/${scoped}${ext}`;
 
-      this.emitFile({
-        type: "asset",
-        fileName,
-        source,
-      });
+      const emitted = globalThis.__DINOU_EMITTED_ASSETS__ || (globalThis.__DINOU_EMITTED_ASSETS__ = new Set());
+      if (!emitted.has(fileName)) {
+        emitted.add(fileName);
+        this.emitFile({
+          type: "asset",
+          fileName,
+          source,
+        });
+      }
 
       return `export default '/assets/${scoped}${ext}';`;
     },

package/dinou/rollup/rollup-plugins/rollup-plugin-memory.js

@@ -0,0 +1,66 @@
+// dinou/rollup/rollup-plugins/rollup-plugin-memory.js
+// Stores all bundled chunks, assets and sourcemaps in memory (globalThis.__DINOU_MEM_FILES__)
+// and deletes them from Rollup's emit queue in dev mode to prevent massive disk writes.
+
+const path = require("node:path");
+
+function rollupMemoryPlugin() {
+  return {
+    name: "rollup-memory-plugin",
+    generateBundle(options, bundle) {
+      const isDev =
+        process.env.NODE_ENV !== "production" ||
+        process.env.DINOU_DEV === "true";
+
+      // Only acts in development mode. In production, Rollup writes to .dinou/dist3 normally.
+      if (!isDev) {
+        return;
+      }
+
+      const shouldWriteToDisk = process.env.DINOU_WRITE_TO_DISK === "true";
+
+      if (typeof globalThis !== "undefined") {
+        if (!globalThis.__DINOU_MEM_FILES__) {
+          globalThis.__DINOU_MEM_FILES__ = new Map();
+        }
+      }
+
+      for (const [fileName, item] of Object.entries(bundle)) {
+        const normKey = fileName.replace(/\\/g, "/");
+        const raw = item.type === "asset" ? item.source : item.code;
+        const buf = Buffer.isBuffer(raw) ? raw : Buffer.from(raw || "");
+
+        if (typeof globalThis !== "undefined" && globalThis.__DINOU_MEM_FILES__) {
+          globalThis.__DINOU_MEM_FILES__.set(normKey, buf);
+          globalThis.__DINOU_MEM_FILES__.set("/" + normKey, buf);
+          const base = path.basename(normKey);
+          globalThis.__DINOU_MEM_FILES__.set(base, buf);
+        }
+
+        if (item.map) {
+          const mapKey = `${normKey}.map`;
+          const mapRaw =
+            typeof item.map.toString === "function"
+              ? item.map.toString()
+              : JSON.stringify(item.map);
+          const mapBuf = Buffer.from(mapRaw);
+          if (
+            typeof globalThis !== "undefined" &&
+            globalThis.__DINOU_MEM_FILES__
+          ) {
+            globalThis.__DINOU_MEM_FILES__.set(mapKey, mapBuf);
+            globalThis.__DINOU_MEM_FILES__.set("/" + mapKey, mapBuf);
+            const baseMap = path.basename(mapKey);
+            globalThis.__DINOU_MEM_FILES__.set(baseMap, mapBuf);
+          }
+        }
+
+        if (!shouldWriteToDisk) {
+          delete bundle[fileName];
+        }
+      }
+    },
+  };
+}
+
+module.exports = rollupMemoryPlugin;