@concavejs/cli 0.0.1-alpha.8 → 0.0.1-alpha.9

package/dist/cli.js

@@ -3921,7 +3921,7 @@ ${file}:${line}:${column}: ERROR: ${pluginText}${e.text}`;
   }
   var fs8 = __require("fs");
   var os = __require("os");
-  var path10 = __require("path");
+  var path11 = __require("path");
   var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
   var isValidBinaryPath = (x) => !!x && x !== "/usr/bin/esbuild";
   var packageDarwin_arm64 = "@esbuild/darwin-arm64";
@@ -3979,19 +3979,19 @@ ${file}:${line}:${column}: ERROR: ${pluginText}${e.text}`;
   }
   function pkgForSomeOtherPlatform() {
     const libMainJS = __require.resolve("esbuild");
-    const nodeModulesDirectory = path10.dirname(path10.dirname(path10.dirname(libMainJS)));
-    if (path10.basename(nodeModulesDirectory) === "node_modules") {
+    const nodeModulesDirectory = path11.dirname(path11.dirname(path11.dirname(libMainJS)));
+    if (path11.basename(nodeModulesDirectory) === "node_modules") {
       for (const unixKey in knownUnixlikePackages) {
         try {
           const pkg = knownUnixlikePackages[unixKey];
-          if (fs8.existsSync(path10.join(nodeModulesDirectory, pkg)))
+          if (fs8.existsSync(path11.join(nodeModulesDirectory, pkg)))
             return pkg;
         } catch {}
       }
       for (const windowsKey in knownWindowsPackages) {
         try {
           const pkg = knownWindowsPackages[windowsKey];
-          if (fs8.existsSync(path10.join(nodeModulesDirectory, pkg)))
+          if (fs8.existsSync(path11.join(nodeModulesDirectory, pkg)))
             return pkg;
         } catch {}
       }
@@ -3999,8 +3999,8 @@ ${file}:${line}:${column}: ERROR: ${pluginText}${e.text}`;
     return null;
   }
   function downloadedBinPath(pkg, subpath) {
-    const esbuildLibDir = path10.dirname(__require.resolve("esbuild"));
-    return path10.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path10.basename(subpath)}`);
+    const esbuildLibDir = path11.dirname(__require.resolve("esbuild"));
+    return path11.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path11.basename(subpath)}`);
   }
   function generateBinPath() {
     if (isValidBinaryPath(ESBUILD_BINARY_PATH)) {
@@ -4089,9 +4089,9 @@ for your current platform.`);
       } catch (e) {}
       if (pnpapi) {
         const root = pnpapi.getPackageInformation(pnpapi.topLevel).packageLocation;
-        const binTargetPath = path10.join(root, "node_modules", ".cache", "esbuild", `pnpapi-${pkg.replace("/", "-")}-${"0.24.2"}-${path10.basename(subpath)}`);
+        const binTargetPath = path11.join(root, "node_modules", ".cache", "esbuild", `pnpapi-${pkg.replace("/", "-")}-${"0.24.2"}-${path11.basename(subpath)}`);
         if (!fs8.existsSync(binTargetPath)) {
-          fs8.mkdirSync(path10.dirname(binTargetPath), { recursive: true });
+          fs8.mkdirSync(path11.dirname(binTargetPath), { recursive: true });
           fs8.copyFileSync(binPath, binTargetPath);
           fs8.chmodSync(binTargetPath, 493);
         }
@@ -5017,6 +5017,7 @@ for (const { componentPath, loader } of componentLoaders) {
 const runtime = defineConcaveRuntime(${runtimeOptions});
 export const ConcaveDO = runtime.ConcaveDO;
 export const SyncDO = runtime.SyncDO;
+export const SyncCoordinatorDO = runtime.SyncCoordinatorDO;
 export { UdfExecutorRpc };
 export default runtime.worker;
 `;
@@ -5484,7 +5485,7 @@ function getProjectName(state, projectRoot) {
 // src/cli/deploy/cloudflare.ts
 var import_picocolors2 = __toESM(require_picocolors(), 1);
 import { promises as fs7 } from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // src/cli/artifacts.ts
 import { cp, copyFile, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
@@ -5595,7 +5596,147 @@ async function copyIfDifferent(source, destination) {
 }
 
 // src/cli/deploy/resources.ts
-import { spawn } from "node:child_process";
+import {
+  spawn
+} from "node:child_process";
+
+// src/cli/deploy/wrangler-launcher.ts
+import { accessSync, constants as fsConstants } from "node:fs";
+import path8 from "node:path";
+var WRANGLER_LAUNCHERS = [
+  { command: "wrangler", argsPrefix: [], description: "wrangler" },
+  { command: "bunx", argsPrefix: ["wrangler"], description: "bunx wrangler" },
+  { command: "npx", argsPrefix: ["wrangler"], description: "npx wrangler" },
+  { command: "npm", argsPrefix: ["exec", "--", "wrangler"], description: "npm exec -- wrangler" },
+  { command: "pnpm", argsPrefix: ["exec", "wrangler"], description: "pnpm exec wrangler" }
+];
+var WRANGLER_BIN_NOT_FOUND_MESSAGE = "Wrangler CLI is not available. Install it with `bun add -d wrangler` or `npm install -D wrangler`, or install `wrangler` globally.";
+
+class WranglerNotFoundError extends Error {
+  constructor(message = WRANGLER_BIN_NOT_FOUND_MESSAGE) {
+    super(message);
+    this.name = "WranglerNotFoundError";
+  }
+}
+function resolveWranglerLauncher(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const env = options.env || process.env;
+  const localBin = findLocalWranglerBin(cwd);
+  if (localBin) {
+    return {
+      command: localBin,
+      argsPrefix: [],
+      description: "local node_modules/.bin/wrangler"
+    };
+  }
+  for (const launcher of WRANGLER_LAUNCHERS) {
+    if (isCommandAvailable(launcher.command, env)) {
+      return launcher;
+    }
+  }
+  const attempted = WRANGLER_LAUNCHERS.map((launcher) => launcher.description).join(", ");
+  throw new WranglerNotFoundError(`${WRANGLER_BIN_NOT_FOUND_MESSAGE} Tried: ${attempted}.`);
+}
+function findLocalWranglerBin(cwd) {
+  const candidates = process.platform === "win32" ? ["wrangler.cmd", "wrangler.exe", "wrangler"] : ["wrangler"];
+  for (const dir of walkUpDirectories(cwd)) {
+    const binDir = path8.join(dir, "node_modules", ".bin");
+    for (const candidate of candidates) {
+      const fullPath = path8.join(binDir, candidate);
+      if (isExecutable(fullPath)) {
+        return fullPath;
+      }
+    }
+  }
+  return null;
+}
+function isCommandAvailable(command, env) {
+  return resolveOnPath(command, env) !== null;
+}
+function resolveOnPath(command, env) {
+  if (hasPathSeparator(command)) {
+    return isExecutable(command) ? command : null;
+  }
+  const pathValue = getEnvVar(env, "PATH") || "";
+  const pathEntries = pathValue.split(path8.delimiter).filter((entry) => entry.length > 0);
+  const commandNames = getCommandNamesForPlatform(command, env);
+  for (const entry of pathEntries) {
+    for (const commandName of commandNames) {
+      const candidate = path8.join(entry, commandName);
+      if (isExecutable(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+function getCommandNamesForPlatform(command, env) {
+  if (process.platform !== "win32") {
+    return [command];
+  }
+  if (path8.extname(command)) {
+    return [command];
+  }
+  const pathExt = getEnvVar(env, "PATHEXT") || ".COM;.EXE;.BAT;.CMD";
+  const extensions = pathExt.split(";").map((ext) => ext.trim()).filter((ext) => ext.length > 0);
+  return [command, ...extensions.map((ext) => `${command}${ext}`)];
+}
+function hasPathSeparator(command) {
+  return command.includes("/") || command.includes("\\");
+}
+function walkUpDirectories(startDir) {
+  const directories = [];
+  let current = path8.resolve(startDir);
+  while (true) {
+    directories.push(current);
+    const parent = path8.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return directories;
+}
+function getEnvVar(env, key) {
+  const direct = env[key];
+  if (typeof direct === "string") {
+    return direct;
+  }
+  const lowerKey = key.toLowerCase();
+  for (const [envKey, envValue] of Object.entries(env)) {
+    if (envKey.toLowerCase() === lowerKey && typeof envValue === "string") {
+      return envValue;
+    }
+  }
+  return;
+}
+function isExecutable(filePath) {
+  try {
+    const mode = process.platform === "win32" ? fsConstants.F_OK : fsConstants.X_OK;
+    accessSync(filePath, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/deploy/resources.ts
+function spawnWrangler(args, options) {
+  const cwd = typeof options.cwd === "string" ? options.cwd : process.cwd();
+  const env = options.env || process.env;
+  const launcher = resolveWranglerLauncher({ cwd, env });
+  return spawn(launcher.command, [...launcher.argsPrefix, ...args], {
+    cwd,
+    env,
+    stdio: options.stdio
+  });
+}
+function toWranglerRunError(prefix, error) {
+  if (error.code === "ENOENT") {
+    return new WranglerNotFoundError;
+  }
+  return new Error(`${prefix}: ${error.message}`);
+}
 async function runWrangler(args, options = {}) {
   return new Promise((resolve, reject) => {
     const chunks = [];
@@ -5607,11 +5748,17 @@ async function runWrangler(args, options = {}) {
     if (options.accountId) {
       env.CLOUDFLARE_ACCOUNT_ID = options.accountId;
     }
-    const proc = spawn("npx", ["wrangler", ...args], {
-      cwd: options.cwd || process.cwd(),
-      stdio: ["pipe", "pipe", "pipe"],
-      env
-    });
+    let proc;
+    try {
+      proc = spawnWrangler(args, {
+        cwd: options.cwd || process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"],
+        env
+      });
+    } catch (error) {
+      reject(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
     proc.stdout.on("data", (chunk) => chunks.push(chunk));
     proc.stderr.on("data", (chunk) => errorChunks.push(chunk));
     proc.on("close", (code) => {
@@ -5629,16 +5776,22 @@ ${stderr}`);
       }
     });
     proc.on("error", (error) => {
-      reject(new Error(`Failed to run wrangler: ${error.message}`));
+      reject(toWranglerRunError("Failed to run wrangler", error));
     });
   });
 }
 async function runWranglerDeploy(configPath, options = {}) {
   return new Promise((resolve, reject) => {
-    const proc = spawn("npx", ["wrangler", "deploy", "--config", configPath], {
-      cwd: options.cwd || process.cwd(),
-      stdio: "inherit"
-    });
+    let proc;
+    try {
+      proc = spawnWrangler(["deploy", "--config", configPath], {
+        cwd: options.cwd || process.cwd(),
+        stdio: "inherit"
+      });
+    } catch (error) {
+      reject(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
     proc.on("close", (code) => {
       if (code === 0) {
         resolve();
@@ -5647,7 +5800,7 @@ async function runWranglerDeploy(configPath, options = {}) {
       }
     });
     proc.on("error", (error) => {
-      reject(new Error(`Failed to run wrangler deploy: ${error.message}`));
+      reject(toWranglerRunError("Failed to run wrangler deploy", error));
     });
   });
 }
@@ -5666,18 +5819,25 @@ async function checkWranglerAuth() {
       email: emailMatch?.[1]
     };
   } catch (error) {
+    if (error instanceof WranglerNotFoundError) {
+      throw error;
+    }
     const errorText = (error.stderr || "") + (error.stdout || "");
     if (errorText.includes("not logged in") || errorText.includes("You are not authenticated")) {
       return null;
     }
-    return null;
+    throw new Error(`Failed to check Cloudflare authentication: ${error.message}`);
   }
 }
 async function wranglerLogin() {
   return new Promise((resolve, reject) => {
-    const proc = spawn("npx", ["wrangler", "login"], {
-      stdio: "inherit"
-    });
+    let proc;
+    try {
+      proc = spawnWrangler(["login"], { stdio: "inherit" });
+    } catch (error) {
+      reject(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
     proc.on("close", async (code) => {
       if (code === 0) {
         const auth = await checkWranglerAuth();
@@ -5691,7 +5851,7 @@ async function wranglerLogin() {
       }
     });
     proc.on("error", (error) => {
-      reject(new Error(`Failed to run wrangler login: ${error.message}`));
+      reject(toWranglerRunError("Failed to run wrangler login", error));
     });
   });
 }
@@ -5791,13 +5951,19 @@ async function ensureR2Bucket(name, accountId) {
 }
 async function setWorkerSecret(workerName, secretName, secretValue) {
   return new Promise((resolve, reject) => {
-    const proc = spawn("npx", ["wrangler", "secret", "put", secretName, "--name", workerName], {
-      stdio: ["pipe", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        CI: "true"
-      }
-    });
+    let proc;
+    try {
+      proc = spawnWrangler(["secret", "put", secretName, "--name", workerName], {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          CI: "true"
+        }
+      });
+    } catch (error) {
+      reject(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
     proc.stdin.write(secretValue);
     proc.stdin.end();
     let stderr = "";
@@ -5812,7 +5978,7 @@ async function setWorkerSecret(workerName, secretName, secretValue) {
       }
     });
     proc.on("error", (error) => {
-      reject(new Error(`Failed to run wrangler secret: ${error.message}`));
+      reject(toWranglerRunError("Failed to run wrangler secret", error));
     });
   });
 }
@@ -5837,7 +6003,7 @@ function getWorkerUrl(workerName, accountSubdomain) {
 
 // src/cli/deploy/secrets.ts
 import { promises as fs6 } from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 var EXCLUDED_VARS = new Set([
   "NODE_ENV",
   "PATH",
@@ -5935,7 +6101,7 @@ async function detectEnvFiles(projectRoot) {
   ];
   const envFiles = [];
   for (const name of envFileNames) {
-    const filePath = path8.join(projectRoot, name);
+    const filePath = path9.join(projectRoot, name);
     const envFile = await loadEnvFile(filePath);
     if (envFile) {
       envFiles.push(envFile);
@@ -6204,7 +6370,13 @@ async function runFirstTimeSetup(projectRoot, _existingState, options) {
     printDryRunNotice();
   }
   const spinner = createSpinner("Checking Cloudflare authentication...");
-  let auth = await checkWranglerAuth();
+  let auth;
+  try {
+    auth = await checkWranglerAuth();
+  } catch (error) {
+    spinner.stop();
+    throw error;
+  }
   if (!auth || !auth.accountId) {
     spinner.stop();
     console.log(import_picocolors2.default.dim(`  Not logged in. Opening browser to authenticate...
@@ -6414,7 +6586,7 @@ async function buildAndDeploy(projectRoot, workerName, config) {
 }
 async function generateWranglerConfig(projectRoot, workerName, config) {
   const concaveDir = getConcaveProjectPaths(projectRoot).concaveDir;
-  const configPath = path9.join(concaveDir, "wrangler.jsonc");
+  const configPath = path10.join(concaveDir, "wrangler.jsonc");
   const wranglerConfig = {
     $schema: "https://json.schemastore.org/wrangler.json",
     name: workerName,
@@ -6463,7 +6635,7 @@ async function generateWranglerConfig(projectRoot, workerName, config) {
     ];
   }
   await fs7.mkdir(concaveDir, { recursive: true });
-  await fs7.mkdir(path9.join(concaveDir, "static"), { recursive: true });
+  await fs7.mkdir(path10.join(concaveDir, "static"), { recursive: true });
   await fs7.writeFile(configPath, JSON.stringify(wranglerConfig, null, 2), "utf8");
   return configPath;
 }
@@ -6511,7 +6683,7 @@ async function handleSecrets(projectRoot, workerName, previousHashes, options) {
 var import_picocolors3 = __toESM(require_picocolors(), 1);
 var import_esbuild = __toESM(require_main(), 1);
 import { promises as fs8 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 function componentDefinitionPlugin() {
   return {
     name: "concave-component-definition",
@@ -6543,14 +6715,14 @@ export default __componentDef;
 }
 async function deploy(projectRoot, options) {
   const { cloudUrl, environment = "development", verbose = false } = options;
-  const convexDir = path10.join(projectRoot, "convex");
+  const convexDir = path11.join(projectRoot, "convex");
   try {
     await fs8.access(convexDir);
   } catch {
     throw new Error(`No convex/ directory found at ${convexDir}`);
   }
   let projectId = options.projectId;
-  const projectSlug = options.projectSlug || path10.basename(projectRoot);
+  const projectSlug = options.projectSlug || path11.basename(projectRoot);
   if (!projectId) {
     projectId = generateProjectId(projectSlug);
     if (verbose) {
@@ -6616,7 +6788,7 @@ async function ensureProject(cloudUrl, projectId, projectSlug) {
   }
 }
 async function bundleProject(projectRoot, _verbose) {
-  const buildDir = path10.join(getConcaveProjectPaths(projectRoot).concaveDir, "cloud");
+  const buildDir = path11.join(getConcaveProjectPaths(projectRoot).concaveDir, "cloud");
   try {
     await fs8.rm(buildDir, { recursive: true, force: true });
   } catch {}
@@ -6680,8 +6852,8 @@ async function getRouting(cloudUrl, projectId, environment) {
     method: "GET"
   });
 }
-async function cloudRequest(cloudUrl, path11, init) {
-  const url = `${cloudUrl}${path11}`;
+async function cloudRequest(cloudUrl, path12, init) {
+  const url = `${cloudUrl}${path12}`;
   const response = await fetch(url, {
     ...init,
     headers: {
@@ -6809,7 +6981,7 @@ var import_picocolors5 = __toESM(require_picocolors(), 1);
 
 // src/cli/url-utils.ts
 import { existsSync, readFileSync } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 var URL_ENV_KEYS = [
   "CONCAVE_URL",
   "CONVEX_URL",
@@ -6857,7 +7029,7 @@ function resolveBaseUrl(options, cwd = process.cwd()) {
     return {
       baseUrl: normalizeUrl(fromFiles.value),
       source: "environment-file",
-      sourceDetail: `${fromFiles.key} from ${path11.relative(cwd, fromFiles.filePath) || path11.basename(fromFiles.filePath)}`
+      sourceDetail: `${fromFiles.key} from ${path12.relative(cwd, fromFiles.filePath) || path12.basename(fromFiles.filePath)}`
     };
   }
   const port = options.port || "3000";
@@ -6944,16 +7116,16 @@ function getUrlFromEnvFiles(cwd) {
 function getEnvFileCandidates(cwd) {
   const convexRoot = detectConvexRoot(cwd);
   const candidates = [
-    path11.join(convexRoot, ".env.local"),
-    path11.join(convexRoot, ".env"),
-    path11.join(cwd, ".env.local"),
-    path11.join(cwd, ".env")
+    path12.join(convexRoot, ".env.local"),
+    path12.join(convexRoot, ".env"),
+    path12.join(cwd, ".env.local"),
+    path12.join(cwd, ".env")
   ];
   return [...new Set(candidates)];
 }
 function detectConvexRoot(cwd) {
-  const convexJsonPath = path11.join(cwd, "convex.json");
-  const fallback = path11.join(cwd, "convex");
+  const convexJsonPath = path12.join(cwd, "convex.json");
+  const fallback = path12.join(cwd, "convex");
   if (!existsSync(convexJsonPath)) {
     return fallback;
   }
@@ -6966,11 +7138,11 @@ function detectConvexRoot(cwd) {
     if (!normalized) {
       return fallback;
     }
-    const root = normalized.includes("/") ? path11.posix.dirname(normalized) : normalized;
+    const root = normalized.includes("/") ? path12.posix.dirname(normalized) : normalized;
     if (!root || root === ".") {
       return fallback;
     }
-    return path11.resolve(cwd, root);
+    return path12.resolve(cwd, root);
   } catch {
     return fallback;
   }
@@ -7323,11 +7495,11 @@ function formatValue(value) {
 // src/cli/type-codegen.ts
 var import_picocolors7 = __toESM(require_picocolors(), 1);
 import { promises as fs9 } from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 async function generateTypes(projectRoot, options = {}) {
   const layout = await resolveProjectLayout(projectRoot);
   const convexDir = layout.functionsDir;
-  const generatedDir = path12.join(convexDir, "_generated");
+  const generatedDir = path13.join(convexDir, "_generated");
   try {
     await fs9.access(convexDir);
   } catch {
@@ -7356,7 +7528,7 @@ async function discoverModules(convexDir) {
       if (entry.name.startsWith(".") || entry.name === "_generated" || entry.name === "node_modules") {
         continue;
       }
-      const fullPath = path12.join(dir, entry.name);
+      const fullPath = path13.join(dir, entry.name);
       const entryRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         await walk(fullPath, entryRelativePath);
@@ -7531,7 +7703,7 @@ export type DatabaseReader = GenericDatabaseReader<DataModel>;
  */
 export type DatabaseWriter = GenericDatabaseWriter<DataModel>;
 `;
-  await fs9.writeFile(path12.join(generatedDir, "server.d.ts"), content, "utf8");
+  await fs9.writeFile(path13.join(generatedDir, "server.d.ts"), content, "utf8");
 }
 async function generateServerJs(generatedDir) {
   const content = `/* eslint-disable */
@@ -7631,7 +7803,7 @@ export const httpAction = httpActionGeneric;
  */
 export { defineTable, defineSchema };
 `;
-  await fs9.writeFile(path12.join(generatedDir, "server.js"), content, "utf8");
+  await fs9.writeFile(path13.join(generatedDir, "server.js"), content, "utf8");
 }
 async function generateDataModelTypes(generatedDir, hasSchema) {
   const content = `/* eslint-disable */
@@ -7695,7 +7867,7 @@ export type Id<TableName extends TableNames | SystemTableNames> =
  */
 ${hasSchema ? "export type DataModel = DataModelFromSchemaDefinition<typeof schema>;" : "export type DataModel = any;"}
 `;
-  await fs9.writeFile(path12.join(generatedDir, "dataModel.d.ts"), content, "utf8");
+  await fs9.writeFile(path13.join(generatedDir, "dataModel.d.ts"), content, "utf8");
 }
 async function generateApiTypes(generatedDir, modules, _hasSchema) {
   const apiModules = modules.filter((m) => m.name !== "schema" && !m.name.startsWith("_") && m.name !== "http");
@@ -7753,7 +7925,7 @@ export declare const internal: FilterApi<
 
 export declare const components: AnyComponents;
 `;
-  await fs9.writeFile(path12.join(generatedDir, "api.d.ts"), content, "utf8");
+  await fs9.writeFile(path13.join(generatedDir, "api.d.ts"), content, "utf8");
 }
 async function generateApiJs(generatedDir) {
   const content = `/* eslint-disable */
@@ -7832,13 +8004,13 @@ export const api = createApi();
 export const internal = createApi();
 export const components = createComponents();
 `;
-  await fs9.writeFile(path12.join(generatedDir, "api.js"), content, "utf8");
+  await fs9.writeFile(path13.join(generatedDir, "api.js"), content, "utf8");
 }
 
 // src/cli/type-codegen-runtime.ts
 var import_picocolors8 = __toESM(require_picocolors(), 1);
 import { promises as fs10 } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 
 // src/cli/validator-to-typescript.ts
@@ -7955,7 +8127,7 @@ function returnsValidatorToTypeScript(returns, options = {}) {
 async function generateTypesWithRuntime(projectRoot, options = {}) {
   const layout = await resolveProjectLayout(projectRoot);
   const convexDir = layout.functionsDir;
-  const generatedDir = path13.join(convexDir, "_generated");
+  const generatedDir = path14.join(convexDir, "_generated");
   console.log(import_picocolors8.default.cyan("\uD83D\uDD27 Generating TypeScript types (runtime analysis)"));
   console.log(import_picocolors8.default.dim(`   Output: ${generatedDir}
 `));
@@ -8028,7 +8200,7 @@ async function discoverAndAnalyzeModules(convexDir, options) {
   const failed = [];
   const moduleFiles = await collectConvexModules2(convexDir);
   for (const filePath of moduleFiles) {
-    const relativePath = path13.relative(convexDir, filePath);
+    const relativePath = path14.relative(convexDir, filePath);
     const moduleName = relativePath.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "").replace(/\\/g, "/");
     if (moduleName === "schema" || moduleName === "http" || moduleName === "crons") {
       continue;
@@ -8158,7 +8330,7 @@ async function collectConvexModules2(convexDir) {
       if (entry.name.startsWith(".") || entry.name === "_generated" || entry.name === "node_modules") {
         continue;
       }
-      const fullPath = path13.join(dir, entry.name);
+      const fullPath = path14.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else if (isConvexSourceFile3(entry.name)) {
@@ -8339,7 +8511,7 @@ export declare const internal: FilterApi<
 
 export declare const components: AnyComponents;
 `;
-  await fs10.writeFile(path13.join(generatedDir, "api.d.ts"), content, "utf8");
+  await fs10.writeFile(path14.join(generatedDir, "api.d.ts"), content, "utf8");
 }
 async function generatePackageJson(generatedDir) {
   const content = {
@@ -8353,7 +8525,7 @@ async function generatePackageJson(generatedDir) {
       "./dataModel.d.ts": "./dataModel.d.ts"
     }
   };
-  await fs10.writeFile(path13.join(generatedDir, "package.json"), JSON.stringify(content, null, 2), "utf8");
+  await fs10.writeFile(path14.join(generatedDir, "package.json"), JSON.stringify(content, null, 2), "utf8");
 }
 async function generateServerTypes2(generatedDir, _hasSchema) {
   const content = `/* eslint-disable */
@@ -8395,7 +8567,7 @@ export type ActionCtx = GenericActionCtx<DataModel>;
 export type DatabaseReader = GenericDatabaseReader<DataModel>;
 export type DatabaseWriter = GenericDatabaseWriter<DataModel>;
 `;
-  await fs10.writeFile(path13.join(generatedDir, "server.d.ts"), content, "utf8");
+  await fs10.writeFile(path14.join(generatedDir, "server.d.ts"), content, "utf8");
 }
 async function generateServerJs2(generatedDir) {
   const content = `/* eslint-disable */
@@ -8495,7 +8667,7 @@ export const httpAction = httpActionGeneric;
  */
 export { defineTable, defineSchema };
 `;
-  await fs10.writeFile(path13.join(generatedDir, "server.js"), content, "utf8");
+  await fs10.writeFile(path14.join(generatedDir, "server.js"), content, "utf8");
 }
 async function generateDataModelTypes2(generatedDir, hasSchema) {
   const content = `/* eslint-disable */
@@ -8523,7 +8695,7 @@ export type Id<TableName extends TableNames | SystemTableNames> = GenericId<Tabl
 
 ${hasSchema ? "export type DataModel = DataModelFromSchemaDefinition<typeof schema>;" : "export type DataModel = any;"}
 `;
-  await fs10.writeFile(path13.join(generatedDir, "dataModel.d.ts"), content, "utf8");
+  await fs10.writeFile(path14.join(generatedDir, "dataModel.d.ts"), content, "utf8");
 }
 async function generateApiJs2(generatedDir) {
   const content = `/* eslint-disable */
@@ -8602,7 +8774,7 @@ export const api = createApi();
 export const internal = createApi();
 export const components = createComponents();
 `;
-  await fs10.writeFile(path13.join(generatedDir, "api.js"), content, "utf8");
+  await fs10.writeFile(path14.join(generatedDir, "api.js"), content, "utf8");
 }
 
 // ../../node_modules/chokidar/esm/index.js
@@ -8682,7 +8854,7 @@ class ReaddirpStream extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat2;
     if (wantBigintFsStats) {
-      this._stat = (path14) => statMethod(path14, { bigint: true });
+      this._stat = (path15) => statMethod(path15, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -8707,8 +8879,8 @@ class ReaddirpStream extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path14, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path14));
+          const { path: path15, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path15));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -8748,20 +8920,20 @@ class ReaddirpStream extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path14, depth) {
+  async _exploreDir(path15, depth) {
     let files;
     try {
-      files = await readdir(path14, this._rdOptions);
+      files = await readdir(path15, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path14 };
+    return { files, depth, path: path15 };
   }
-  async _formatEntry(dirent, path14) {
+  async _formatEntry(dirent, path15) {
     let entry;
     const basename = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path14, basename));
+      const fullPath = presolve(pjoin(path15, basename));
       entry = { path: prelative(this._root, fullPath), fullPath, basename };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -9160,16 +9332,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = new Map;
-function createFsWatchInstance(path14, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path15, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path14);
-    emitRaw(rawEvent, evPath, { watchedPath: path14 });
-    if (evPath && path14 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path14, evPath), KEY_LISTENERS, sysPath.join(path14, evPath));
+    listener(path15);
+    emitRaw(rawEvent, evPath, { watchedPath: path15 });
+    if (evPath && path15 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path15, evPath), KEY_LISTENERS, sysPath.join(path15, evPath));
     }
   };
   try {
-    return fs_watch(path14, {
+    return fs_watch(path15, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -9185,12 +9357,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path14, fullPath, options, handlers) => {
+var setFsWatchListener = (path15, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path14, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path15, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -9200,7 +9372,7 @@ var setFsWatchListener = (path14, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path14, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path15, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error) => {
@@ -9209,7 +9381,7 @@ var setFsWatchListener = (path14, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path14, "r");
+          const fd = await open(path15, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {}
@@ -9239,7 +9411,7 @@ var setFsWatchListener = (path14, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = new Map;
-var setFsWatchFileListener = (path14, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path15, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -9261,7 +9433,7 @@ var setFsWatchFileListener = (path14, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path14, curr));
+          foreach(cont.listeners, (listener2) => listener2(path15, curr));
         }
       })
     };
@@ -9284,13 +9456,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error) => fsW._handleError(error);
   }
-  _watchWithNodeFs(path14, listener) {
+  _watchWithNodeFs(path15, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path14);
-    const basename2 = sysPath.basename(path14);
+    const directory = sysPath.dirname(path15);
+    const basename2 = sysPath.basename(path15);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename2);
-    const absolutePath = sysPath.resolve(path14);
+    const absolutePath = sysPath.resolve(path15);
     const options = {
       persistent: opts.persistent
     };
@@ -9300,12 +9472,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename2) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path14, absolutePath, options, {
+      closer = setFsWatchFileListener(path15, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path14, absolutePath, options, {
+      closer = setFsWatchListener(path15, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -9323,7 +9495,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename2))
       return;
-    const listener = async (path14, newStats) => {
+    const listener = async (path15, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -9337,11 +9509,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path14);
+            this.fsw._closeFile(path15);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path14, closer2);
+              this.fsw._addPathCloser(path15, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -9365,7 +9537,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path14, item) {
+  async _handleSymlink(entry, directory, path15, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -9375,7 +9547,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path14);
+        linkPath = await fsrealpath(path15);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -9385,12 +9557,12 @@ class NodeFsHandler {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path14, entry.stats);
+          this.fsw._emit(EV.CHANGE, path15, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path14, entry.stats);
+        this.fsw._emit(EV.ADD, path15, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -9419,9 +9591,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path14 = sysPath.join(directory, item);
+      let path15 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path14, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path15, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -9430,8 +9602,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path14 = sysPath.join(dir, sysPath.relative(dir, path14));
-        this._addToNodeFs(path14, initialAdd, wh, depth + 1);
+        path15 = sysPath.join(dir, sysPath.relative(dir, path15));
+        this._addToNodeFs(path15, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve2, reject) => {
@@ -9480,13 +9652,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path14, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path15, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path14) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path15) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path14);
+    const wh = this.fsw._getWatchHelpers(path15);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -9502,8 +9674,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path14);
-        const targetPath = follow ? await fsrealpath(path14) : path14;
+        const absPath = sysPath.resolve(path15);
+        const targetPath = follow ? await fsrealpath(path15) : path15;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -9513,29 +9685,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path14) : path14;
+        const targetPath = follow ? await fsrealpath(path15) : path15;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path14, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path15, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path14), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path15), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path14, closer);
+        this.fsw._addPathCloser(path15, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path14;
+        return path15;
       }
     }
   }
@@ -9579,26 +9751,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path14) {
-  if (typeof path14 !== "string")
+function normalizePath(path15) {
+  if (typeof path15 !== "string")
     throw new Error("string expected");
-  path14 = sysPath2.normalize(path14);
-  path14 = path14.replace(/\\/g, "/");
+  path15 = sysPath2.normalize(path15);
+  path15 = path15.replace(/\\/g, "/");
   let prepend = false;
-  if (path14.startsWith("//"))
+  if (path15.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path14.match(DOUBLE_SLASH_RE2))
-    path14 = path14.replace(DOUBLE_SLASH_RE2, "/");
+  while (path15.match(DOUBLE_SLASH_RE2))
+    path15 = path15.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path14 = "/" + path14;
-  return path14;
+    path15 = "/" + path15;
+  return path15;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path14 = normalizePath(testString);
+  const path15 = normalizePath(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path14, stats)) {
+    if (pattern(path15, stats)) {
       return true;
     }
   }
@@ -9638,19 +9810,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path14) => toUnix(sysPath2.normalize(toUnix(path14)));
-var normalizeIgnored = (cwd = "") => (path14) => {
-  if (typeof path14 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path14) ? path14 : sysPath2.join(cwd, path14));
+var normalizePathToUnix = (path15) => toUnix(sysPath2.normalize(toUnix(path15)));
+var normalizeIgnored = (cwd = "") => (path15) => {
+  if (typeof path15 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path15) ? path15 : sysPath2.join(cwd, path15));
   } else {
-    return path14;
+    return path15;
   }
 };
