@concavejs/cli 0.0.1-alpha.7 → 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);
         }
@@ -4757,7 +4757,7 @@ async function loadAppDefinition(configPath, parentComponentPath, entries, visit
   for (const child of childComponents) {
     const componentPath = joinComponentPath(parentComponentPath, child.name);
     const definitionPath = resolveChildDefinitionPath(configPath, child.path);
-    const modulesDir = path.join(path.dirname(definitionPath), "convex");
+    const modulesDir = await resolveComponentModulesDir(definitionPath);
     entries.push({
       componentPath,
       modulesDir,
@@ -4780,7 +4780,7 @@ async function loadComponentDefinition(configPath, componentPath, entries, visit
   for (const child of childComponents) {
     const nestedComponentPath = joinComponentPath(componentPath, child.name);
     const definitionPath = resolveChildDefinitionPath(configPath, child.path);
-    const modulesDir = path.join(path.dirname(definitionPath), "convex");
+    const modulesDir = await resolveComponentModulesDir(definitionPath);
     entries.push({
       componentPath: nestedComponentPath,
       modulesDir,
@@ -4806,6 +4806,17 @@ function resolveChildDefinitionPath(parentConfigPath, childPath) {
   const parentDir = path.dirname(parentConfigPath);
   return path.resolve(parentDir, childPath);
 }
+async function resolveComponentModulesDir(definitionPath) {
+  const definitionDir = path.dirname(definitionPath);
+  const nestedConvexDir = path.join(definitionDir, "convex");
+  try {
+    const stats = await fs.stat(nestedConvexDir);
+    if (stats.isDirectory()) {
+      return nestedConvexDir;
+    }
+  } catch {}
+  return definitionDir;
+}
 function joinComponentPath(parent, child) {
   if (!parent) {
     return child;
@@ -5006,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;
 `;
@@ -5146,6 +5158,7 @@ async function generateUserEntry(projectRoot, outDir) {
   const componentManifest = await scanComponents(projectRoot);
   await writeComponentManifest(targetDir, componentManifest.entries);
   await copyComponentModules(targetDir, componentManifest.entries);
+  const componentLoaderBlocks = await buildComponentLoaderBlocks(targetDir, componentManifest.entries);
   const fallbackEntries = files.map((filePath) => {
     const importPath = formatImportPath(targetDir, filePath);
     return `	'${importPath}': () => import('${importPath}'),`;
@@ -5154,10 +5167,20 @@ async function generateUserEntry(projectRoot, outDir) {
   const content = `// Generated by concave CLI
 // Do not edit this file manually
 
+import { createModuleLoaderFromGlob, setConcaveModuleLoader } from "@concavejs/core/udf";
+
 const modules = import.meta?.glob?.(["../convex/**/*.*s", "!../**/*.*.*s"]) ?? {
 ${fallbackEntries}
 };
 
+const componentLoaders = [];
+${componentLoaderBlocks.join(`
+
+`)}
+for (const { componentPath, loader } of componentLoaders) {
+	setConcaveModuleLoader(loader, { componentPath });
+}
+
 export { modules };
 `;
   const contentWithFunctionsPath = content.replace('const modules = import.meta?.glob?.(["../convex/**/*.*s", "!../**/*.*.*s"]) ?? {', `const modules = import.meta?.glob?.([${JSON.stringify(functionsGlobPattern)}, "!../**/*.*.*s"]) ?? {`);
@@ -5462,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";
@@ -5573,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 = [];
@@ -5585,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) => {
@@ -5607,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();
@@ -5625,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));
     });
   });
 }
@@ -5644,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();
@@ -5669,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));
     });
   });
 }
@@ -5769,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 = "";
@@ -5790,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));
     });
   });
 }
@@ -5815,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",
@@ -5913,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);
@@ -6182,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...
@@ -6392,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,
@@ -6441,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;
 }
@@ -6489,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",
@@ -6521,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) {
@@ -6594,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 {}
@@ -6658,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: {
@@ -6787,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",
@@ -6835,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";
@@ -6922,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;
   }
@@ -6944,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;
   }
@@ -7301,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 {
@@ -7334,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);
@@ -7387,6 +7581,8 @@ import {
 } from "convex/server";
 import type { DataModel } from "./dataModel.js";
 
+export { defineSchema, defineTable } from "convex/server";
+
 /**
  * Define a query in this Convex app's public API.
  *
@@ -7507,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 */
@@ -7528,6 +7724,8 @@ import {
   internalActionGeneric,
   internalMutationGeneric,
   internalQueryGeneric,
+  defineSchema,
+  defineTable,
 } from "convex/server";
 
 /**
@@ -7599,8 +7797,13 @@ export const internalAction = internalActionGeneric;
  * @returns The wrapped endpoint function. Route a URL path to this function in \`convex/http.js\`.
  */
 export const httpAction = httpActionGeneric;
+
+/**
+ * Define a table in this Convex app's schema.
+ */
+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 */
@@ -7664,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");
@@ -7722,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 */
@@ -7735,8 +7938,59 @@ async function generateApiJs(generatedDir) {
  * @module
  */
 
-import { anyApi } from "convex/server";
-import { componentsGeneric } from "convex/server";
+const functionName = Symbol.for("functionName");
+const toReferencePath = Symbol.for("toReferencePath");
+
+function createApi(pathParts = []) {
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop === "string") {
+          return createApi([...pathParts, prop]);
+        }
+        if (prop === functionName) {
+          if (pathParts.length < 2) {
+            const found = ["api", ...pathParts].join(".");
+            throw new Error(
+              "API path is expected to be of the form \`api.moduleName.functionName\`. Found: \`" + found + "\`",
+            );
+          }
+          const modulePath = pathParts.slice(0, -1).join("/");
+          const exportName = pathParts[pathParts.length - 1];
+          return exportName === "default" ? modulePath : modulePath + ":" + exportName;
+        }
+        if (prop === Symbol.toStringTag) {
+          return "FunctionReference";
+        }
+        return undefined;
+      },
+    },
+  );
+}
+
+function createComponents(pathParts = []) {
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop === "string") {
+          return createComponents([...pathParts, prop]);
+        }
+        if (prop === toReferencePath) {
+          if (pathParts.length < 1) {
+            const found = ["components", ...pathParts].join(".");
+            throw new Error(
+              "API path is expected to be of the form \`components.childComponent.functionName\`. Found: \`" + found + "\`",
+            );
+          }
+          return "_reference/childComponent/" + pathParts.join("/");
+        }
+        return undefined;
+      },
+    },
+  );
+}
 
 /**
  * A utility for referencing Convex functions in your app's API.
@@ -7746,17 +8000,17 @@ import { componentsGeneric } from "convex/server";
  * const myFunctionReference = api.myModule.myFunction;
  * \`\`\`
  */
-export const api = anyApi;
-export const internal = anyApi;
-export const components = componentsGeneric();
+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
@@ -7873,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}
 `));
@@ -7946,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;
@@ -8076,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)) {
@@ -8257,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 = {
@@ -8271,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 */
@@ -8297,6 +8551,8 @@ import {
 } from "convex/server";
 import type { DataModel } from "./dataModel.js";
 
+export { defineSchema, defineTable } from "convex/server";
+
 export declare const query: QueryBuilder<DataModel, "public">;
 export declare const internalQuery: QueryBuilder<DataModel, "internal">;
 export declare const mutation: MutationBuilder<DataModel, "public">;
@@ -8311,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 */
@@ -8332,17 +8588,86 @@ import {
   internalActionGeneric,
   internalMutationGeneric,
   internalQueryGeneric,
+  defineSchema,
+  defineTable,
 } from "convex/server";
 
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an \`export\` to name it and make it accessible.
+ */
 export const query = queryGeneric;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an \`export\` to name it and make it accessible.
+ */
 export const internalQuery = internalQueryGeneric;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an \`export\` to name it and make it accessible.
+ */
 export const mutation = mutationGeneric;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an \`export\` to name it and make it accessible.
+ */
 export const internalMutation = internalMutationGeneric;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an \`export\` to name it and make it accessible.
+ */
 export const action = actionGeneric;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an \`export\` to name it and make it accessible.
+ */
 export const internalAction = internalActionGeneric;
+
+/**
+ * Define a Convex HTTP action.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument, and a \`Request\` object
+ * as its second.
+ * @returns The wrapped endpoint function. Route a URL path to this function in \`convex/http.js\`.
+ */
 export const httpAction = httpActionGeneric;
+
+/**
+ * Define a table in this Convex app's schema.
+ */
+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 */
@@ -8370,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 */
@@ -8383,7 +8708,59 @@ async function generateApiJs2(generatedDir) {
  * @module
  */
 
-import { anyApi, componentsGeneric } from "convex/server";
+const functionName = Symbol.for("functionName");
+const toReferencePath = Symbol.for("toReferencePath");
+
+function createApi(pathParts = []) {
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop === "string") {
+          return createApi([...pathParts, prop]);
+        }
+        if (prop === functionName) {
+          if (pathParts.length < 2) {
+            const found = ["api", ...pathParts].join(".");
+            throw new Error(
+              "API path is expected to be of the form \`api.moduleName.functionName\`. Found: \`" + found + "\`",
+            );
+          }
+          const modulePath = pathParts.slice(0, -1).join("/");
+          const exportName = pathParts[pathParts.length - 1];
+          return exportName === "default" ? modulePath : modulePath + ":" + exportName;
+        }
+        if (prop === Symbol.toStringTag) {
+          return "FunctionReference";
+        }
+        return undefined;
+      },
+    },
+  );
+}
+
+function createComponents(pathParts = []) {
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop === "string") {
+          return createComponents([...pathParts, prop]);
+        }
+        if (prop === toReferencePath) {
+          if (pathParts.length < 1) {
+            const found = ["components", ...pathParts].join(".");
+            throw new Error(
+              "API path is expected to be of the form \`components.childComponent.functionName\`. Found: \`" + found + "\`",
+            );
+          }
+          return "_reference/childComponent/" + pathParts.join("/");
+        }
+        return undefined;
+      },
+    },
+  );
+}
 
 /**
  * A utility for referencing Convex functions in your app's API.
@@ -8393,11 +8770,11 @@ import { anyApi, componentsGeneric } from "convex/server";
  * const myFunctionReference = api.myModule.myFunction;
  * \`\`\`
  */
-export const api = anyApi;
-export const internal = anyApi;
-export const components = componentsGeneric();
+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
@@ -8477,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;
     }
@@ -8502,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)
@@ -8543,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) {
@@ -8955,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) {
@@ -8980,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);
@@ -8995,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) => {
@@ -9004,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) {}
@@ -9034,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;
@@ -9056,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));
         }
       })
     };
@@ -9079,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
     };
@@ -9095,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
@@ -9118,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) {
@@ -9132,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;
           }
@@ -9160,7 +9537,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path14, item) {
+  async _handleSymlink(entry, directory, path15, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -9170,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;
@@ -9180,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;
@@ -9214,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) {
@@ -9225,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) => {
@@ -9275,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);
@@ -9297,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);
@@ -9308,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;
       }
     }
   }
@@ -9374,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;
     }
   }
@@ -9433,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);
 
@@ -9502,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 = [];
@@ -9618,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;
@@ -9650,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
         });
       }
@@ -9709,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) {
@@ -9758,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);
@@ -9786,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);
@@ -9810,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;
         }
@@ -9861,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;
@@ -9872,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);
@@ -9892,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);
   }
@@ -9973,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";
@@ -9982,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) => {
@@ -10029,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);
@@ -10056,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);
@@ -10098,7 +10475,7 @@ function setupAuthEnvironment(keys, siteUrl, options = {}) {
   setEnv("AUTH_SKIP_VERIFICATION", "true");
 }
 // package.json
-var version = "0.0.1-alpha.7";
+var version = "0.0.1-alpha.9";
 
 // src/cli/cli.ts
 var WATCH_IGNORE_PATTERNS = [
@@ -10138,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";
@@ -10184,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;
@@ -10198,7 +10575,7 @@ function hasConvexDependency(packageJson) {
 }
 function createDefaultPackageJson(projectRoot) {
   return {
-    name: sanitizePackageName(path15.basename(projectRoot)),
+    name: sanitizePackageName(path16.basename(projectRoot)),
     private: true,
     type: "module"
   };
@@ -10227,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;
@@ -10249,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");
@@ -10274,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"));
@@ -10284,7 +10661,7 @@ async function ensureConvexDependencyReady(projectRoot, commandName) {
   }
   if (!hasConvexDependency(packageJson)) {
     console.error(import_picocolors9.default.red("✗ Missing dependency: convex"));
-    console.error(import_picocolors9.default.dim("   Concave function files import `convex/values` and generated files import `convex/server`."));
+    console.error(import_picocolors9.default.dim("   Concave function files import `convex/values` and generated types depend on `convex/server`."));
     console.error(import_picocolors9.default.dim(`   Run: ${addCommand.display}`));
     process.exit(1);
   }
@@ -10328,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) {
@@ -10345,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;
 }
@@ -10358,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);
@@ -10486,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"
     });
@@ -10518,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);
@@ -10700,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}`);
@@ -10733,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) {
@@ -10821,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}`));
@@ -10934,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
 `));
@@ -10947,17 +11325,15 @@ async function runBunDevServer(cwd, opts, artifacts, layout) {
         throw error;
       }
     };
-    const restartServer = async (reason) => {
+    const reloadServer = async (reason) => {
       if (isRestarting)
         return;
       isRestarting = true;
       try {
-        console.log(import_picocolors9.default.yellow(`
-⟳ ${reason}`));
-        if (server) {
-          await server.close();
-        }
-        await startServer();
+        console.log(import_picocolors9.default.dim(`
+   ⟳ ${reason}`));
+        await server.reload();
+        console.log(import_picocolors9.default.dim(`   ✓ Reloaded`));
       } catch (error) {
         console.error(import_picocolors9.default.red("✗ Failed to reload server:"), error.message);
       } finally {
@@ -10977,11 +11353,11 @@ 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 {}
-        restartServer(`File changed: ${relPath}`);
+        reloadServer(`File changed: ${relPath}`);
       }, 300);
     };
     watcher.on("add", (filePath) => scheduleReload("added", filePath)).on("change", (filePath) => scheduleReload("changed", filePath)).on("unlink", (filePath) => scheduleReload("deleted", filePath));
@@ -11045,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)};
@@ -11062,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
@@ -11088,20 +11464,136 @@ process.on("SIGTERM", async () => {
 `;
   await fs12.writeFile(tempScriptPath, scriptContent, "utf8");
   const bunArgs = [tempScriptPath];
-  const bunProcess = spawn2("bun", bunArgs, {
-    cwd,
-    stdio: "inherit"
-  });
-  bunProcess.on("exit", (code) => {
-    fs12.unlink(tempScriptPath).catch(() => {});
-    process.exit(code ?? 0);
-  });
-  process.on("SIGINT", () => {
-    bunProcess.kill("SIGTERM");
-  });
-  process.on("SIGTERM", () => {
-    bunProcess.kill("SIGTERM");
+  let watcher;
+  let bunProcess;
+  let reloadTimer;
+  let isRestarting = false;
+  let isShuttingDown = false;
+  const stopBunProcess = async () => {
+    const activeProcess = bunProcess;
+    if (!activeProcess || activeProcess.exitCode !== null) {
+      return;
+    }
+    await new Promise((resolve3) => {
+      let settled = false;
+      let forceKillTimer;
+      const finish = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        if (forceKillTimer) {
+          clearTimeout(forceKillTimer);
+          forceKillTimer = undefined;
+        }
+        activeProcess.off("exit", onExit);
+        resolve3();
+      };
+      const onExit = () => finish();
+      activeProcess.once("exit", onExit);
+      try {
+        activeProcess.kill("SIGTERM");
+      } catch {
+        finish();
+        return;
+      }
+      forceKillTimer = setTimeout(() => {
+        if (settled) {
+          return;
+        }
+        try {
+          activeProcess.kill("SIGKILL");
+        } catch {
+          finish();
+        }
+      }, 2000);
+    });
+  };
+  const cleanup = async () => {
+    if (reloadTimer) {
+      clearTimeout(reloadTimer);
+      reloadTimer = undefined;
+    }
+    if (watcher) {
+      await watcher.close();
+      watcher = undefined;
+    }
+    await stopBunProcess();
+    await fs12.unlink(tempScriptPath).catch(() => {});
+  };
+  const spawnBunProcess = () => {
+    const child = spawn2("bun", bunArgs, {
+      cwd,
+      stdio: "inherit"
+    });
+    child.on("exit", (code) => {
+      if (isRestarting || isShuttingDown) {
+        return;
+      }
+      cleanup().catch(() => {}).finally(() => {
+        process.exit(code ?? 0);
+      });
+    });
+    return child;
+  };
+  const reloadServerViaHttp = async (reason) => {
+    if (isRestarting || isShuttingDown) {
+      return;
+    }
+    isRestarting = true;
+    try {
+      console.log(import_picocolors9.default.dim(`
+   ⟳ ${reason}`));
+      const response = await fetch(`http://127.0.0.1:${port}/_dev/reload`, {
+        method: "POST",
+        signal: AbortSignal.timeout(5000)
+      });
+      if (response.ok) {
+        console.log(import_picocolors9.default.dim(`   ✓ Reloaded`));
+      } else {
+        throw new Error(`HTTP ${response.status}`);
+      }
+    } catch (error) {
+      console.warn(import_picocolors9.default.dim(`   HTTP reload failed (${error.message}), restarting process...`));
+      await stopBunProcess();
+      bunProcess = spawnBunProcess();
+    } finally {
+      isRestarting = false;
+    }
+  };
+  bunProcess = spawnBunProcess();
+  watcher = esm_default.watch(convexDir, {
+    ignoreInitial: true,
+    ignored: WATCH_IGNORE_PATTERNS,
+    persistent: true
   });
