rwsdk 1.0.0-alpha.1-test.20250911154541 → 1.0.0-alpha.10

package/dist/scripts/debug-sync.mjs

@@ -6,27 +6,6 @@ import { existsSync } from "node:fs";
 import chokidar from "chokidar";
 import { lock } from "proper-lockfile";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const getPackageManagerInfo = (targetDir) => {
-    if (existsSync(path.join(targetDir, "bun.lock"))) {
-        return { name: "bun", lockFile: "bun.lock", command: "add" };
-    }
-    const pnpmResult = {
-        name: "pnpm",
-        lockFile: "pnpm-lock.yaml",
-        command: "add",
-    };
-    if (existsSync(path.join(targetDir, "yarn.lock"))) {
-        return { name: "yarn", lockFile: "yarn.lock", command: "add" };
-    }
-    if (existsSync(path.join(targetDir, "pnpm-lock.yaml")) ||
-        existsSync(path.join(targetDir, "node_modules", ".pnpm"))) {
-        return pnpmResult;
-    }
-    if (existsSync(path.join(targetDir, "package-lock.json"))) {
-        return { name: "npm", lockFile: "package-lock.json", command: "install" };
-    }
-    return pnpmResult;
-};
 const cleanupViteEntries = async (targetDir) => {
     const nodeModulesDir = path.join(targetDir, "node_modules");
     if (!existsSync(nodeModulesDir)) {
@@ -58,91 +37,6 @@ const cleanupViteEntries = async (targetDir) => {
         console.log(`Failed to cleanup vite cache entries: ${error}`);
     }
 };
-const performFullSync = async (sdkDir, targetDir) => {
-    let tarballPath = "";
-    let tarballName = "";
-    // Clean up vite cache
-    await cleanupViteEntries(targetDir);
-    try {
-        console.log("📦 Packing SDK...");
-        const packResult = await $({ cwd: sdkDir }) `npm pack --json`;
-        const json = JSON.parse(packResult.stdout || "[]");
-        const packInfo = Array.isArray(json) ? json[0] : undefined;
-        tarballName = (packInfo && (packInfo.filename || packInfo.name)) || "";
-        if (!tarballName) {
-            console.error("❌ Failed to get tarball name from npm pack.");
-            return;
-        }
-        tarballPath = path.resolve(sdkDir, tarballName);
-        console.log(`💿 Installing ${tarballName} in ${targetDir}...`);
-        const pm = getPackageManagerInfo(targetDir);
-        const packageJsonPath = path.join(targetDir, "package.json");
-        const lockfilePath = path.join(targetDir, pm.lockFile);
-        const originalPackageJson = await fs
-            .readFile(packageJsonPath, "utf-8")
-            .catch(() => null);
-        const originalLockfile = await fs
-            .readFile(lockfilePath, "utf-8")
-            .catch(() => null);
-        try {
-            // For bun, we need to remove the existing dependency from package.json
-            // before adding the tarball to avoid a dependency loop error.
-            if (pm.name === "bun" && originalPackageJson) {
-                try {
-                    const targetPackageJson = JSON.parse(originalPackageJson);
-                    let modified = false;
-                    if (targetPackageJson.dependencies?.rwsdk) {
-                        delete targetPackageJson.dependencies.rwsdk;
-                        modified = true;
-                    }
-                    if (targetPackageJson.devDependencies?.rwsdk) {
-                        delete targetPackageJson.devDependencies.rwsdk;
-                        modified = true;
-                    }
-                    if (modified) {
-                        console.log("Temporarily removing rwsdk from target package.json to prevent dependency loop with bun.");
-                        await fs.writeFile(packageJsonPath, JSON.stringify(targetPackageJson, null, 2));
-                    }
-                }
-                catch (e) {
-                    console.warn("Could not modify target package.json, proceeding anyway.");
-                }
-            }
-            const cmd = pm.name;
-            const args = [pm.command];
-            if (pm.name === "yarn") {
-                // For modern yarn, disable PnP to avoid resolution issues with local tarballs
-                process.env.YARN_NODE_LINKER = "node-modules";
-                args.push(`rwsdk@file:${tarballPath}`);
-            }
-            else {
-                args.push(tarballPath);
-            }
-            await $(cmd, args, {
-                cwd: targetDir,
-                stdio: "inherit",
-            });
-        }
-        finally {
-            if (originalPackageJson) {
-                console.log("Restoring package.json...");
-                await fs.writeFile(packageJsonPath, originalPackageJson);
-            }
-            if (originalLockfile) {
-                console.log(`Restoring ${pm.lockFile}...`);
-                await fs.writeFile(lockfilePath, originalLockfile);
-            }
-        }
-    }
-    finally {
-        if (tarballPath) {
-            console.log("Removing tarball...");
-            await fs.unlink(tarballPath).catch(() => {
-                // ignore if deletion fails
-            });
-        }
-    }
-};
 const syncFilesWithRsyncOrFs = async (sdkDir, destDir, filesEntries) => {
     const sources = filesEntries.map((p) => path.join(sdkDir, p));
     // Always include package.json in sync
@@ -191,45 +85,120 @@ const syncFilesWithRsyncOrFs = async (sdkDir, destDir, filesEntries) => {
         }
     }
 };
