rwsdk 0.1.0-alpha.9 → 0.1.1

package/dist/vite/transformServerFunctions.mjs

@@ -1,204 +1,289 @@
-import { Project, SyntaxKind, Node } from "ts-morph";
+import MagicString from "magic-string";
 import debug from "debug";
+import { hasDirective } from "./hasDirective.mjs";
+import { findExports } from "./findSpecifiers.mjs";
+import { parse as sgParse, Lang as SgLang, Lang } from "@ast-grep/napi";
+import path from "path";
 const log = debug("rwsdk:vite:transform-server-functions");
 const verboseLog = debug("verbose:rwsdk:vite:transform-server-functions");
-export const findExportedFunctions = (sourceFile) => {
+export const findExportedFunctions = (code, normalizedId) => {
+    return findExportInfo(code, normalizedId).localFunctions;
+};
+export const findExportInfo = (code, normalizedId) => {
     verboseLog("Finding exported functions in source file");
-    const exportedFunctions = new Set();
-    const exportAssignments = sourceFile.getDescendantsOfKind(SyntaxKind.ExportAssignment);
-    for (const e of exportAssignments) {
-        const name = e.getExpression().getText();
-        if (name === "default") {
-            continue;
-        }
-        exportedFunctions.add(name);
-        verboseLog("Found export assignment: %s", name);
-    }
-    const functionDeclarations = sourceFile.getDescendantsOfKind(SyntaxKind.FunctionDeclaration);
-    for (const func of functionDeclarations) {
-        if (func.hasModifier(SyntaxKind.ExportKeyword)) {
-            const name = func.getName();
-            if (name) {
-                exportedFunctions.add(name);
-                verboseLog("Found exported function declaration: %s", name);
+    const localFunctions = new Set();
+    const reExports = [];
+    const exportInfos = findExports(normalizedId || "file.ts", code, verboseLog);
+    for (const exportInfo of exportInfos) {
+        if (exportInfo.isReExport && exportInfo.moduleSpecifier) {
+            // For re-exports, we need to determine the original name by parsing the code
+            // For "export { default as multiply }", we want localName="multiply", originalName="default"
+            // For "export { sum }", we want localName="sum", originalName="sum"
+            let originalName = exportInfo.name;
+            // Check if this is a default re-export with alias
+            if (exportInfo.isDefault && exportInfo.alias) {
+                originalName = "default";
             }
+            reExports.push({
+                localName: exportInfo.name,
+                originalName: originalName,
+                moduleSpecifier: exportInfo.moduleSpecifier,
+            });
+            verboseLog("Found re-exported function: %s (original: %s) from %s", exportInfo.name, originalName, exportInfo.moduleSpecifier);
         }
-    }
-    const variableStatements = sourceFile.getDescendantsOfKind(SyntaxKind.VariableStatement);
-    for (const statement of variableStatements) {
-        if (statement.hasModifier(SyntaxKind.ExportKeyword)) {
-            const declarations = statement.getDeclarationList().getDeclarations();
-            for (const declaration of declarations) {
-                const initializer = declaration.getInitializer();
-                if (initializer && Node.isArrowFunction(initializer)) {
-                    const name = declaration.getName();
-                    if (name) {
-                        exportedFunctions.add(name);
-                        verboseLog("Found exported arrow function: %s", name);
-                    }
-                }
-            }
+        else {
+            localFunctions.add(exportInfo.name);
+            verboseLog("Found exported function: %s", exportInfo.name);
         }
     }
-    log("Found %d exported functions: %O", exportedFunctions.size, Array.from(exportedFunctions));
-    return exportedFunctions;
+    log("Found %d local functions: %O", localFunctions.size, Array.from(localFunctions));
+    log("Found %d re-exports: %O", reExports.length, reExports.map((r) => `${r.localName} from ${r.moduleSpecifier}`));
+    return { localFunctions, reExports };
 };
-export const transformServerFunctions = (code, normalizedId, environment, serverFiles) => {
-    verboseLog("Transform server functions called for normalizedId=%s, environment=%s", normalizedId, environment);
-    const project = new Project({
-        useInMemoryFileSystem: true,
-        compilerOptions: {
-            sourceMap: true,
-            target: 2,
-            module: 1,
-            jsx: 2,
-        },
-    });
-    const sourceFile = project.createSourceFile(normalizedId, code);
-    const statements = sourceFile.getStatements();
-    let hasUseServerDirective = false;
-    for (const stmt of statements) {
-        if (!Node.isExpressionStatement(stmt))
-            break;
-        const expr = stmt.getExpression();
-        if (!expr || !Node.isStringLiteral(expr))
-            break;
-        const value = expr.getLiteralText();
-        if (value === "use server") {
-            hasUseServerDirective = true;
-            log("Found 'use server' directive at top level for normalizedId=%s", normalizedId);
-            stmt.remove();
-            verboseLog("Removed 'use server' directive from normalizedId=%s", normalizedId);
-            break;
+// Helper function to find default function names using ast-grep
+function findDefaultFunctionName(code, normalizedId) {
+    const ext = path.extname(normalizedId).toLowerCase();
+    const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+    try {
+        const root = sgParse(lang, code);
+        const matches = root
+            .root()
+            .findAll("export default function $NAME($$$) { $$$ }");
+        if (matches.length > 0) {
+            const nameCapture = matches[0].getMatch("NAME");
+            return nameCapture?.text() || null;
+        }
+    }
+    catch (err) {
+        verboseLog("Error finding default function name: %O", err);
+    }
+    return null;
+}
+// Helper function to check if there's a default export (not re-export)
+function hasDefaultExport(code, normalizedId) {
+    const ext = path.extname(normalizedId).toLowerCase();
+    const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+    try {
+        const root = sgParse(lang, code);
+        // Check for any export default statements
+        const patterns = [
+            "export default function $$$",
+            "export default function($$$) { $$$ }",
+            "export default $$$",
+        ];
+        for (const pattern of patterns) {
+            const matches = root.root().findAll(pattern);
+            if (matches.length > 0) {
+                return true;
+            }
         }
     }
-    if (!hasUseServerDirective) {
-        verboseLog("No 'use server' directive found at top-level, skipping transformation for normalizedId=%s", normalizedId);
+    catch (err) {
+        verboseLog("Error checking for default export: %O", err);
+    }
+    return false;
+}
+export const transformServerFunctions = (code, normalizedId, environment, serverFiles, addServerModule) => {
+    verboseLog("Transform server functions called for normalizedId=%s, environment=%s", normalizedId, environment);
+    if (!hasDirective(code, "use server")) {
+        log("Skipping: no 'use server' directive in id=%s", normalizedId);
+        verboseLog(":VERBOSE: Returning code unchanged for id=%s:\n%s", normalizedId, code);
         return;
     }
     log("Processing 'use server' module: normalizedId=%s, environment=%s", normalizedId, environment);
-    serverFiles?.add(normalizedId);
-    if (environment === "ssr") {
-        log("Transforming for SSR environment: normalizedId=%s", normalizedId);
-        const ssrSourceFile = project.createSourceFile("ssr.tsx", "");
-        ssrSourceFile.addImportDeclaration({
-            moduleSpecifier: "rwsdk/__ssr",
-            namedImports: ["createServerReference"],
-        });
-        const exports = findExportedFunctions(sourceFile);
-        for (const name of exports) {
-            ssrSourceFile.addVariableStatement({
-                isExported: true,
-                declarations: [
-                    {
-                        name: name,
-                        initializer: `createServerReference(${JSON.stringify(normalizedId)}, ${JSON.stringify(name)})`,
-                    },
-                ],
-            });
-            log("Added SSR server reference for function: %s in normalizedId=%s", name, normalizedId);
+    addServerModule?.(environment, normalizedId);
+    if (environment === "ssr" || environment === "client") {
+        log(`Transforming for ${environment} environment: normalizedId=%s`, normalizedId);
+        const exportInfo = findExportInfo(code, normalizedId);
+        const allExports = new Set([
+            ...exportInfo.localFunctions,
+            ...exportInfo.reExports.map((r) => r.localName),
+        ]);
+        // Check for default function exports that should also be named exports
+        const defaultFunctionName = findDefaultFunctionName(code, normalizedId);
+        if (defaultFunctionName) {
+            allExports.add(defaultFunctionName);
         }
-        const hadDefaultExport = !!sourceFile.getDefaultExportSymbol();
-        if (hadDefaultExport) {
-            ssrSourceFile.addExportAssignment({
-                expression: `createServerReference(${JSON.stringify(normalizedId)}, "default")`,
-                isExportEquals: false,
-            });
-            log("Added SSR server reference for default export in normalizedId=%s", normalizedId);
+        // Generate completely new code for SSR
+        const s = new MagicString("");
+        if (environment === "ssr") {
+            s.append('import { createServerReference } from "rwsdk/__ssr";\n\n');
+        }
+        else {
+            s.append('import { createServerReference } from "rwsdk/client";\n\n');
         }
-        const emitOutput = ssrSourceFile.getEmitOutput();
-        let sourceMap;
-        for (const outputFile of emitOutput.getOutputFiles()) {
-            if (outputFile.getFilePath().endsWith(".js.map")) {
-                sourceMap = JSON.parse(outputFile.getText());
+        for (const name of allExports) {
+            if (name !== "default" && name !== defaultFunctionName) {
+                s.append(`export let ${name} = createServerReference(${JSON.stringify(normalizedId)}, ${JSON.stringify(name)});\n`);
+                log(`Added ${environment} server reference for function: %s in normalizedId=%s`, name, normalizedId);
             }
         }
-        log("SSR transformation complete for normalizedId=%s", normalizedId);
+        // Check for default export in the actual module (not re-exports)
+        if (hasDefaultExport(code, normalizedId)) {
+            s.append(`\nexport default createServerReference(${JSON.stringify(normalizedId)}, "default");\n`);
+            log(`Added ${environment} server reference for default export in normalizedId=%s`, normalizedId);
+        }
+        log(`${environment} transformation complete for normalizedId=%s`, normalizedId);
         return {
-            code: ssrSourceFile.getFullText(),
-            map: sourceMap,
+            code: s.toString(),
+            map: s.generateMap({
+                source: normalizedId,
+                includeContent: true,
+                hires: true,
+            }),
         };
     }
     else if (environment === "worker") {
         log("Transforming for worker environment: normalizedId=%s", normalizedId);
-        sourceFile.addImportDeclaration({
-            moduleSpecifier: "rwsdk/worker",
-            namedImports: ["registerServerReference"],
-        });
-        const defaultExportSymbol = sourceFile.getDefaultExportSymbol();
-        const defaultExportDecl = defaultExportSymbol?.getDeclarations()[0];
-        let hasDefaultExport = false;
-        if (defaultExportDecl && Node.isFunctionDeclaration(defaultExportDecl)) {
-            hasDefaultExport = true;
-            defaultExportDecl.setIsDefaultExport(false);
-            defaultExportDecl.rename("__defaultServerFunction__");
-            sourceFile.addExportAssignment({
-                expression: "__defaultServerFunction__",
-                isExportEquals: false,
-            });
-            sourceFile.addStatements(`registerServerReference(__defaultServerFunction__, ${JSON.stringify(normalizedId)}, "default")`);
+        const exportInfo = findExportInfo(code, normalizedId);
+        const s = new MagicString(code);
+        // Remove "use server" directive first
+        const directiveRegex = /^(\s*)(['"]use server['"])\s*;?\s*$/gm;
+        let match;
+        while ((match = directiveRegex.exec(code)) !== null) {
+            const start = match.index;
+            const end = match.index + match[0].length;
+            s.remove(start, end);
+            verboseLog("Removed 'use server' directive from normalizedId=%s", normalizedId);
+            break; // Only remove the first one
+        }
+        // Add imports at the very beginning
+        let importsToAdd = [];
+        // Add imports for re-exported functions so they exist in scope
+        for (const reExport of exportInfo.reExports) {
+            // Fix the import statement - the originalName is what we import, localName is the alias
+            const importStatement = reExport.originalName === "default"
+                ? `import { default as ${reExport.localName} } from "${reExport.moduleSpecifier}";`
+                : reExport.originalName === reExport.localName
+                    ? `import { ${reExport.originalName} } from "${reExport.moduleSpecifier}";`
+                    : `import { ${reExport.originalName} as ${reExport.localName} } from "${reExport.moduleSpecifier}";`;
+            importsToAdd.push(importStatement);
+            log("Added import for re-exported function: %s from %s in normalizedId=%s", reExport.localName, reExport.moduleSpecifier, normalizedId);
+        }
+        // Add registerServerReference import
+        importsToAdd.push('import { registerServerReference } from "rwsdk/worker";');
+        // Add imports - position depends on whether file starts with block comment
+        if (importsToAdd.length > 0) {
+            const trimmedCode = code.trim();
+            if (trimmedCode.startsWith("/*")) {
+                // Find the end of the block comment
+                const blockCommentEnd = code.indexOf("*/");
+                if (blockCommentEnd !== -1) {
+                    // Insert after the block comment
+                    const insertPos = blockCommentEnd + 2;
+                    // Find the next newline after the block comment
+                    const nextNewline = code.indexOf("\n", insertPos);
+                    const actualInsertPos = nextNewline !== -1 ? nextNewline + 1 : insertPos;
+                    s.appendLeft(actualInsertPos, importsToAdd.join("\n") + "\n");
+                }
+                else {
+                    s.prepend(importsToAdd.join("\n") + "\n");
+                }
+            }
+            else {
+                // No block comment at start, add at beginning
+                s.prepend(importsToAdd.join("\n") + "\n");
+            }
+        }
+        // Handle default export renaming if present
+        const hasDefExport = hasDefaultExport(code, normalizedId);
+        if (hasDefExport) {
+            // Find and rename default function export using ast-grep
+            const ext = path.extname(normalizedId).toLowerCase();
+            const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+            try {
+                const root = sgParse(lang, code);
+                // Handle named default function: export default function myFunc() {}
+                const namedMatches = root
+                    .root()
+                    .findAll("export default function $NAME($$$) { $$$ }");
+                if (namedMatches.length > 0) {
+                    const match = namedMatches[0];
+                    const range = match.range();
+                    const funcName = match.getMatch("NAME")?.text();
+                    if (funcName) {
+                        // Replace "export default function myFunc" with "function __defaultServerFunction__"
+                        const newText = match
+                            .text()
+                            .replace(`export default function ${funcName}`, "function __defaultServerFunction__");
+                        s.overwrite(range.start.index, range.end.index, newText);
+                        s.append("\nexport default __defaultServerFunction__;\n");
+                    }
+                }
+                else {
+                    // Handle anonymous default function: export default function() {}
+                    const anonMatches = root
+                        .root()
+                        .findAll("export default function($$$) { $$$ }");
+                    if (anonMatches.length > 0) {
+                        const match = anonMatches[0];
+                        const range = match.range();
+                        const newText = match
+                            .text()
+                            .replace("export default function", "function __defaultServerFunction__");
+                        s.overwrite(range.start.index, range.end.index, newText);
+                        s.append("\nexport default __defaultServerFunction__;\n");
+                    }
+                    else {
+                        const predefinedMatches = root
+                            .root()
+                            .findAll("export default $NAME");
+                        if (predefinedMatches.length > 0) {
+                            const match = predefinedMatches[0];
+                            const nameCapture = match.getMatch("NAME")?.text();
+                            if (nameCapture) {
+                                s.append(`const __defaultServerFunction__ = ${nameCapture};\n`);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                verboseLog("Error processing default function: %O", err);
+            }
+        }
+        // Add registration calls at the end
+        let registrationCalls = [];
+        const registeredFunctions = new Set(); // Track to avoid duplicates
+        if (hasDefExport) {
+            registrationCalls.push(`registerServerReference(__defaultServerFunction__, ${JSON.stringify(normalizedId)}, "default")`);
+            registeredFunctions.add("default");
             log("Registered worker server reference for default export in normalizedId=%s", normalizedId);
         }
-        const exports = findExportedFunctions(sourceFile);
-        for (const name of exports) {
-            if (name === "__defaultServerFunction__")
+        // Register local functions
+        const defaultFunctionName = findDefaultFunctionName(code, normalizedId);
+        for (const name of exportInfo.localFunctions) {
+            if (name === "__defaultServerFunction__" ||
+                name === "default" ||
+                name === defaultFunctionName)
                 continue;
-            sourceFile.addStatements(`registerServerReference(${name}, ${JSON.stringify(normalizedId)}, ${JSON.stringify(name)})`);
-            log("Registered worker server reference for function: %s in normalizedId=%s", name, normalizedId);
-        }
-        const emitOutput = sourceFile.getEmitOutput();
-        let sourceMap;
-        for (const outputFile of emitOutput.getOutputFiles()) {
-            if (outputFile.getFilePath().endsWith(".js.map")) {
-                sourceMap = JSON.parse(outputFile.getText());
-            }
+            // Skip if already registered
+            if (registeredFunctions.has(name))
+                continue;
+            registrationCalls.push(`registerServerReference(${name}, ${JSON.stringify(normalizedId)}, ${JSON.stringify(name)})`);
+            registeredFunctions.add(name);
+            log("Registered worker server reference for local function: %s in normalizedId=%s", name, normalizedId);
         }
-        log("Worker transformation complete for normalizedId=%s", normalizedId);
-        return {
-            code: sourceFile.getFullText(),
-            map: sourceMap,
-        };
-    }
-    else if (environment === "client") {
-        log("Transforming for client environment: normalizedId=%s", normalizedId);
-        const clientSourceFile = project.createSourceFile("client.tsx", "");
-        clientSourceFile.addImportDeclaration({
-            moduleSpecifier: "rwsdk/client",
-            namedImports: ["createServerReference"],
-        });
-        const exports = findExportedFunctions(sourceFile);
-        for (const name of exports) {
-            clientSourceFile.addVariableStatement({
-                isExported: true,
-                declarations: [
-                    {
-                        name: name,
-                        initializer: `createServerReference(${JSON.stringify(normalizedId)}, ${JSON.stringify(name)})`,
-                    },
-                ],
-            });
-            log("Added client server reference for function: %s in normalizedId=%s", name, normalizedId);
-            verboseLog("Added client server reference for function: %s in normalizedId=%s", name, normalizedId);
-        }
-        const hadDefaultExport = !!sourceFile.getDefaultExportSymbol();
-        if (hadDefaultExport) {
-            clientSourceFile.addExportAssignment({
-                expression: `createServerReference(${JSON.stringify(normalizedId)}, "default")`,
-                isExportEquals: false,
-            });
-            log("Added client server reference for default export in normalizedId=%s", normalizedId);
+        // Register re-exported functions
+        for (const reExport of exportInfo.reExports) {
+            // Skip if already registered
+            if (registeredFunctions.has(reExport.localName))
+                continue;
+            registrationCalls.push(`registerServerReference(${reExport.localName}, ${JSON.stringify(normalizedId)}, ${JSON.stringify(reExport.localName)})`);
+            registeredFunctions.add(reExport.localName);
+            log("Registered worker server reference for re-exported function: %s in normalizedId=%s", reExport.localName, normalizedId);
         }
-        const emitOutput = clientSourceFile.getEmitOutput();
-        let sourceMap;
-        for (const outputFile of emitOutput.getOutputFiles()) {
-            if (outputFile.getFilePath().endsWith(".js.map")) {
-                sourceMap = JSON.parse(outputFile.getText());
-            }
+        if (registrationCalls.length > 0) {
+            s.append(registrationCalls.join("\n") + "\n");
         }
-        log("Client transformation complete for normalizedId=%s", normalizedId);
+        log("Worker transformation complete for normalizedId=%s", normalizedId);
         return {
-            code: clientSourceFile.getFullText(),
-            map: sourceMap,
+            code: s.toString(),
+            map: s.generateMap({
+                source: normalizedId,
+                includeContent: true,
+                hires: true,
+            }),
         };
     }
     verboseLog("No transformation applied for environment=%s, normalizedId=%s", environment, normalizedId);

package/dist/vite/transformServerFunctions.test.mjs

@@ -46,6 +46,21 @@ export function sum() {
 export default function sum() {
   return 1 + 2;
 }
+`;
+    let PREDEFINED_DEFAULT_EXPORT_CODE = `
+"use server";
+
+const sum = () => {
+  return 1 + 1;
+}
+
+export default sum;
+`;
+    let EXPORT_DEFAULT_FUNCTION_CODE = `
+"use server";
+export default function sum() {
+  return 1 + 1;
+}
 `;
     let NAMED_EXPORT_CODE = `
 "use server";
@@ -68,10 +83,12 @@ export async function sum() {
   return 1 + 1
 }
 `;
-    let IGNORE_NON_FUNCTION_EXPORT_CODE = `
+    let RE_EXPORT_CODE = `
 "use server";
 
-export const a = "string";
+export { sum } from './math';
+export { default as multiply } from './multiply';
+export * from './utils';
 `;
     const TEST_CASES = {
         COMMENT_CODE,
@@ -81,8 +98,10 @@ export const a = "string";
         NAMED_EXPORT_CODE,
         ARROW_FUNCTION_EXPORT_CODE,
         ASYNC_FUNCTION_EXPORT_CODE,
-        IGNORE_NON_FUNCTION_EXPORT_CODE,
         DEFAULT_AND_NAMED_EXPORTS_CODE,
+        RE_EXPORT_CODE,
+        PREDEFINED_DEFAULT_EXPORT_CODE,
+        EXPORT_DEFAULT_FUNCTION_CODE,
     };
     describe("TRANSFORMS", () => {
         for (const [key, CODE] of Object.entries(TEST_CASES)) {

package/dist/vite/useClientLookupPlugin.mjs

@@ -4,6 +4,7 @@ export const useClientLookupPlugin = async ({ projectRootDir, clientFiles, }) =>
         projectRootDir,
         files: clientFiles,
         config: {
+            kind: "client",
             directive: "use client",
             virtualModuleName: "virtual:use-client-lookup",
             exportName: "useClientLookup",

package/dist/vite/useServerLookupPlugin.mjs

@@ -4,6 +4,7 @@ export const useServerLookupPlugin = async ({ projectRootDir, serverFiles, }) =>
         projectRootDir,
         files: serverFiles,
         config: {
+            kind: "server",
             directive: "use server",
             virtualModuleName: "virtual:use-server-lookup",
             exportName: "useServerLookup",

package/dist/vite/useServerPlugin.d.mts

@@ -1 +1 @@
-export { findExportedFunctions, transformServerFunctions, } from "./transformServerFunctions.mjs";
+export { transformServerFunctions } from "./transformServerFunctions.mjs";

package/dist/vite/useServerPlugin.mjs

@@ -1 +1 @@
-export { findExportedFunctions, transformServerFunctions, } from "./transformServerFunctions.mjs";
+export { transformServerFunctions } from "./transformServerFunctions.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "0.1.0-alpha.9",
+  "version": "0.1.1",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -44,6 +44,14 @@
       "types": "./dist/runtime/entries/auth.d.ts",
       "default": "./dist/runtime/entries/auth.js"
     },
+    "./db": {
+      "types": "./dist/runtime/lib/db/index.d.ts",
+      "default": "./dist/runtime/lib/db/index.js"
+    },
+    "./debug": {
+      "types": "./dist/runtime/lib/debug.d.ts",
+      "default": "./dist/runtime/lib/debug.js"
+    },
     "./constants": {
       "types": "./dist/runtime/constants.d.ts",
       "default": "./dist/runtime/constants.js"
@@ -101,7 +109,8 @@
   "author": "RedwoodSDK <peter@redwoodjs.com>",
   "license": "MIT",
   "dependencies": {
-    "@cloudflare/vite-plugin": "0.0.0-1bae8618b",
+    "@ast-grep/napi": "^0.38.5",
+    "@cloudflare/vite-plugin": "1.7.4",
     "@cloudflare/workers-types": "^4.20250407.0",
     "@puppeteer/browsers": "^2.8.0",
     "@types/fs-extra": "^11.0.4",
@@ -117,6 +126,8 @@
     "glob": "^11.0.1",
     "ignore": "^7.0.4",
     "jsonc-parser": "^3.3.1",
+    "kysely": "^0.28.2",
+    "kysely-do": "^0.0.1-rc.1",
     "lodash": "^4.17.21",
     "magic-string": "^0.30.17",
     "miniflare": "^4.20250405.0",
@@ -132,7 +143,7 @@
     "unique-names-generator": "^4.7.1",
     "vibe-rules": "^0.2.31",
     "vite-tsconfig-paths": "^5.1.4",
-    "wrangler": "^4.16.0"
+    "wrangler": "^4.20.5"
   },
   "peerDependencies": {
     "vite": "^6.2.6"