-var getAbsolutePath = (path14, cwd) => {
-  if (sysPath2.isAbsolute(path14)) {
-    return path14;
+var getAbsolutePath = (path15, cwd) => {
+  if (sysPath2.isAbsolute(path15)) {
+    return path15;
   }
-  return sysPath2.join(cwd, path14);
+  return sysPath2.join(cwd, path15);
 };
 var EMPTY_SET = Object.freeze(new Set);
 
@@ -9707,10 +9879,10 @@ var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 
 class WatchHelper {
-  constructor(path14, follow, fsw) {
+  constructor(path15, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path14;
-    this.path = path14 = path14.replace(REPLACER_RE, "");
+    const watchPath = path15;
+    this.path = path15 = path15.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -9823,20 +9995,20 @@ class FSWatcher extends EventEmitter {
     this._closePromise = undefined;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path14) => {
-        const absPath = getAbsolutePath(path14, cwd);
+      paths = paths.map((path15) => {
+        const absPath = getAbsolutePath(path15, cwd);
         return absPath;
       });
     }
-    paths.forEach((path14) => {
-      this._removeIgnoredPath(path14);
+    paths.forEach((path15) => {
+      this._removeIgnoredPath(path15);
     });
     this._userIgnored = undefined;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path14) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path14, !_internal, undefined, 0, _origAdd);
+    Promise.all(paths.map(async (path15) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path15, !_internal, undefined, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -9855,17 +10027,17 @@ class FSWatcher extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path14) => {
-      if (!sysPath2.isAbsolute(path14) && !this._closers.has(path14)) {
+    paths.forEach((path15) => {
+      if (!sysPath2.isAbsolute(path15) && !this._closers.has(path15)) {
         if (cwd)
-          path14 = sysPath2.join(cwd, path14);
-        path14 = sysPath2.resolve(path14);
+          path15 = sysPath2.join(cwd, path15);
+        path15 = sysPath2.resolve(path15);
       }
-      this._closePath(path14);
-      this._addIgnoredPath(path14);
-      if (this._watched.has(path14)) {
+      this._closePath(path15);
+      this._addIgnoredPath(path15);
+      if (this._watched.has(path15)) {
         this._addIgnoredPath({
-          path: path14,
+          path: path15,
           recursive: true
         });
       }
@@ -9914,38 +10086,38 @@ class FSWatcher extends EventEmitter {
     if (event !== EVENTS.ERROR)
       this.emit(EVENTS.ALL, event, ...args);
   }
-  async _emit(event, path14, stats) {
+  async _emit(event, path15, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path14 = sysPath2.normalize(path14);
+      path15 = sysPath2.normalize(path15);
     if (opts.cwd)
-      path14 = sysPath2.relative(opts.cwd, path14);
-    const args = [path14];
+      path15 = sysPath2.relative(opts.cwd, path15);
+    const args = [path15];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path14))) {
+    if (awf && (pw = this._pendingWrites.get(path15))) {
       pw.lastChange = new Date;
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path14, [event, ...args]);
+        this._pendingUnlinks.set(path15, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path15) => {
+          this._pendingUnlinks.forEach((entry, path16) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path15);
+            this._pendingUnlinks.delete(path16);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path14)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path15)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path14);
+        this._pendingUnlinks.delete(path15);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -9963,16 +10135,16 @@ class FSWatcher extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path14, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path15, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path14, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path15, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path14) : path14;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path15) : path15;
       let stats2;
       try {
         stats2 = await stat4(fullPath);
@@ -9991,23 +10163,23 @@ class FSWatcher extends EventEmitter {
     }
     return error || this.closed;
   }
-  _throttle(actionType, path14, timeout) {
+  _throttle(actionType, path15, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, new Map);
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path14);
+    const actionPath = action.get(path15);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path14);
+      const item = action.get(path15);
       const count = item ? item.count : 0;
-      action.delete(path14);
+      action.delete(path15);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -10015,50 +10187,50 @@ class FSWatcher extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path14, thr);
+    action.set(path15, thr);
     return thr;
   }
   _incrReadyCount() {
     return this._readyCount++;
   }
-  _awaitWriteFinish(path14, threshold, event, awfEmit) {
+  _awaitWriteFinish(path15, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path14;
-    if (this.options.cwd && !sysPath2.isAbsolute(path14)) {
-      fullPath = sysPath2.join(this.options.cwd, path14);
+    let fullPath = path15;
+    if (this.options.cwd && !sysPath2.isAbsolute(path15)) {
+      fullPath = sysPath2.join(this.options.cwd, path15);
     }
     const now = new Date;
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path14)) {
+        if (err || !writes.has(path15)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(new Date);
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path14).lastChange = now2;
+          writes.get(path15).lastChange = now2;
         }
-        const pw = writes.get(path14);
+        const pw = writes.get(path15);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path14);
+          writes.delete(path15);
           awfEmit(undefined, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path14)) {
-      writes.set(path14, {
+    if (!writes.has(path15)) {
+      writes.set(path15, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path14);
+          writes.delete(path15);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -10066,8 +10238,8 @@ class FSWatcher extends EventEmitter {
       timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
     }
   }
-  _isIgnored(path14, stats) {
-    if (this.options.atomic && DOT_RE.test(path14))
+  _isIgnored(path15, stats) {
+    if (this.options.atomic && DOT_RE.test(path15))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -10077,13 +10249,13 @@ class FSWatcher extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, undefined);
     }
-    return this._userIgnored(path14, stats);
+    return this._userIgnored(path15, stats);
   }
-  _isntIgnored(path14, stat5) {
-    return !this._isIgnored(path14, stat5);
+  _isntIgnored(path15, stat5) {
+    return !this._isIgnored(path15, stat5);
   }
-  _getWatchHelpers(path14) {
-    return new WatchHelper(path14, this.options.followSymlinks, this);
+  _getWatchHelpers(path15) {
+    return new WatchHelper(path15, this.options.followSymlinks, this);
   }
   _getWatchedDir(directory) {
     const dir = sysPath2.resolve(directory);
@@ -10097,57 +10269,57 @@ class FSWatcher extends EventEmitter {
     return Boolean(Number(stats.mode) & 256);
   }
   _remove(directory, item, isDirectory) {
-    const path14 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path14);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path14) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path14, 100))
+    const path15 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path15);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path15) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path15, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path14);
+    const wp = this._getWatchedDir(path15);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path14, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path15, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path14;
+    let relPath = path15;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path14);
+      relPath = sysPath2.relative(this.options.cwd, path15);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path14);
+    this._watched.delete(path15);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path14))
-      this._emit(eventName, path14);
-    this._closePath(path14);
+    if (wasTracked && !this._isIgnored(path15))
+      this._emit(eventName, path15);
+    this._closePath(path15);
   }