+  const scheduleReload = (_event, filePath) => {
+    if (reloadTimer) {
+      clearTimeout(reloadTimer);
+    }
+    reloadTimer = setTimeout(async () => {
+      reloadTimer = undefined;
+      const relPath = path16.relative(cwd, filePath);
+      try {
+        await generateTypes(cwd, { silent: true });
+      } catch {}
+      await reloadServerViaHttp(`File changed: ${relPath}`);
+    }, 300);
+  };
+  watcher.on("add", (filePath) => scheduleReload("added", filePath)).on("change", (filePath) => scheduleReload("changed", filePath)).on("unlink", (filePath) => scheduleReload("deleted", filePath));
+  const shutdown = async () => {
+    if (isShuttingDown) {
+      return;
+    }
+    isShuttingDown = true;
+    console.log(import_picocolors9.default.cyan(`
+
+\uD83C\uDF0A Shutting down Concave dev server...`));
+    await cleanup();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
 }
 async function ensureNodeSqliteReady() {
   const hasFlag = process.execArgv.includes("--experimental-sqlite");
@@ -11153,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";
   }
@@ -11241,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
 `));
@@ -11254,17 +11746,15 @@ async function runNodeDevServer(cwd, opts, artifacts, layout) {
         throw error;
       }
     };
-    const restartServer = async (reason) => {
+    const reloadServer = async (reason) => {
       if (isRestarting)
         return;
       isRestarting = true;
       try {
-        console.log(import_picocolors9.default.yellow(`
-⟳ ${reason}`));
-        if (server) {
-          await server.close();
-        }
-        await startServer();
+        console.log(import_picocolors9.default.dim(`
+   ⟳ ${reason}`));
+        await server.reload();
+        console.log(import_picocolors9.default.dim(`   ✓ Reloaded`));
       } catch (error) {
         console.error(import_picocolors9.default.red("✗ Failed to reload server:"), error.message);
       } finally {
@@ -11284,11 +11774,11 @@ 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 {}
-        restartServer(`File changed: ${relPath}`);
+        reloadServer(`File changed: ${relPath}`);
       }, 300);
     };
     watcher.on("add", (filePath) => scheduleReload("added", filePath)).on("change", (filePath) => scheduleReload("changed", filePath)).on("unlink", (filePath) => scheduleReload("deleted", filePath));
@@ -11356,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)};
@@ -11377,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
@@ -11404,26 +11894,142 @@ process.on("SIGTERM", async () => {
   await fs12.writeFile(tempScriptPath, scriptContent, "utf8");
   const nodeArgs = ["--experimental-sqlite", "--import", tsxLoaderPath, tempScriptPath];
   const executable = detectHostRuntime() === "node" ? process.execPath : "node";
-  const nodeProcess = spawn2(executable, nodeArgs, {
-    cwd,
-    stdio: "inherit"
-  });
-  nodeProcess.on("exit", (code) => {
-    fs12.unlink(tempScriptPath).catch(() => {});
-    process.exit(code ?? 0);
-  });
-  process.on("SIGINT", () => {
-    nodeProcess.kill("SIGTERM");
-  });
-  process.on("SIGTERM", () => {
-    nodeProcess.kill("SIGTERM");
+  let watcher;
+  let nodeProcess;
+  let reloadTimer;
+  let isRestarting = false;
+  let isShuttingDown = false;
+  const stopNodeProcess = async () => {
+    const activeProcess = nodeProcess;
+    if (!activeProcess || activeProcess.exitCode !== null) {
+      return;
+    }
+    await new Promise((resolve3) => {
+      let settled = false;
+      let forceKillTimer;
+      const finish = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        if (forceKillTimer) {
+          clearTimeout(forceKillTimer);
+          forceKillTimer = undefined;
+        }
+        activeProcess.off("exit", onExit);
+        resolve3();
+      };
+      const onExit = () => finish();
+      activeProcess.once("exit", onExit);
+      try {
+        activeProcess.kill("SIGTERM");
+      } catch {
+        finish();
+        return;
+      }
+      forceKillTimer = setTimeout(() => {
+        if (settled) {
+          return;
+        }
+        try {
+          activeProcess.kill("SIGKILL");
+        } catch {
+          finish();
+        }
+      }, 2000);
+    });
+  };
+  const cleanup = async () => {
+    if (reloadTimer) {
+      clearTimeout(reloadTimer);
+      reloadTimer = undefined;
+    }
+    if (watcher) {
+      await watcher.close();
+      watcher = undefined;
+    }
+    await stopNodeProcess();
+    await fs12.unlink(tempScriptPath).catch(() => {});
+  };
+  const spawnNodeProcess = () => {
+    const child = spawn2(executable, nodeArgs, {
+      cwd,
+      stdio: "inherit"
+    });
+    child.on("exit", (code) => {
+      if (isRestarting || isShuttingDown) {
+        return;
+      }
+      cleanup().catch(() => {}).finally(() => {
+        process.exit(code ?? 0);
+      });
+    });
+    return child;
+  };
+  const reloadServerViaHttp = async (reason) => {
+    if (isRestarting || isShuttingDown) {
+      return;
+    }
+    isRestarting = true;
+    try {
+      console.log(import_picocolors9.default.dim(`
+   ⟳ ${reason}`));
+      const response = await fetch(`http://127.0.0.1:${port}/_dev/reload`, {
+        method: "POST",
+        signal: AbortSignal.timeout(5000)
+      });
+      if (response.ok) {
+        console.log(import_picocolors9.default.dim(`   ✓ Reloaded`));
+      } else {
+        throw new Error(`HTTP ${response.status}`);
+      }
+    } catch (error) {
+      console.warn(import_picocolors9.default.dim(`   HTTP reload failed (${error.message}), restarting process...`));
+      await stopNodeProcess();
+      nodeProcess = spawnNodeProcess();
+    } finally {
+      isRestarting = false;
+    }
+  };
+  nodeProcess = spawnNodeProcess();
+  watcher = esm_default.watch(convexDir, {
+    ignoreInitial: true,
+    ignored: WATCH_IGNORE_PATTERNS,
+    persistent: true
   });
+  const scheduleReload = (_event, filePath) => {
+    if (reloadTimer) {
+      clearTimeout(reloadTimer);
+    }
+    reloadTimer = setTimeout(async () => {
+      reloadTimer = undefined;
+      const relPath = path16.relative(cwd, filePath);
+      try {
+        await generateTypes(cwd, { silent: true });
+      } catch {}
+      await reloadServerViaHttp(`File changed: ${relPath}`);
+    }, 300);
+  };
+  watcher.on("add", (filePath) => scheduleReload("added", filePath)).on("change", (filePath) => scheduleReload("changed", filePath)).on("unlink", (filePath) => scheduleReload("deleted", filePath));
+  const shutdown = async () => {
+    if (isShuttingDown) {
+      return;
+    }
+    isShuttingDown = true;
+    console.log(import_picocolors9.default.cyan(`
+
+\uD83C\uDF0A Shutting down Concave dev server...`));
+    await cleanup();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
 }
 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 {
@@ -11432,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",
@@ -11456,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;
 }