@ivogt/rsc-router 0.0.0-experimental.7 → 0.0.0-experimental.8

package/dist/vite/index.js

@@ -0,0 +1,1237 @@
+// src/vite/index.ts
+import * as Vite from "vite";
+import { resolve as resolve2 } from "node:path";
+
+// src/vite/expose-action-id.ts
+import MagicString from "magic-string";
+import path from "node:path";
+import fs from "node:fs";
+function getRscPluginApi(config) {
+  let plugin = config.plugins.find((p) => p.name === "rsc:minimal");
+  if (!plugin) {
+    plugin = config.plugins.find(
+      (p) => p.api?.manager?.serverReferenceMetaMap !== void 0
+    );
+    if (plugin) {
+      console.warn(
+        `[rsc-router:expose-action-id] RSC plugin found by API structure (name: "${plugin.name}"). Consider updating the name lookup if the plugin was renamed.`
+      );
+    }
+  }
+  return plugin?.api;
+}
+function normalizePath(p) {
+  return p.split(path.sep).join("/");
+}
+function isUseServerModule(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const trimmed = content.replace(/^\s*\/\/[^\n]*\n/gm, "").replace(/^\s*\/\*[\s\S]*?\*\/\s*/gm, "").trimStart();
+    return trimmed.startsWith('"use server"') || trimmed.startsWith("'use server'");
+  } catch {
+    return false;
+  }
+}
+function transformServerReferences(code, sourceId, hashToFileMap) {
+  if (!code.includes("createServerReference(")) {
+    return null;
+  }
+  const pattern = /((?:\$\$\w+\.)?createServerReference)\(("[^"]+#[^"]+")([^)]*)\)/g;
+  const s = new MagicString(code);
+  let hasChanges = false;
+  let match;
+  while ((match = pattern.exec(code)) !== null) {
+    hasChanges = true;
+    const [fullMatch, fnCall, idArg, rest] = match;
+    const start = match.index;
+    const end = start + fullMatch.length;
+    let finalIdArg = idArg;
+    if (hashToFileMap) {
+      const idValue = idArg.slice(1, -1);
+      const hashMatch = idValue.match(/^([^#]+)#(.+)$/);
+      if (hashMatch) {
+        const [, hash, actionName] = hashMatch;
+        const filePath = hashToFileMap.get(hash);
+        if (filePath) {
+          finalIdArg = `"${filePath}#${actionName}"`;
+        }
+      }
+    }
+    const replacement = `(function(fn) { fn.$$id = ${finalIdArg}; return fn; })(${fnCall}(${idArg}${rest}))`;
+    s.overwrite(start, end, replacement);
+  }
+  if (!hasChanges) {
+    return null;
+  }
+  return {
+    code: s.toString(),
+    map: s.generateMap({ source: sourceId, includeContent: true })
+  };
+}
+function transformRegisterServerReference(code, sourceId, hashToFileMap) {
+  if (!hashToFileMap || !code.includes("registerServerReference(")) {
+    return null;
+  }
+  const pattern = /registerServerReference\(([^,]+),\s*"([^"]+)",\s*"([^"]+)"\)/g;
+  const s = new MagicString(code);
+  let hasChanges = false;
+  let match;
+  while ((match = pattern.exec(code)) !== null) {
+    const [fullMatch, fnArg, hash, exportName] = match;
+    const start = match.index;
+    const end = start + fullMatch.length;
+    const filePath = hashToFileMap.get(hash);
+    if (filePath) {
+      hasChanges = true;
+      const filePathId = `${filePath}#${exportName}`;
+      const replacement = `(function(fn) { fn.$id = "${filePathId}"; return fn; })(registerServerReference(${fnArg}, "${hash}", "${exportName}"))`;
+      s.overwrite(start, end, replacement);
+    }
+  }
+  if (!hasChanges) {
+    return null;
+  }
+  return {
+    code: s.toString(),
+    map: s.generateMap({ source: sourceId, includeContent: true })
+  };
+}
+function exposeActionId() {
+  let config;
+  let isBuild = false;
+  let hashToFileMap;
+  let rscPluginApi;
+  return {
+    name: "rsc-router:expose-action-id",
+    // Run after all other plugins (including RSC plugin's transforms)
+    enforce: "post",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      isBuild = config.command === "build";
+      rscPluginApi = getRscPluginApi(config);
+    },
+    buildStart() {
+      if (!rscPluginApi) {
+        rscPluginApi = getRscPluginApi(config);
+      }
+      if (!rscPluginApi) {
+        throw new Error(
+          "[rsc-router] Could not find @vitejs/plugin-rsc. rsc-router requires the Vite RSC plugin.\nThe RSC plugin should be included automatically. If you disabled it with\nrscRouter({ rsc: false }), add rsc() before rscRouter() in your config."
+        );
+      }
+      if (!isBuild) return;
+      hashToFileMap = /* @__PURE__ */ new Map();
+      const { serverReferenceMetaMap } = rscPluginApi.manager;
+      for (const [absolutePath, meta] of Object.entries(
+        serverReferenceMetaMap
+      )) {
+        if (!isUseServerModule(absolutePath)) {
+          continue;
+        }
+        const relativePath = normalizePath(
+          path.relative(config.root, absolutePath)
+        );
+        hashToFileMap.set(meta.referenceKey, relativePath);
+      }
+    },
+    // Dev mode only: transform hook runs after RSC plugin creates server references
+    // In dev mode, IDs already contain file paths, not hashes
+    transform(code, id) {
+      if (isBuild) {
+        return;
+      }
+      if (!code.includes("createServerReference(")) {
+        return;
+      }
+      if (id.includes("/node_modules/")) {
+        return;
+      }
+      return transformServerReferences(code, id);
+    },
+    // Build mode: renderChunk runs after all transforms and bundling complete
+    renderChunk(code, chunk) {
+      const isRscEnv = this.environment?.name === "rsc";
+      const effectiveMap = isRscEnv ? hashToFileMap : void 0;
+      const result = transformServerReferences(
+        code,
+        chunk.fileName,
+        effectiveMap
+      );
+      if (isRscEnv && hashToFileMap) {
+        const codeToTransform = result ? result.code : code;
+        const registerResult = transformRegisterServerReference(
+          codeToTransform,
+          chunk.fileName,
+          hashToFileMap
+        );
+        if (registerResult) {
+          return { code: registerResult.code, map: registerResult.map };
+        }
+      }
+      if (result) {
+        return { code: result.code, map: result.map };
+      }
+      return null;
+    }
+  };
+}
+
+// src/vite/expose-loader-id.ts
+import MagicString2 from "magic-string";
+import path2 from "node:path";
+import crypto from "node:crypto";
+function normalizePath2(p) {
+  return p.split(path2.sep).join("/");
+}
+function hashLoaderId(filePath, exportName) {
+  const input = `${filePath}#${exportName}`;
+  const hash = crypto.createHash("sha256").update(input).digest("hex");
+  return `${hash.slice(0, 8)}#${exportName}`;
+}
+function hasCreateLoaderImport(code) {
+  const pattern = /import\s*\{[^}]*\bcreateLoader\b[^}]*\}\s*from\s*["']rsc-router(?:\/server)?["']/;
+  return pattern.test(code);
+}
+function countCreateLoaderArgs(code, startPos, endPos) {
+  let depth = 0;
+  let argCount = 0;
+  let hasContent = false;
+  for (let i = startPos; i < endPos; i++) {
+    const char = code[i];
+    if (char === "(" || char === "[" || char === "{") {
+      depth++;
+      hasContent = true;
+    } else if (char === ")" || char === "]" || char === "}") {
+      depth--;
+    } else if (char === "," && depth === 0) {
+      argCount++;
+    } else if (!/\s/.test(char)) {
+      hasContent = true;
+    }
+  }
+  return hasContent ? argCount + 1 : 0;
+}
+function transformLoaderExports(code, filePath, sourceId, isBuild = false) {
+  if (!code.includes("createLoader")) {
+    return null;
+  }
+  if (!hasCreateLoaderImport(code)) {
+    return null;
+  }
+  const pattern = /export\s+const\s+(\w+)\s*=\s*createLoader\s*\(/g;
+  const s = new MagicString2(code);
+  let hasChanges = false;
+  let match;
+  while ((match = pattern.exec(code)) !== null) {
+    const exportName = match[1];
+    const matchEnd = match.index + match[0].length;
+    let parenDepth = 1;
+    let i = matchEnd;
+    while (i < code.length && parenDepth > 0) {
+      if (code[i] === "(") parenDepth++;
+      if (code[i] === ")") parenDepth--;
+      i++;
+    }
+    const closeParenPos = i - 1;
+    const argCount = countCreateLoaderArgs(code, matchEnd, closeParenPos);
+    let statementEnd = i;
+    while (statementEnd < code.length && /\s/.test(code[statementEnd])) {
+      statementEnd++;
+    }
+    if (code[statementEnd] === ";") {
+      statementEnd++;
+    }
+    const loaderId = isBuild ? hashLoaderId(filePath, exportName) : `${filePath}#${exportName}`;
+    const paramInjection = argCount === 1 ? `, undefined, "${loaderId}"` : `, "${loaderId}"`;
+    s.appendLeft(closeParenPos, paramInjection);
+    const propInjection = `
+${exportName}.$$id = "${loaderId}";`;
+    s.appendRight(statementEnd, propInjection);
+    hasChanges = true;
+  }
+  if (!hasChanges) {
+    return null;
+  }
+  return {
+    code: s.toString(),
+    map: s.generateMap({ source: sourceId, includeContent: true })
+  };
+}
+var VIRTUAL_LOADER_MANIFEST = "virtual:rsc-router/loader-manifest";
+var RESOLVED_VIRTUAL_LOADER_MANIFEST = "\0" + VIRTUAL_LOADER_MANIFEST;
+function exposeLoaderId() {
+  let config;
+  let isBuild = false;
+  const loaderRegistry = /* @__PURE__ */ new Map();
+  const pendingLoaderScans = /* @__PURE__ */ new Map();
+  return {
+    name: "rsc-router:expose-loader-id",
+    enforce: "post",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      isBuild = config.command === "build";
+    },
+    async buildStart() {
+      if (!isBuild) return;
+      const fs2 = await import("node:fs/promises");
+      async function scanDir(dir) {
+        const results = [];
+        try {
+          const entries = await fs2.readdir(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path2.join(dir, entry.name);
+            if (entry.isDirectory()) {
+              if (entry.name !== "node_modules") {
+                results.push(...await scanDir(fullPath));
+              }
+            } else if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) {
+              results.push(fullPath);
+            }
+          }
+        } catch {
+        }
+        return results;
+      }
+      try {
+        const srcDir = path2.join(config.root, "src");
+        const files = await scanDir(srcDir);
+        for (const filePath of files) {
+          const content = await fs2.readFile(filePath, "utf-8");
+          if (!content.includes("createLoader")) continue;
+          if (!hasCreateLoaderImport(content)) continue;
+          const pattern = /export\s+const\s+(\w+)\s*=\s*createLoader\s*\(/g;
+          const relativePath = normalizePath2(
+            path2.relative(config.root, filePath)
+          );
+          let match;
+          while ((match = pattern.exec(content)) !== null) {
+            const exportName = match[1];
+            const hashedId = hashLoaderId(relativePath, exportName);
+            loaderRegistry.set(hashedId, {
+              filePath: relativePath,
+              exportName
+            });
+          }
+        }
+      } catch (error) {
+        console.warn("[exposeLoaderId] Pre-scan failed:", error);
+      }
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_LOADER_MANIFEST) {
+        return RESOLVED_VIRTUAL_LOADER_MANIFEST;
+      }
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_LOADER_MANIFEST) {
+        if (!isBuild) {
+          return `import { setLoaderImports } from "rsc-router/server";
+
+// Dev mode: empty map, loaders are resolved dynamically via path parsing
+setLoaderImports({});
+`;
+        }
+        const lazyImports = [];
+        for (const [hashedId, { filePath, exportName }] of loaderRegistry) {
+          lazyImports.push(
+            `  "${hashedId}": () => import("/${filePath}").then(m => m.${exportName})`
+          );
+        }
+        if (lazyImports.length === 0) {
+          return `import { setLoaderImports } from "rsc-router/server";
+
+// No fetchable loaders discovered during build
+setLoaderImports({});
+`;
+        }
+        const code = `import { setLoaderImports } from "rsc-router/server";
+
+// Lazy import map - loaders are loaded on-demand when first requested
+setLoaderImports({
+${lazyImports.join(",\n")}
+});
+`;
+        return code;
+      }
+    },
+    transform(code, id) {
+      if (id.includes("/node_modules/")) {
+        return;
+      }
+      if (!code.includes("createLoader")) {
+        return;
+      }
+      if (!hasCreateLoaderImport(code)) {
+        return;
+      }
+      const envName = this.environment?.name;
+      const isRscEnv = envName === "rsc";
+      const relativePath = normalizePath2(path2.relative(config.root, id));
+      if (isRscEnv) {
+        const pattern = /export\s+const\s+(\w+)\s*=\s*createLoader\s*\(/g;
+        let match;
+        while ((match = pattern.exec(code)) !== null) {
+          const exportName = match[1];
+          const hashedId = hashLoaderId(relativePath, exportName);
+          loaderRegistry.set(hashedId, { filePath: relativePath, exportName });
+        }
+      }
+      return transformLoaderExports(code, relativePath, id, isBuild);
+    }
+  };
+}
+
+// src/vite/expose-handle-id.ts
+import MagicString3 from "magic-string";
+import path3 from "node:path";
+import crypto2 from "node:crypto";
+function normalizePath3(p) {
+  return p.split(path3.sep).join("/");
+}
+function hashHandleId(filePath, exportName) {
+  const input = `${filePath}#${exportName}`;
+  const hash = crypto2.createHash("sha256").update(input).digest("hex");
+  return `${hash.slice(0, 8)}#${exportName}`;
+}
+function hasCreateHandleImport(code) {
+  const pattern = /import\s*\{[^}]*\bcreateHandle\b[^}]*\}\s*from\s*["']rsc-router(?:\/[^"']+)?["']/;
+  return pattern.test(code);
+}
+function analyzeCreateHandleArgs(code, startPos, endPos) {
+  const content = code.slice(startPos, endPos).trim();
+  if (!content) {
+    return { hasArgs: false, firstArgIsString: false, firstArgIsFunction: false };
+  }
+  const firstArgIsString = /^["']/.test(content);
+  const firstArgIsFunction = content.startsWith("(") || content.startsWith("function") || // Check for identifier that could be a collect function reference
+  /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*(?:,|$)/.test(content);
+  return { hasArgs: true, firstArgIsString, firstArgIsFunction };
+}
+function transformHandleExports(code, filePath, sourceId, isBuild = false) {
+  if (!code.includes("createHandle")) {
+    return null;
+  }
+  if (!hasCreateHandleImport(code)) {
+    return null;
+  }
+  const pattern = /export\s+const\s+(\w+)\s*=\s*createHandle\s*(?:<[^>]*>)?\s*\(/g;
+  const s = new MagicString3(code);
+  let hasChanges = false;
+  let match;
+  while ((match = pattern.exec(code)) !== null) {
+    const exportName = match[1];
+    const matchEnd = match.index + match[0].length;
+    let parenDepth = 1;
+    let i = matchEnd;
+    while (i < code.length && parenDepth > 0) {
+      if (code[i] === "(") parenDepth++;
+      if (code[i] === ")") parenDepth--;
+      i++;
+    }
+    const closeParenPos = i - 1;
+    const args = analyzeCreateHandleArgs(code, matchEnd, closeParenPos);
+    let statementEnd = i;
+    while (statementEnd < code.length && /\s/.test(code[statementEnd])) {
+      statementEnd++;
+    }
+    if (code[statementEnd] === ";") {
+      statementEnd++;
+    }
+    const handleId = isBuild ? hashHandleId(filePath, exportName) : `${filePath}#${exportName}`;
+    let paramInjection;
+    if (!args.hasArgs) {
+      paramInjection = `undefined, "${handleId}"`;
+    } else {
+      paramInjection = `, "${handleId}"`;
+    }
+    s.appendLeft(closeParenPos, paramInjection);
+    const propInjection = `
+${exportName}.$$id = "${handleId}";`;
+    s.appendRight(statementEnd, propInjection);
+    hasChanges = true;
+  }
+  if (!hasChanges) {
+    return null;
+  }
+  return {
+    code: s.toString(),
+    map: s.generateMap({ source: sourceId, includeContent: true })
+  };
+}
+function exposeHandleId() {
+  let config;
+  let isBuild = false;
+  return {
+    name: "rsc-router:expose-handle-id",
+    enforce: "post",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      isBuild = config.command === "build";
+    },
+    transform(code, id) {
+      if (id.includes("/node_modules/")) {
+        return;
+      }
+      if (!code.includes("createHandle")) {
+        return;
+      }
+      if (!hasCreateHandleImport(code)) {
+        return;
+      }
+      const relativePath = normalizePath3(path3.relative(config.root, id));
+      return transformHandleExports(code, relativePath, id, isBuild);
+    }
+  };
+}
+
+// src/vite/expose-location-state-id.ts
+import MagicString4 from "magic-string";
+import path4 from "node:path";
+import crypto3 from "node:crypto";
+function normalizePath4(p) {
+  return p.split(path4.sep).join("/");
+}
+function hashLocationStateKey(filePath, exportName) {
+  const input = `${filePath}#${exportName}`;
+  const hash = crypto3.createHash("sha256").update(input).digest("hex");
+  return `${hash.slice(0, 8)}#${exportName}`;
+}
+function hasCreateLocationStateImport(code) {
+  const pattern = /import\s*\{[^}]*\bcreateLocationState\b[^}]*\}\s*from\s*["']rsc-router(?:\/[^"']+)?["']/;
+  return pattern.test(code);
+}
+function transformLocationStateExports(code, filePath, sourceId, isBuild = false) {
+  if (!code.includes("createLocationState")) {
+    return null;
+  }
+  if (!hasCreateLocationStateImport(code)) {
+    return null;
+  }
+  const pattern = /export\s+const\s+(\w+)\s*=\s*createLocationState\s*(?:<[^>]*>)?\s*\(/g;
+  const s = new MagicString4(code);
+  let hasChanges = false;
+  let match;
+  while ((match = pattern.exec(code)) !== null) {
+    const exportName = match[1];
+    const matchEnd = match.index + match[0].length;
+    let parenDepth = 1;
+    let i = matchEnd;
+    while (i < code.length && parenDepth > 0) {
+      if (code[i] === "(") parenDepth++;
+      if (code[i] === ")") parenDepth--;
+      i++;
+    }
+    const closeParenPos = i - 1;
+    const content = code.slice(matchEnd, closeParenPos).trim();
+    const hasArgs = content.length > 0;
+    let statementEnd = i;
+    while (statementEnd < code.length && /\s/.test(code[statementEnd])) {
+      statementEnd++;
+    }
+    if (code[statementEnd] === ";") {
+      statementEnd++;
+    }
+    const stateKey = isBuild ? hashLocationStateKey(filePath, exportName) : `${filePath}#${exportName}`;
+    if (!hasArgs) {
+      s.appendLeft(closeParenPos, `"${stateKey}"`);
+    } else {
+      continue;
+    }
+    const propInjection = `
+${exportName}.__rsc_ls_key = "__rsc_ls_${stateKey}";`;
+    s.appendRight(statementEnd, propInjection);
+    hasChanges = true;
+  }
+  if (!hasChanges) {
+    return null;
+  }
+  return {
+    code: s.toString(),
+    map: s.generateMap({ source: sourceId, includeContent: true })
+  };
+}
+function exposeLocationStateId() {
+  let config;
+  let isBuild = false;
+  return {
+    name: "rsc-router:expose-location-state-id",
+    enforce: "post",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      isBuild = config.command === "build";
+    },
+    transform(code, id) {
+      if (id.includes("/node_modules/")) {
+        return;
+      }
+      if (!code.includes("createLocationState")) {
+        return;
+      }
+      if (!hasCreateLocationStateImport(code)) {
+        return;
+      }
+      const relativePath = normalizePath4(path4.relative(config.root, id));
+      return transformLocationStateExports(code, relativePath, id, isBuild);
+    }
+  };
+}
+
+// src/vite/virtual-entries.ts
+var VIRTUAL_ENTRY_BROWSER = `
+import {
+  createFromReadableStream,
+  createFromFetch,
+  setServerCallback,
+  encodeReply,
+  createTemporaryReferenceSet,
+} from "rsc-router/internal/deps/browser";
+import { createElement, StrictMode } from "react";
+import { hydrateRoot } from "react-dom/client";
+import { rscStream } from "rsc-router/internal/deps/html-stream-client";
+import { initBrowserApp, RSCRouter } from "rsc-router/browser";
+
+async function initializeApp() {
+  const deps = {
+    createFromFetch,
+    createFromReadableStream,
+    encodeReply,
+    setServerCallback,
+    createTemporaryReferenceSet,
+  };
+
+  await initBrowserApp({ rscStream, deps });
+
+  hydrateRoot(
+    document,
+    createElement(StrictMode, null, createElement(RSCRouter))
+  );
+}
+
+initializeApp().catch(console.error);
+`.trim();
+var VIRTUAL_ENTRY_SSR = `
+import { createFromReadableStream } from "rsc-router/internal/deps/ssr";
+import { renderToReadableStream } from "react-dom/server.edge";
+import { injectRSCPayload } from "rsc-router/internal/deps/html-stream-server";
+import { createSSRHandler } from "rsc-router/ssr";
+
+export const renderHTML = createSSRHandler({
+  createFromReadableStream,
+  renderToReadableStream,
+  injectRSCPayload,
+  loadBootstrapScriptContent: () =>
+    import.meta.viteRsc.loadBootstrapScriptContent("index"),
+});
+`.trim();
+function getVirtualEntryRSC(routerPath) {
+  return `
+import {
+  renderToReadableStream,
+  decodeReply,
+  createTemporaryReferenceSet,
+  loadServerAction,
+  decodeAction,
+  decodeFormState,
+} from "rsc-router/internal/deps/rsc";
+import { router } from "${routerPath}";
+import { createRSCHandler } from "rsc-router/rsc";
+import { VERSION } from "rsc-router:version";
+
+// Import loader manifest to ensure all fetchable loaders are registered at startup
+// This is critical for serverless/multi-process deployments where the loader module
+// might not be imported before a GET request arrives
+import "virtual:rsc-router/loader-manifest";
+
+export default createRSCHandler({
+  router,
+  version: VERSION,
+  deps: {
+    renderToReadableStream,
+    decodeReply,
+    createTemporaryReferenceSet,
+    loadServerAction,
+    decodeAction,
+    decodeFormState,
+  },
+  loadSSRModule: () =>
+    import.meta.viteRsc.loadModule("ssr", "index"),
+});
+`.trim();
+}
+var VIRTUAL_IDS = {
+  browser: "virtual:rsc-router/entry.browser.js",
+  ssr: "virtual:rsc-router/entry.ssr.js",
+  rsc: "virtual:rsc-router/entry.rsc.js",
+  version: "rsc-router:version"
+};
+function getVirtualVersionContent(version) {
+  return `export const VERSION = ${JSON.stringify(version)};`;
+}
+
+// src/vite/package-resolution.ts
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+// package.json
+var package_default = {
+  name: "@ivogt/rsc-router",
+  version: "0.0.0-experimental.8",
+  type: "module",
+  description: "Type-safe RSC router with partial rendering support",
+  author: "Ivo Todorov",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ivogt/vite-rsc.git",
+    directory: "packages/rsc-router"
+  },
+  homepage: "https://github.com/ivogt/vite-rsc#readme",
+  bugs: {
+    url: "https://github.com/ivogt/vite-rsc/issues"
+  },
+  publishConfig: {
+    access: "public",
+    tag: "experimental"
+  },
+  keywords: [
+    "react",
+    "rsc",
+    "react-server-components",
+    "router",
+    "vite"
+  ],
+  exports: {
+    ".": {
+      "react-server": "./src/index.rsc.ts",
+      types: "./src/index.ts",
+      default: "./src/index.ts"
+    },
+    "./server": {
+      types: "./src/server.ts",
+      import: "./src/server.ts"
+    },
+    "./client": {
+      "react-server": "./src/client.rsc.tsx",
+      types: "./src/client.tsx",
+      default: "./src/client.tsx"
+    },
+    "./browser": {
+      types: "./src/browser/index.ts",
+      default: "./src/browser/index.ts"
+    },
+    "./ssr": {
+      types: "./src/ssr/index.tsx",
+      default: "./src/ssr/index.tsx"
+    },
+    "./rsc": {
+      "react-server": "./src/rsc/index.ts",
+      types: "./src/rsc/index.ts",
+      default: "./src/rsc/index.ts"
+    },
+    "./vite": {
+      types: "./src/vite/index.ts",
+      import: "./dist/vite/index.js"
+    },
+    "./types": {
+      types: "./src/vite/version.d.ts"
+    },
+    "./internal/deps/browser": {
+      types: "./src/deps/browser.ts",
+      default: "./src/deps/browser.ts"
+    },
+    "./internal/deps/ssr": {
+      types: "./src/deps/ssr.ts",
+      default: "./src/deps/ssr.ts"
+    },
+    "./internal/deps/rsc": {
+      "react-server": "./src/deps/rsc.ts",
+      types: "./src/deps/rsc.ts",
+      default: "./src/deps/rsc.ts"
+    },
+    "./internal/deps/html-stream-client": {
+      types: "./src/deps/html-stream-client.ts",
+      default: "./src/deps/html-stream-client.ts"
+    },
+    "./internal/deps/html-stream-server": {
+      types: "./src/deps/html-stream-server.ts",
+      default: "./src/deps/html-stream-server.ts"
+    },
+    "./cache": {
+      "react-server": "./src/cache/index.ts",
+      types: "./src/cache/index.ts",
+      default: "./src/cache/index.ts"
+    }
+  },
+  files: [
+    "src",
+    "dist",
+    "README.md"
+  ],
+  scripts: {
+    build: "pnpm dlx esbuild src/vite/index.ts --bundle --format=esm --outfile=dist/vite/index.js --platform=node --packages=external",
+    prepublishOnly: "pnpm build",
+    typecheck: "tsc --noEmit",
+    test: "playwright test",
+    "test:ui": "playwright test --ui",
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest"
+  },
+  peerDependencies: {
+    "@cloudflare/vite-plugin": "^1.21.0",
+    "@vitejs/plugin-rsc": "^0.5.14",
+    react: "^18.0.0 || ^19.0.0",
+    vite: "^7.3.0"
+  },
+  peerDependenciesMeta: {
+    "@cloudflare/vite-plugin": {
+      optional: true
+    },
+    vite: {
+      optional: true
+    }
+  },
+  dependencies: {
+    "@vitejs/plugin-rsc": "^0.5.14",
+    "magic-string": "^0.30.17",
+    "rsc-html-stream": "^0.0.7"
+  },
+  devDependencies: {
+    "@playwright/test": "^1.49.1",
+    "@types/node": "^24.10.1",
+    "@types/react": "catalog:",
+    "@types/react-dom": "catalog:",
+    react: "catalog:",
+    "react-dom": "catalog:",
+    esbuild: "^0.27.0",
+    tinyexec: "^0.3.2",
+    typescript: "^5.3.0",
+    vitest: "^2.1.8"
+  }
+};
+
+// src/vite/package-resolution.ts
+var VIRTUAL_PACKAGE_NAME = "rsc-router";
+function getPublishedPackageName() {
+  return package_default.name;
+}
+function isInstalledFromNpm() {
+  const packageName = getPublishedPackageName();
+  return existsSync(resolve(process.cwd(), "node_modules", packageName));
+}
+function isWorkspaceDevelopment() {
+  return !isInstalledFromNpm();
+}
+var PACKAGE_SUBPATHS = [
+  "",
+  "/browser",
+  "/client",
+  "/server",
+  "/rsc",
+  "/ssr",
+  "/internal/deps/browser",
+  "/internal/deps/html-stream-client",
+  "/internal/deps/ssr",
+  "/internal/deps/rsc"
+];
+function getExcludeDeps() {
+  const packageName = getPublishedPackageName();
+  const excludes = [];
+  for (const subpath of PACKAGE_SUBPATHS) {
+    excludes.push(`${packageName}${subpath}`);
+    if (packageName !== VIRTUAL_PACKAGE_NAME) {
+      excludes.push(`${VIRTUAL_PACKAGE_NAME}${subpath}`);
+    }
+  }
+  return excludes;
+}
+var ALIAS_SUBPATHS = [
+  "/internal/deps/browser",
+  "/internal/deps/ssr",
+  "/internal/deps/rsc",
+  "/internal/deps/html-stream-client",
+  "/internal/deps/html-stream-server",
+  "/browser",
+  "/client",
+  "/server",
+  "/rsc",
+  "/ssr"
+];
+function getPackageAliases() {
+  if (isWorkspaceDevelopment()) {
+    return {};
+  }
+  const packageName = getPublishedPackageName();
+  const aliases = {};
+  for (const subpath of ALIAS_SUBPATHS) {
+    aliases[`${VIRTUAL_PACKAGE_NAME}${subpath}`] = `${packageName}${subpath}`;
+  }
+  return aliases;
+}
+
+// src/vite/index.ts
+var versionEsbuildPlugin = {
+  name: "rsc-router-version",
+  setup(build) {
+    build.onResolve({ filter: /^rsc-router:version$/ }, (args) => ({
+      path: args.path,
+      namespace: "rsc-router-virtual"
+    }));
+    build.onLoad({ filter: /.*/, namespace: "rsc-router-virtual" }, () => ({
+      contents: `export const VERSION = "dev";`,
+      loader: "js"
+    }));
+  }
+};
+var sharedEsbuildOptions = {
+  plugins: [versionEsbuildPlugin]
+};
+function createVirtualEntriesPlugin(entries, routerPath) {
+  const virtualModules = {};
+  if (entries.client === VIRTUAL_IDS.browser) {
+    virtualModules[VIRTUAL_IDS.browser] = VIRTUAL_ENTRY_BROWSER;
+  }
+  if (entries.ssr === VIRTUAL_IDS.ssr) {
+    virtualModules[VIRTUAL_IDS.ssr] = VIRTUAL_ENTRY_SSR;
+  }
+  if (entries.rsc === VIRTUAL_IDS.rsc && routerPath) {
+    const absoluteRouterPath = routerPath.startsWith(".") ? "/" + routerPath.slice(2) : routerPath;
+    virtualModules[VIRTUAL_IDS.rsc] = getVirtualEntryRSC(absoluteRouterPath);
+  }
+  return {
+    name: "rsc-router:virtual-entries",
+    enforce: "pre",
+    resolveId(id) {
+      if (id in virtualModules) {
+        return "\0" + id;
+      }
+      if (id.startsWith("\0") && id.slice(1) in virtualModules) {
+        return id;
+      }
+      return null;
+    },
+    load(id) {
+      if (id.startsWith("\0virtual:rsc-router/")) {
+        const virtualId = id.slice(1);
+        if (virtualId in virtualModules) {
+          return virtualModules[virtualId];
+        }
+      }
+      return null;
+    }
+  };
+}
+function getManualChunks(id) {
+  const normalized = Vite.normalizePath(id);
+  if (normalized.includes("node_modules/react/") || normalized.includes("node_modules/react-dom/") || normalized.includes("node_modules/react-server-dom-webpack/") || normalized.includes("node_modules/@vitejs/plugin-rsc/")) {
+    return "react";
+  }
+  if (normalized.includes("node_modules/rsc-router/")) {
+    return "router";
+  }
+  return void 0;
+}
+function createVersionPlugin() {
+  const buildVersion = Date.now().toString(16);
+  let currentVersion = buildVersion;
+  let isDev = false;
+  let server = null;
+  return {
+    name: "rsc-router:version",
+    enforce: "pre",
+    configResolved(config) {
+      isDev = config.command === "serve";
+    },
+    configureServer(devServer) {
+      server = devServer;
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_IDS.version) {
+        return "\0" + id;
+      }
+      return null;
+    },
+    load(id) {
+      if (id === "\0" + VIRTUAL_IDS.version) {
+        return getVirtualVersionContent(currentVersion);
+      }
+      return null;
+    },
+    // Track RSC module changes and update version
+    hotUpdate(ctx) {
+      if (!isDev) return;
+      const isRscModule = this.environment?.name === "rsc";
+      if (isRscModule && ctx.modules.length > 0) {
+        currentVersion = Date.now().toString(16);
+        console.log(
+          `[rsc-router] RSC module changed, version updated: ${currentVersion}`
+        );
+        if (server) {
+          const rscEnv = server.environments?.rsc;
+          if (rscEnv?.moduleGraph) {
+            const versionMod = rscEnv.moduleGraph.getModuleById(
+              "\0" + VIRTUAL_IDS.version
+            );
+            if (versionMod) {
+              rscEnv.moduleGraph.invalidateModule(versionMod);
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function createVersionInjectorPlugin(rscEntryPath) {
+  let projectRoot = "";
+  let resolvedEntryPath = "";
+  return {
+    name: "rsc-router:version-injector",
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = config.root;
+      resolvedEntryPath = resolve2(projectRoot, rscEntryPath);
+    },
+    transform(code, id) {
+      const normalizedId = Vite.normalizePath(id);
+      const normalizedEntry = Vite.normalizePath(resolvedEntryPath);
+      if (normalizedId !== normalizedEntry) {
+        return null;
+      }
+      if (!code.includes("createRSCHandler")) {
+        return null;
+      }
+      if (code.includes("rsc-router:version")) {
+        return null;
+      }
+      const handlerCallMatch = code.match(/createRSCHandler\s*\(\s*\{/);
+      if (!handlerCallMatch) {
+        return null;
+      }
+      const lastImportIndex = code.lastIndexOf("import ");
+      if (lastImportIndex === -1) {
+        return null;
+      }
+      const afterLastImport = code.indexOf("\n", lastImportIndex);
+      if (afterLastImport === -1) {
+        return null;
+      }
+      let insertIndex = afterLastImport + 1;
+      while (insertIndex < code.length && (code.slice(insertIndex).match(/^\s*(from|import)\s/) || code[insertIndex] === "\n")) {
+        const nextNewline = code.indexOf("\n", insertIndex);
+        if (nextNewline === -1) break;
+        insertIndex = nextNewline + 1;
+      }
+      const versionImport = `import { VERSION } from "rsc-router:version";
+`;
+      let newCode = code.slice(0, insertIndex) + versionImport + code.slice(insertIndex);
+      newCode = newCode.replace(
+        /createRSCHandler\s*\(\s*\{/,
+        "createRSCHandler({\n  version: VERSION,"
+      );
+      return {
+        code: newCode,
+        map: null
+      };
+    }
+  };
+}
+async function rscRouter(options) {
+  const preset = options.preset ?? "node";
+  const enableExposeActionId = options.exposeActionId ?? true;
+  const plugins = [];
+  const rscRouterAliases = getPackageAliases();
+  const excludeDeps = getExcludeDeps();
+  let rscEntryPath = null;
+  if (preset === "cloudflare") {
+    const { default: rsc } = await import("@vitejs/plugin-rsc");
+    const finalEntries = {
+      client: VIRTUAL_IDS.browser,
+      ssr: VIRTUAL_IDS.ssr
+    };
+    plugins.push({
+      name: "rsc-router:cloudflare-integration",
+      enforce: "pre",
+      config() {
+        return {
+          // Exclude rsc-router modules from optimization to prevent module duplication
+          // This ensures the same Context instance is used by both browser entry and RSC proxy modules
+          optimizeDeps: {
+            exclude: excludeDeps,
+            esbuildOptions: sharedEsbuildOptions
+          },
+          resolve: {
+            alias: rscRouterAliases
+          },
+          environments: {
+            client: {
+              build: {
+                rollupOptions: {
+                  output: {
+                    manualChunks: getManualChunks
+                  }
+                }
+              },
+              // Pre-bundle rsc-html-stream to prevent discovery during first request
+              // Exclude rsc-router modules to ensure same Context instance
+              optimizeDeps: {
+                include: ["rsc-html-stream/client"],
+                exclude: excludeDeps,
+                esbuildOptions: sharedEsbuildOptions
+              }
+            },
+            ssr: {
+              // Build SSR inside RSC directory so wrangler can deploy self-contained dist/rsc
+              build: {
+                outDir: "./dist/rsc/ssr"
+              },
+              resolve: {
+                // Ensure single React instance in SSR child environment
+                dedupe: ["react", "react-dom"]
+              },
+              // Pre-bundle SSR entry and React for proper module linking with childEnvironments
+              // Exclude rsc-router modules to ensure same Context instance
+              optimizeDeps: {
+                entries: [finalEntries.ssr],
+                include: [
+                  "react",
+                  "react-dom/server.edge",
+                  "react/jsx-runtime",
+                  "rsc-html-stream/server"
+                ],
+                exclude: excludeDeps,
+                esbuildOptions: sharedEsbuildOptions
+              }
+            },
+            rsc: {
+              // RSC environment needs exclude list and esbuild options
+              // Exclude rsc-router modules to prevent createContext in RSC environment
+              optimizeDeps: {
+                exclude: excludeDeps,
+                esbuildOptions: sharedEsbuildOptions
+              }
+            }
+          }
+        };
+      }
+    });
+    plugins.push(createVirtualEntriesPlugin(finalEntries));
+    plugins.push(
+      rsc({
+        get entries() {
+          return finalEntries;
+        },
+        serverHandler: false
+      })
+    );
+  } else {
+    const nodeOptions = options;
+    const routerPath = nodeOptions.router;
+    const rscOption = nodeOptions.rsc ?? true;
+    if (rscOption !== false) {
+      const { default: rsc } = await import("@vitejs/plugin-rsc");
+      const userEntries = typeof rscOption === "boolean" ? {} : rscOption.entries || {};
+      const finalEntries = {
+        client: userEntries.client ?? VIRTUAL_IDS.browser,
+        ssr: userEntries.ssr ?? VIRTUAL_IDS.ssr,
+        rsc: userEntries.rsc ?? VIRTUAL_IDS.rsc
+      };
+      rscEntryPath = userEntries.rsc ?? null;
+      let hasWarnedDuplicate = false;
+      plugins.push({
+        name: "rsc-router:rsc-integration",
+        enforce: "pre",
+        config() {
+          const useVirtualClient = finalEntries.client === VIRTUAL_IDS.browser;
+          const useVirtualSSR = finalEntries.ssr === VIRTUAL_IDS.ssr;
+          const useVirtualRSC = finalEntries.rsc === VIRTUAL_IDS.rsc;
+          return {
+            // Exclude rsc-router modules from optimization to prevent module duplication
+            // This ensures the same Context instance is used by both browser entry and RSC proxy modules
+            optimizeDeps: {
+              exclude: excludeDeps,
+              esbuildOptions: sharedEsbuildOptions
+            },
+            resolve: {
+              alias: rscRouterAliases
+            },
+            environments: {
+              client: {
+                build: {
+                  rollupOptions: {
+                    output: {
+                      manualChunks: getManualChunks
+                    }
+                  }
+                },
+                // Always exclude rsc-router modules, conditionally add virtual entry
+                optimizeDeps: {
+                  exclude: excludeDeps,
+                  esbuildOptions: sharedEsbuildOptions,
+                  ...useVirtualClient && {
+                    // Tell Vite to scan the virtual entry for dependencies
+                    entries: [VIRTUAL_IDS.browser]
+                  }
+                }
+              },
+              ...useVirtualSSR && {
+                ssr: {
+                  optimizeDeps: {
+                    entries: [VIRTUAL_IDS.ssr],
+                    // Pre-bundle React for SSR to ensure single instance
+                    include: ["react", "react-dom/server.edge", "react/jsx-runtime"],
+                    exclude: excludeDeps,
+                    esbuildOptions: sharedEsbuildOptions
+                  }
+                }
+              },
+              ...useVirtualRSC && {
+                rsc: {
+                  optimizeDeps: {
+                    entries: [VIRTUAL_IDS.rsc],
+                    // Pre-bundle React for RSC to ensure single instance
+                    include: ["react", "react/jsx-runtime"],
+                    esbuildOptions: sharedEsbuildOptions
+                  }
+                }
+              }
+            }
+          };
+        },
+        configResolved(config) {
+          const rscMinimalCount = config.plugins.filter(
+            (p) => p.name === "rsc:minimal"
+          ).length;
+          if (rscMinimalCount > 1 && !hasWarnedDuplicate) {
+            hasWarnedDuplicate = true;
+            console.warn(
+              "[rsc-router] Duplicate @vitejs/plugin-rsc detected. Remove rsc() from your config or use rscRouter({ rsc: false }) for manual configuration."
+            );
+          }
+        }
+      });
+      plugins.push(createVirtualEntriesPlugin(finalEntries, routerPath));
+      plugins.push(
+        rsc({
+          entries: finalEntries
+        })
+      );
+    }
+  }
+  if (enableExposeActionId) {
+    plugins.push(exposeActionId());
+  }
+  plugins.push(exposeLoaderId());
+  plugins.push(exposeHandleId());
+  plugins.push(exposeLocationStateId());
+  plugins.push(createVersionPlugin());
+  if (rscEntryPath) {
+    plugins.push(createVersionInjectorPlugin(rscEntryPath));
+  }
+  return plugins;
+}
+export {
+  exposeActionId,
+  exposeHandleId,
+  exposeLoaderId,
+  exposeLocationStateId,
+  rscRouter
+};