-const performFastSync = async (sdkDir, targetDir) => {
-    console.log("⚡️ No dependency changes, performing fast sync...");
-    // Clean up vite cache
-    await cleanupViteEntries(targetDir);
-    const nodeModulesPkgDir = path.join(targetDir, "node_modules", "rwsdk");
-    // Copy directories/files declared in package.json#files (plus package.json)
-    const filesToSync = JSON.parse(await fs.readFile(path.join(sdkDir, "package.json"), "utf-8"))
-        .files || [];
-    await syncFilesWithRsyncOrFs(sdkDir, nodeModulesPkgDir, filesToSync);
+const findUp = async (names, startDir) => {
+    let dir = startDir;
+    while (dir !== path.dirname(dir)) {
+        for (const name of names) {
+            const filePath = path.join(dir, name);
+            if (existsSync(filePath)) {
+                return dir;
+            }
+        }
+        dir = path.dirname(dir);
+    }
+    return undefined;
+};
+const getMonorepoRoot = async (startDir) => {
+    try {
+        // `pnpm root` is the most reliable way to find the workspace root node_modules
+        const { stdout } = await $({
+            cwd: startDir,
+        }) `pnpm root`;
+        // pnpm root returns the node_modules path, so we go up one level
+        return path.resolve(stdout, "..");
+    }
+    catch (e) {
+        console.warn(`Could not determine pnpm root from ${startDir}. Falling back to file search.`);
+        const root = await findUp(["pnpm-workspace.yaml"], startDir);
+        if (root) {
+            return root;
+        }
+    }
+    console.warn("Could not find pnpm monorepo root. Using parent directory of target as fallback.");
+    return path.resolve(startDir, "..");
 };
 const areDependenciesEqual = (deps1, deps2) => {
     // Simple string comparison for this use case is sufficient
     return JSON.stringify(deps1 ?? {}) === JSON.stringify(deps2 ?? {});
 };
+const performFullSync = async (sdkDir, targetDir, monorepoRoot) => {
+    console.log("📦 Performing full sync with tarball...");
+    let tarballPath = "";
+    const projectName = path.basename(targetDir);
+    const rwsyncDir = path.join(monorepoRoot, "node_modules", `.rwsync_${projectName}`);
+    try {
+        // 1. Pack the SDK
+        const packResult = await $({ cwd: sdkDir }) `npm pack --json`;
+        const json = JSON.parse(packResult.stdout || "[]");
+        const packInfo = Array.isArray(json) ? json[0] : undefined;
+        const tarballName = (packInfo && (packInfo.filename || packInfo.name)) || "";
+        if (!tarballName) {
+            throw new Error("Failed to get tarball name from npm pack.");
+        }
+        tarballPath = path.resolve(sdkDir, tarballName);
+        // 2. Prepare isolated install directory
+        console.log(`Preparing isolated install directory at ${rwsyncDir}`);
+        await fs.rm(rwsyncDir, { recursive: true, force: true });
+        await fs.mkdir(rwsyncDir, { recursive: true });
+        await fs.writeFile(path.join(rwsyncDir, "package.json"), JSON.stringify({ name: `rwsync-env-${projectName}` }, null, 2));
+        // 3. Perform isolated install
+        console.log(`Installing ${tarballName} in isolation...`);
+        await $("pnpm", ["add", tarballPath], {
+            cwd: rwsyncDir,
+            stdio: "inherit",
+        });
+        // 4. Create symlink
+        const symlinkSource = path.join(rwsyncDir, "node_modules", "rwsdk");
+        const symlinkTarget = path.join(targetDir, "node_modules", "rwsdk");
+        console.log(`Symlinking ${symlinkTarget} -> ${symlinkSource}`);
+        await fs.rm(symlinkTarget, { recursive: true, force: true });
+        await fs.mkdir(path.dirname(symlinkTarget), { recursive: true });
+        await fs.symlink(symlinkSource, symlinkTarget, "dir");
+    }
+    finally {
+        if (tarballPath) {
+            console.log("Removing tarball...");
+            await fs.unlink(tarballPath).catch(() => { });
+        }
+    }
+};
+const performFastSync = async (sdkDir, targetDir, monorepoRoot) => {
+    console.log("⚡️ Performing fast sync with rsync...");
+    const projectName = path.basename(targetDir);
+    const rwsyncDir = path.join(monorepoRoot, "node_modules", `.rwsync_${projectName}`);
+    const syncDestDir = path.join(rwsyncDir, "node_modules", "rwsdk");
+    // Copy directories/files declared in package.json#files (plus package.json)
+    const filesToSync = JSON.parse(await fs.readFile(path.join(sdkDir, "package.json"), "utf-8"))
+        .files || [];
+    await syncFilesWithRsyncOrFs(sdkDir, syncDestDir, filesToSync);
+};
 const performSync = async (sdkDir, targetDir) => {
     console.log("🏗️  Rebuilding SDK...");
     await $ `pnpm build`;
-    const forceFullSync = Boolean(process.env.RWSDK_FORCE_FULL_SYNC);
-    if (forceFullSync) {
-        console.log("🏃 Force full sync mode is enabled.");
-        await performFullSync(sdkDir, targetDir);
-        console.log("✅ Done syncing");
-        return;
+    // Clean up vite cache in the target project
+    await cleanupViteEntries(targetDir);
+    const monorepoRoot = await getMonorepoRoot(targetDir);
+    const projectName = path.basename(targetDir);
+    const installedSdkPackageJsonPath = path.join(monorepoRoot, "node_modules", `.rwsync_${projectName}`, "node_modules", "rwsdk", "package.json");
+    let needsFullSync = false;
+    if (!existsSync(installedSdkPackageJsonPath)) {
+        console.log("No previous sync found, performing full sync.");
+        needsFullSync = true;
     }
-    const sdkPackageJsonPath = path.join(sdkDir, "package.json");
-    const installedSdkPackageJsonPath = path.join(targetDir, "node_modules/rwsdk/package.json");
-    let packageJsonChanged = true;
-    if (existsSync(installedSdkPackageJsonPath)) {
-        const sdkPackageJsonContent = await fs.readFile(sdkPackageJsonPath, "utf-8");
-        const installedSdkPackageJsonContent = await fs.readFile(installedSdkPackageJsonPath, "utf-8");
-        packageJsonChanged =
-            sdkPackageJsonContent !== installedSdkPackageJsonContent;
+    else {
+        const sdkPackageJson = JSON.parse(await fs.readFile(path.join(sdkDir, "package.json"), "utf-8"));
+        const installedSdkPackageJson = JSON.parse(await fs.readFile(installedSdkPackageJsonPath, "utf-8"));
+        if (!areDependenciesEqual(sdkPackageJson.dependencies, installedSdkPackageJson.dependencies) ||
+            !areDependenciesEqual(sdkPackageJson.devDependencies, installedSdkPackageJson.devDependencies)) {
+            console.log("Dependency changes detected, performing full sync.");
+            needsFullSync = true;
+        }
     }
-    if (packageJsonChanged) {
-        console.log("📦 package.json changed, performing full sync...");
-        await performFullSync(sdkDir, targetDir);
+    if (needsFullSync) {
+        await performFullSync(sdkDir, targetDir, monorepoRoot);
     }
     else {
-        await performFastSync(sdkDir, targetDir);
+        await performFastSync(sdkDir, targetDir, monorepoRoot);
     }
     console.log("✅ Done syncing");
 };

package/dist/vite/buildApp.d.mts

@@ -6,10 +6,11 @@ import type { ViteBuilder } from "vite";
  *
  * @see docs/architecture/productionBuildProcess.md
  */
-export declare function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, }: {
+export declare function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, workerEntryPathname, }: {
     builder: ViteBuilder;
     clientEntryPoints: Set<string>;
     clientFiles: Set<string>;
     serverFiles: Set<string>;
     projectRootDir: string;
+    workerEntryPathname: string;
 }): Promise<void>;

package/dist/vite/buildApp.mjs

@@ -9,13 +9,14 @@ const log = debug("rwsdk:vite:build-app");
  *
  * @see docs/architecture/productionBuildProcess.md
  */
-export async function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, }) {
+export async function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, workerEntryPathname, }) {
     const workerEnv = builder.environments.worker;
     await runDirectivesScan({
         rootConfig: builder.config,
         environments: builder.environments,
         clientFiles,
         serverFiles,
+        entries: [workerEntryPathname],
     });
     console.log("Building worker to discover used client components...");
     process.env.RWSDK_BUILD_PASS = "worker";
@@ -42,11 +43,14 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
     // Re-configure the worker environment for the linking pass
     const workerConfig = workerEnv.config;
     workerConfig.build.emptyOutDir = false;
+    // context(justinvdm, 22 Sep 2025): This is a workaround to satisfy the
+    // Cloudflare plugin's expectation of an entry chunk named `index`. The plugin
+    // now manages the worker build, so we no longer set rollup options
+    // directly. Instead, we re-point the original entry to the intermediate
+    // worker bundle from the first pass. This allows the linker pass to re-use
+    // the same plugin-driven configuration while bundling the final worker.
     workerConfig.build.rollupOptions.input = {
-        worker: resolve(projectRootDir, "dist", "worker", "worker.js"),
-    };
-    workerConfig.build.rollupOptions.output = {
-        entryFileNames: "worker.js",
+        index: resolve(projectRootDir, "dist", "worker", "index.js"),
     };
     await builder.build(workerEnv);
     console.log("Build complete!");

package/dist/vite/checkIsUsingPrisma.d.mts

@@ -1,6 +1,10 @@
 export type PrismaCheckResult = {
     isUsingPrisma: boolean;
 };
+export declare const isUsingPrisma: ({ projectRootDir, resolver, }: {
+    projectRootDir: string;
+    resolver?: (path: string, request: string) => string | false;
+}) => boolean;
 export declare const checkPrismaStatus: ({ projectRootDir, }: {
     projectRootDir: string;
 }) => PrismaCheckResult;

package/dist/vite/checkIsUsingPrisma.mjs

@@ -1,7 +1,7 @@
 import enhancedResolve from "enhanced-resolve";
-const isUsingPrisma = ({ projectRootDir }) => {
+export const isUsingPrisma = ({ projectRootDir, resolver = enhancedResolve.sync, }) => {
     try {
-        const prismaClientPath = enhancedResolve.sync(projectRootDir, "@prisma/client");
+        const prismaClientPath = resolver(projectRootDir, "@prisma/client");
         if (!prismaClientPath) {
             return false;
         }

package/dist/vite/checkIsUsingPrisma.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/vite/checkIsUsingPrisma.test.mjs

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import { isUsingPrisma } from "./checkIsUsingPrisma.mjs";
+describe("isUsingPrisma", () => {
+    it("should return true if prisma client is resolved", () => {
+        const resolver = () => "/path/to/prisma/client";
+        const result = isUsingPrisma({
+            projectRootDir: "/test/project",
+            resolver: resolver,
+        });
+        expect(result).toBe(true);
+    });
+    it("should return false if prisma client is not resolved", () => {
+        const resolver = () => false;
+        const result = isUsingPrisma({
+            projectRootDir: "/test/project",
+            resolver: resolver,
+        });
+        expect(result).toBe(false);
+    });
+    it("should return false if resolver throws", () => {
+        const resolver = () => {
+            throw new Error("Module not found");
+        };
+        const result = isUsingPrisma({
+            projectRootDir: "/test/project",
+            resolver: resolver,
+        });
+        expect(result).toBe(false);
+    });
+});

package/dist/vite/configPlugin.mjs

@@ -1,13 +1,11 @@
 import path, { resolve } from "node:path";
 import enhancedResolve from "enhanced-resolve";
-import debug from "debug";
 import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import { buildApp } from "./buildApp.mjs";
 import { externalModules } from "./constants.mjs";
-const log = debug("rwsdk:vite:config");
 export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clientFiles, serverFiles, clientEntryPoints, }) => ({
     name: "rwsdk:config",
-    config: async (_) => {
+    config: async (_, { command }) => {
         const mode = process.env.NODE_ENV;
         const workerConfig = {
             resolve: {
@@ -33,7 +31,15 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
             },
             optimizeDeps: {
                 noDiscovery: false,
-                include: ["rwsdk/worker"],
+                include: [
+                    "rwsdk/worker",
+                    "rwsdk/router",
+                    "rwsdk/auth",
+                    "rwsdk/db",
+                    "rwsdk/__ssr_bridge",
+                    "rwsdk/realtime/worker",
+                    "rwsdk/realtime/durableObject",
+                ],
                 exclude: [],
                 entries: [workerEntryPathname],
                 esbuildOptions: {
@@ -49,14 +55,6 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                 emitAssets: true,
                 emptyOutDir: false,
                 ssr: true,
-                rollupOptions: {
-                    output: {
-                        inlineDynamicImports: true,
-                    },
-                    input: {
-                        worker: workerEntryPathname,
-                    },
-                },
             },
         };
         const baseConfig = {
@@ -88,7 +86,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                     },
                     optimizeDeps: {
                         noDiscovery: false,
-                        include: ["rwsdk/client"],
+                        include: ["rwsdk/client", "rwsdk/realtime/client"],
                         entries: [],
                         esbuildOptions: {
                             jsx: "automatic",
@@ -115,7 +113,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                         noDiscovery: false,
                         entries: [workerEntryPathname],
                         exclude: externalModules,
-                        include: ["rwsdk/__ssr", "rwsdk/__ssr_bridge"],
+                        include: ["rwsdk/__ssr", "rwsdk/__ssr_bridge", "rwsdk/client"],
                         esbuildOptions: {
                             jsx: "automatic",
                             jsxImportSource: "react",
@@ -136,8 +134,30 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                         outDir: path.dirname(INTERMEDIATE_SSR_BRIDGE_PATH),
                         rollupOptions: {
                             output: {
+                                // context(justinvdm, 15 Sep 2025): The SSR bundle is a
+                                // pre-compiled artifact. When the linker pass bundles it into
+                                // the intermediate worker bundle (another pre-compiled
+                                // artifact), Rollup merges their top-level scopes. Since both
+                                // may have identical minified identifiers (e.g., `l0`), this
+                                // causes a redeclaration error. To solve this, we wrap the SSR
+                                // bundle in an exporting IIFE. This creates a scope boundary,
+                                // preventing symbol collisions while producing a valid,
+                                // tree-shakeable ES module. The inline plugin below removes the
+                                // original `export` statement from the bundle to prevent syntax
+                                // errors.
                                 inlineDynamicImports: true,
+                                banner: `export const { renderHtmlStream, ssrLoadModule, ssrWebpackRequire, ssrGetModuleExport, createThenableFromReadableStream } = (function() {`,
+                                footer: `return { renderHtmlStream, ssrLoadModule, ssrWebpackRequire, ssrGetModuleExport, createThenableFromReadableStream };\n})();`,
                             },
+                            plugins: [
+                                {
+                                    name: "rwsdk:ssr-bridge-exports",
+                                    renderChunk(code) {
+                                        // Remove the original export statement as it's now handled by the banner/footer
+                                        return code.replace(/export\s*{[^}]+};?/, "");
+                                    },
+                                },
+                            ],
                         },
                     },
                 },
@@ -154,6 +174,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                         clientEntryPoints,
                         clientFiles,
                         serverFiles,
+                        workerEntryPathname,
                     });
                 },
             },

package/dist/vite/createDirectiveLookupPlugin.d.mts

@@ -1,4 +1,13 @@
 import { Plugin } from "vite";
+export declare function generateLookupMap({ files, isDev, kind, exportName, }: {
+    files: Set<string>;
+    isDev: boolean;
+    kind: "client" | "server";
+    exportName: string;
+}): {
+    code: string;
+    map: import("magic-string").SourceMap;
+};
 interface DirectiveLookupConfig {
     kind: "client" | "server";
     directive: "use client" | "use server";

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -2,6 +2,33 @@ import MagicString from "magic-string";
 import path from "path";
 import debug from "debug";
 import { VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
+export function generateLookupMap({ files, isDev, kind, exportName, }) {
+    const s = new MagicString(`
+export const ${exportName} = {
+  ${Array.from(files)
+        .map((file) => {
+        if (file.includes("node_modules") && isDev) {
+            const barrelPath = kind === "client"
+                ? VENDOR_CLIENT_BARREL_EXPORT_PATH
+                : VENDOR_SERVER_BARREL_EXPORT_PATH;
+            return `
+  "${file}": () => import("${barrelPath}").then(m => m.default["${file}"]),
+`;
+        }
+        else {
+            return `
+  "${file}": () => import("${file}"),
+`;
+        }
+    })
+        .join("")}
+};
+`);
+    return {
+        code: s.toString(),
+        map: s.generateMap(),
+    };
+}
 export const createDirectiveLookupPlugin = async ({ projectRootDir, files, config, }) => {
     const debugNamespace = `rwsdk:vite:${config.pluginName}`;
     const log = debug(debugNamespace);
@@ -121,35 +148,12 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
                 log("Loading %s module with %d files", config.virtualModuleName, files.size);
                 const environment = this.environment?.name || "client";
                 log("Current environment: %s, isDev: %s", environment, isDev);
-                const s = new MagicString(`
-export const ${config.exportName} = {
-  ${Array.from(files)
-                    .map((file) => {
-                    if (file.includes("node_modules") && isDev) {
-                        const barrelPath = config.kind === "client"
-                            ? VENDOR_CLIENT_BARREL_EXPORT_PATH
-                            : VENDOR_SERVER_BARREL_EXPORT_PATH;
-                        return `
-  "${file}": () => import("${barrelPath}").then(m => m.default["${file}"]),
-`;
-                    }
-                    else {
-                        return `
-  "${file}": () => import("${file}"),
-`;
-                    }
-                })
-                    .join("")}
-};
-`);
-                const code = s.toString();
-                const map = s.generateMap();
-                log("Generated virtual module code length: %d", code.length);
-                process.env.VERBOSE && log("Generated virtual module code: %s", code);
-                return {
-                    code,
-                    map,
-                };
+                return generateLookupMap({
+                    files,
+                    isDev,
+                    kind: config.kind,
+                    exportName: config.exportName,
+                });
             }
         },
     };

package/dist/vite/createDirectiveLookupPlugin.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/vite/createDirectiveLookupPlugin.test.mjs

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+import { generateLookupMap } from "./createDirectiveLookupPlugin.mjs";
+import { VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
+describe("generateLookupMap", () => {
+    const files = new Set([
+        "src/app.js",
+        "node_modules/lib-a/index.js",
+        "src/component.tsx",
+    ]);
+    it("should generate correct map for client in dev", () => {
+        const result = generateLookupMap({
+            files,
+            isDev: true,
+            kind: "client",
+            exportName: "clientLookup",
+        });
+        expect(result.code).toContain("export const clientLookup = {");
+        expect(result.code).toContain(`"src/app.js": () => import("src/app.js")`);
+        expect(result.code).toContain(`"node_modules/lib-a/index.js": () => import("${VENDOR_CLIENT_BARREL_EXPORT_PATH}").then(m => m.default["node_modules/lib-a/index.js"])`);
+    });
+    it("should generate correct map for server in dev", () => {
+        const result = generateLookupMap({
+            files,
+            isDev: true,
+            kind: "server",
+            exportName: "serverLookup",
+        });
+        expect(result.code).toContain("export const serverLookup = {");
+        expect(result.code).toContain(`"node_modules/lib-a/index.js": () => import("${VENDOR_SERVER_BARREL_EXPORT_PATH}").then(m => m.default["node_modules/lib-a/index.js"])`);
+    });
+    it("should generate correct map for prod (isDev: false)", () => {
+        const result = generateLookupMap({
+            files,
+            isDev: false,
+            kind: "client",
+            exportName: "clientLookup",
+        });
+        expect(result.code).toContain(`"node_modules/lib-a/index.js": () => import("node_modules/lib-a/index.js")`);
+    });
+});

package/dist/vite/directiveModulesDevPlugin.d.mts

@@ -1,6 +1,9 @@
 import { Plugin } from "vite";
-export declare const directiveModulesDevPlugin: ({ clientFiles, serverFiles, projectRootDir, }: {
+export declare const generateVendorBarrelContent: (files: Set<string>, projectRootDir: string) => string;
+export declare const generateAppBarrelContent: (files: Set<string>, projectRootDir: string) => string;
+export declare const directiveModulesDevPlugin: ({ clientFiles, serverFiles, projectRootDir, workerEntryPathname, }: {
     clientFiles: Set<string>;
     serverFiles: Set<string>;
     projectRootDir: string;
+    workerEntryPathname: string;
 }) => Plugin;