-  _closePath(path14) {
-    this._closeFile(path14);
-    const dir = sysPath2.dirname(path14);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path14));
+  _closePath(path15) {
+    this._closeFile(path15);
+    const dir = sysPath2.dirname(path15);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path15));
   }
-  _closeFile(path14) {
-    const closers = this._closers.get(path14);
+  _closeFile(path15) {
+    const closers = this._closers.get(path15);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path14);
+    this._closers.delete(path15);
   }
-  _addPathCloser(path14, closer) {
+  _addPathCloser(path15, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path14);
+    let list = this._closers.get(path15);
     if (!list) {
       list = [];
-      this._closers.set(path14, list);
+      this._closers.set(path15, list);
     }
     list.push(closer);
   }
@@ -10178,7 +10350,7 @@ var esm_default = { watch, FSWatcher };
 
 // src/cli/cli.ts
 var import_picocolors9 = __toESM(require_picocolors(), 1);
-import path15 from "node:path";
+import path16 from "node:path";
 import { promises as fs12, existsSync as existsSync2 } from "node:fs";
 import { spawn as spawn2, spawnSync } from "node:child_process";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
@@ -10187,7 +10359,7 @@ import { createRequire as createRequire3 } from "node:module";
 // src/cli/auth-keys.ts
 import * as crypto2 from "crypto";
 import * as fs11 from "fs/promises";
-import * as path14 from "path";
+import * as path15 from "path";
 var AUTH_KEYS_FILENAME = "auth-keys.json";
 async function generateAuthKeys() {
   return new Promise((resolve3, reject) => {
@@ -10234,7 +10406,7 @@ function createJwksFromPublicKey(publicKeyPem, kid) {
   };
 }
 async function loadOrGenerateAuthKeys(dataDir) {
-  const keysPath = path14.join(dataDir, AUTH_KEYS_FILENAME);
+  const keysPath = path15.join(dataDir, AUTH_KEYS_FILENAME);
   try {
     const data = await fs11.readFile(keysPath, "utf-8");
     const stored = JSON.parse(data);
@@ -10261,7 +10433,7 @@ async function loadOrGenerateAuthKeys(dataDir) {
   }
 }
 async function detectAuthProjectFlavor(projectRoot) {
-  const packageJsonPath = path14.join(projectRoot, "package.json");
+  const packageJsonPath = path15.join(projectRoot, "package.json");
   try {
     const raw = await fs11.readFile(packageJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -10303,7 +10475,7 @@ function setupAuthEnvironment(keys, siteUrl, options = {}) {
   setEnv("AUTH_SKIP_VERIFICATION", "true");
 }
 // package.json
-var version = "0.0.1-alpha.8";
+var version = "0.0.1-alpha.9";
 
 // src/cli/cli.ts
 var WATCH_IGNORE_PATTERNS = [
@@ -10343,16 +10515,16 @@ function detectPreferredRuntime() {
   return "node";
 }
 function detectPackageManager(projectRoot) {
-  if (existsSync2(path15.join(projectRoot, "bun.lock")) || existsSync2(path15.join(projectRoot, "bun.lockb"))) {
+  if (existsSync2(path16.join(projectRoot, "bun.lock")) || existsSync2(path16.join(projectRoot, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync2(path15.join(projectRoot, "pnpm-lock.yaml"))) {
+  if (existsSync2(path16.join(projectRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync2(path15.join(projectRoot, "yarn.lock"))) {
+  if (existsSync2(path16.join(projectRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync2(path15.join(projectRoot, "package-lock.json")) || existsSync2(path15.join(projectRoot, "npm-shrinkwrap.json"))) {
+  if (existsSync2(path16.join(projectRoot, "package-lock.json")) || existsSync2(path16.join(projectRoot, "npm-shrinkwrap.json"))) {
     return "npm";
   }
   return isBunAvailable() ? "bun" : "npm";
@@ -10389,11 +10561,11 @@ function sanitizePackageName(input) {
   return normalized.length > 0 ? normalized : "concave-app";
 }
 function formatPathForDisplay(fromDir, targetPath) {
-  const relative3 = path15.relative(fromDir, targetPath);
+  const relative3 = path16.relative(fromDir, targetPath);
   if (!relative3 || relative3 === ".") {
     return ".";
   }
-  if (!relative3.startsWith("..") && !path15.isAbsolute(relative3)) {
+  if (!relative3.startsWith("..") && !path16.isAbsolute(relative3)) {
     return relative3;
   }
   return targetPath;
@@ -10403,7 +10575,7 @@ function hasConvexDependency(packageJson) {
 }
 function createDefaultPackageJson(projectRoot) {
   return {
-    name: sanitizePackageName(path15.basename(projectRoot)),
+    name: sanitizePackageName(path16.basename(projectRoot)),
     private: true,
     type: "module"
   };
@@ -10432,7 +10604,7 @@ async function writePackageJson(packageJsonPath, packageJson) {
 `, "utf8");
 }
 async function ensurePackageJsonWithConvexDependency(projectRoot) {
-  const packageJsonPath = path15.join(projectRoot, "package.json");
+  const packageJsonPath = path16.join(projectRoot, "package.json");
   const existing = await readPackageJson(packageJsonPath);
   const packageJson = existing ?? createDefaultPackageJson(projectRoot);
   const createdPackageJson = existing === null;
@@ -10454,7 +10626,7 @@ async function ensurePackageJsonWithConvexDependency(projectRoot) {
   };
 }
 async function canResolveConvexRuntime(projectRoot) {
-  const requireFromProject = createRequire3(path15.join(projectRoot, "__concave__.js"));
+  const requireFromProject = createRequire3(path16.join(projectRoot, "__concave__.js"));
   try {
     requireFromProject.resolve("convex/values");
     requireFromProject.resolve("convex/server");
@@ -10479,7 +10651,7 @@ async function ensureConvexDependencyReady(projectRoot, commandName) {
   const packageManager = detectPackageManager(projectRoot);
   const addCommand = getAddConvexCommand(packageManager);
   const installCommand = getInstallCommand(packageManager);
-  const packageJsonPath = path15.join(projectRoot, "package.json");
+  const packageJsonPath = path16.join(projectRoot, "package.json");
   const packageJson = await readPackageJson(packageJsonPath);
   if (!packageJson) {
     console.error(import_picocolors9.default.red("✗ Missing package.json"));
@@ -10533,10 +10705,10 @@ function parseDotEnv2(content) {
 }
 async function loadDevEnvironment(cwd, layout) {
   const candidates = [
-    path15.join(layout.convexRootDir, ".env.local"),
-    path15.join(layout.convexRootDir, ".env"),
-    path15.join(cwd, ".env.local"),
-    path15.join(cwd, ".env")
+    path16.join(layout.convexRootDir, ".env.local"),
+    path16.join(layout.convexRootDir, ".env"),
+    path16.join(cwd, ".env.local"),
+    path16.join(cwd, ".env")
   ];
   const loaded = [];
   for (const filePath of candidates) {
@@ -10550,7 +10722,7 @@ async function loadDevEnvironment(cwd, layout) {
         process.env[key] = value;
       }
     }
-    loaded.push(path15.relative(cwd, filePath));
+    loaded.push(path16.relative(cwd, filePath));
   }
   return loaded;
 }
@@ -10563,11 +10735,11 @@ Examples:
   $ concave init my-app --force Overwrite starter files
 `).action(async (dir, opts) => {
   const cwd = process.cwd();
-  const projectRoot = path15.resolve(cwd, dir ?? ".");
+  const projectRoot = path16.resolve(cwd, dir ?? ".");
   const displayRoot = formatPathForDisplay(cwd, projectRoot);
   const layout = await resolveProjectLayout(projectRoot);
   const convexDir = layout.functionsDir;
-  const starterPath = path15.join(convexDir, "messages.ts");
+  const starterPath = path16.join(convexDir, "messages.ts");
   await fs12.mkdir(projectRoot, { recursive: true });
   await fs12.mkdir(convexDir, { recursive: true });
   const starterExists = existsSync2(starterPath);
@@ -10691,16 +10863,17 @@ Examples:
     });
     console.log(import_picocolors9.default.green(`✓ Generated worker entry (${result.moduleCount} module${result.moduleCount === 1 ? "" : "s"})`));
     const configPath = await ensureWranglerConfig(cwd);
-    console.log(import_picocolors9.default.green(`✓ Using config: ${path15.basename(configPath)}`));
-    const relativeConfigPath = path15.relative(cwd, configPath);
-    const wranglerArgs = ["wrangler", "dev", "--config", relativeConfigPath];
+    console.log(import_picocolors9.default.green(`✓ Using config: ${path16.basename(configPath)}`));
+    const relativeConfigPath = path16.relative(cwd, configPath);
+    const wranglerArgs = ["dev", "--config", relativeConfigPath];
     if (opts.port) {
       wranglerArgs.push("--port", opts.port);
     }
     console.log(import_picocolors9.default.cyan(`
 \uD83D\uDE80 Starting wrangler dev...
 `));
-    wranglerProcess = spawn2("bunx", wranglerArgs, {
+    const wranglerLauncher = resolveWranglerLauncher({ cwd });
+    wranglerProcess = spawn2(wranglerLauncher.command, [...wranglerLauncher.argsPrefix, ...wranglerArgs], {
       cwd,
       stdio: "inherit"
     });
@@ -10723,7 +10896,7 @@ Examples:
           try {
             await generateTypes(cwd, { silent: true });
           } catch {}
-          const relPath = path15.relative(cwd, filePath);
+          const relPath = path16.relative(cwd, filePath);
           console.log(import_picocolors9.default.dim(`   Updated worker entry (${event}: ${relPath || "convex/"}, ${regenResult.moduleCount} module${regenResult.moduleCount === 1 ? "" : "s"})`));
         } catch (error) {
           console.error(import_picocolors9.default.red("✗ Failed to update worker entry:"), error.message ?? error);
@@ -10905,10 +11078,10 @@ Examples:
     console.log(import_picocolors9.default.green(`✓ Generated standalone entry (${result.moduleCount} module${result.moduleCount === 1 ? "" : "s"})`));
     if (opts.verbose) {
       for (const file of result.sourceFiles) {
-        console.log(import_picocolors9.default.dim(`   ${path15.relative(cwd, file)}`));
+        console.log(import_picocolors9.default.dim(`   ${path16.relative(cwd, file)}`));
       }
     }
-    const outfile = path15.resolve(cwd, opts.outfile);
+    const outfile = path16.resolve(cwd, opts.outfile);
     const buildArgs = ["build", "--compile", result.entryFile, "--outfile", outfile];
     if (opts.target) {
       buildArgs.push("--target", `bun-${opts.target}`);
@@ -10938,13 +11111,13 @@ Examples:
       sizeStr = ` (${sizeMB} MB)`;
     } catch {}
     console.log(import_picocolors9.default.green(`
-✓ Built: ${path15.relative(cwd, outfile)}${sizeStr}`));
+✓ Built: ${path16.relative(cwd, outfile)}${sizeStr}`));
     if (opts.target) {
       console.log(import_picocolors9.default.dim(`   Target: bun-${opts.target}`));
     }
     console.log(import_picocolors9.default.dim(`
    Run it:`));
-    console.log(import_picocolors9.default.dim(`   ./${path15.relative(cwd, outfile)} --port 3000`));
+    console.log(import_picocolors9.default.dim(`   ./${path16.relative(cwd, outfile)} --port 3000`));
   } catch (error) {
     console.error(import_picocolors9.default.red("✗ Build failed:"), error.message);
     if (opts.verbose && error.stack) {
@@ -11026,7 +11199,7 @@ async function listFunctionSpecs(options) {
     const result = await response.json();
     const functions = result.value || result.result || [];
     if (options.file) {
-      const outPath = path15.resolve("function-spec.json");
+      const outPath = path16.resolve("function-spec.json");
       await fs12.writeFile(outPath, JSON.stringify(functions, null, 2) + `
 `);
       console.log(import_picocolors9.default.green(`✓ Wrote ${functions.length} function specs to ${outPath}`));
@@ -11139,7 +11312,7 @@ async function runBunDevServer(cwd, opts, artifacts, layout) {
         console.log(import_picocolors9.default.cyan(`
 \uD83D\uDE80 Server ready at ${import_picocolors9.default.bold(displayUrl)}`));
         console.log(import_picocolors9.default.dim(`   Dashboard:  ${displayUrl}/_dashboard`));
-        console.log(import_picocolors9.default.dim(`   Functions:  ${path15.relative(cwd, functionsDir)}/`));
+        console.log(import_picocolors9.default.dim(`   Functions:  ${path16.relative(cwd, functionsDir)}/`));
         console.log(import_picocolors9.default.dim(`
    Press Ctrl+C to stop
 `));
@@ -11180,7 +11353,7 @@ async function runBunDevServer(cwd, opts, artifacts, layout) {
       }
       reloadTimer = setTimeout(async () => {
         reloadTimer = undefined;
-        const relPath = path15.relative(cwd, filePath);
+        const relPath = path16.relative(cwd, filePath);
         try {
           await generateTypes(cwd, { silent: true });
         } catch {}
@@ -11248,7 +11421,7 @@ async function runBunDevServerForked(cwd, opts, artifacts, layout) {
   } catch (error) {
     console.warn(import_picocolors9.default.yellow(`⚠️  Auth keys setup failed: ${error.message}`));
   }
-  const tempScriptPath = path15.join(localData.dataDir, ".bun-dev-server.js");
+  const tempScriptPath = path16.join(localData.dataDir, ".bun-dev-server.js");
   const dashboardModulePath = artifacts.dashboardHtmlPath.replace(/\\/g, "/");
   const scriptContent = `import { BunServer } from "${artifacts.bunRuntime.serverEntryPath.replace(/\\/g, "/")}";
 import { DASHBOARD_HTML } from ${JSON.stringify(dashboardModulePath)};
@@ -11265,7 +11438,7 @@ const displayUrl = server.url.replace(/127\\.0\\.0\\.1|0\\.0\\.0\\.0/, "localhos
 
 console.log("\\n\uD83D\uDE80 Server ready at " + displayUrl);
 console.log("   Dashboard:  " + displayUrl + "/_dashboard");
-console.log("   Functions:  ${path15.relative(cwd, functionsDir).replace(/\\/g, "/")}/");
+console.log("   Functions:  ${path16.relative(cwd, functionsDir).replace(/\\/g, "/")}/");
 console.log("\\n   Press Ctrl+C to stop\\n");
 
 // Handle graceful shutdown
@@ -11400,7 +11573,7 @@ process.on("SIGTERM", async () => {
     }
     reloadTimer = setTimeout(async () => {
       reloadTimer = undefined;
-      const relPath = path15.relative(cwd, filePath);
+      const relPath = path16.relative(cwd, filePath);
       try {
         await generateTypes(cwd, { silent: true });
       } catch {}
@@ -11472,7 +11645,7 @@ function resolveTsxLoaderPath() {
   let tsxLoaderPath = "tsx";
   try {
     const tsxPackagePath = require2.resolve("tsx/package.json");
-    tsxLoaderPath = path15.join(path15.dirname(tsxPackagePath), "dist/loader.mjs");
+    tsxLoaderPath = path16.join(path16.dirname(tsxPackagePath), "dist/loader.mjs");
   } catch {
     tsxLoaderPath = "tsx";
   }
@@ -11560,7 +11733,7 @@ async function runNodeDevServer(cwd, opts, artifacts, layout) {
         console.log(import_picocolors9.default.cyan(`
 \uD83D\uDE80 Server ready at ${import_picocolors9.default.bold(displayUrl)}`));
         console.log(import_picocolors9.default.dim(`   Dashboard:  ${displayUrl}/_dashboard`));
-        console.log(import_picocolors9.default.dim(`   Functions:  ${path15.relative(cwd, functionsDir)}/`));
+        console.log(import_picocolors9.default.dim(`   Functions:  ${path16.relative(cwd, functionsDir)}/`));
         console.log(import_picocolors9.default.dim(`
    Press Ctrl+C to stop
 `));
@@ -11601,7 +11774,7 @@ async function runNodeDevServer(cwd, opts, artifacts, layout) {
       }
       reloadTimer = setTimeout(async () => {
         reloadTimer = undefined;
-        const relPath = path15.relative(cwd, filePath);
+        const relPath = path16.relative(cwd, filePath);
         try {
           await generateTypes(cwd, { silent: true });
         } catch {}
@@ -11673,11 +11846,11 @@ async function runNodeDevServerForked(cwd, opts, artifacts, layout) {
   let tsxLoaderPath;
   try {
     const tsxPackagePath = require2.resolve("tsx/package.json");
-    tsxLoaderPath = path15.join(path15.dirname(tsxPackagePath), "dist/loader.mjs");
+    tsxLoaderPath = path16.join(path16.dirname(tsxPackagePath), "dist/loader.mjs");
   } catch {
     tsxLoaderPath = "tsx";
   }
-  const tempScriptPath = path15.join(localData.dataDir, ".node-dev-server.mjs");
+  const tempScriptPath = path16.join(localData.dataDir, ".node-dev-server.mjs");
   const nodeDashboardModulePath = artifacts.dashboardHtmlPath.replace(/\\/g, "/");
   const scriptContent = `import { NodeServer } from "${artifacts.nodeRuntime.serverEntryPath.replace(/\\/g, "/")}";
 import { DASHBOARD_HTML } from ${JSON.stringify(nodeDashboardModulePath)};
@@ -11694,7 +11867,7 @@ const displayUrl = server.url.replace(/127\\.0\\.0\\.1|0\\.0\\.0\\.0/, "localhos
 
 console.log("\\n\uD83D\uDE80 Server ready at " + displayUrl);
 console.log("   Dashboard:  " + displayUrl + "/_dashboard");
-console.log("   Functions:  ${path15.relative(cwd, functionsDir).replace(/\\/g, "/")}/");
+console.log("   Functions:  ${path16.relative(cwd, functionsDir).replace(/\\/g, "/")}/");
 console.log("\\n   Press Ctrl+C to stop\\n");
 
 // Handle graceful shutdown
@@ -11830,7 +12003,7 @@ process.on("SIGTERM", async () => {
     }
     reloadTimer = setTimeout(async () => {
       reloadTimer = undefined;
-      const relPath = path15.relative(cwd, filePath);
+      const relPath = path16.relative(cwd, filePath);
       try {
         await generateTypes(cwd, { silent: true });
       } catch {}
@@ -11854,9 +12027,9 @@ process.on("SIGTERM", async () => {
 }
 async function ensureWranglerConfig(cwd) {
   const userConfigs = [
-    path15.join(cwd, "wrangler.jsonc"),
-    path15.join(cwd, "wrangler.json"),
-    path15.join(cwd, "wrangler.toml")
+    path16.join(cwd, "wrangler.jsonc"),
+    path16.join(cwd, "wrangler.json"),
+    path16.join(cwd, "wrangler.toml")
   ];
   for (const configPath of userConfigs) {
     try {
@@ -11865,8 +12038,8 @@ async function ensureWranglerConfig(cwd) {
     } catch {}
   }
   const concavePaths = getConcaveProjectPaths(cwd);
-  const generatedConfigPath = path15.join(concavePaths.concaveDir, "wrangler.jsonc");
-  const assetsDirectory = path15.join(concavePaths.concaveDir, "static");
+  const generatedConfigPath = path16.join(concavePaths.concaveDir, "wrangler.jsonc");
+  const assetsDirectory = path16.join(concavePaths.concaveDir, "static");
   await fs12.mkdir(assetsDirectory, { recursive: true });
   const config = {
     name: "concave-app",
@@ -11889,7 +12062,7 @@ async function ensureWranglerConfig(cwd) {
       }
     ]
   };
-  await fs12.mkdir(path15.dirname(generatedConfigPath), { recursive: true });
+  await fs12.mkdir(path16.dirname(generatedConfigPath), { recursive: true });
   await fs12.writeFile(generatedConfigPath, JSON.stringify(config, null, 2), "utf8");
   return generatedConfigPath;
 }