@luckystack/devkit 0.1.9 → 0.2.1

package/dist/index.js

@@ -1,3 +1,7 @@
+import {
+  validateDeploy
+} from "./chunk-YYWCJ7VZ.js";
+
 // src/typeMap/discovery.ts
 import fs from "fs";
 import path from "path";
@@ -68,7 +72,15 @@ var toForwardSlashRelative = (absolute) => {
   const rel = path.relative(ROOT_DIR, absolute);
   return rel.replaceAll("\\", "/");
 };
-var walkFiles = (dir, matcher, results = []) => {
+var walkFiles = (dir, matcher, results = [], visited = /* @__PURE__ */ new Set()) => {
+  let realDir;
+  try {
+    realDir = fs.realpathSync(dir);
+  } catch {
+    return results;
+  }
+  if (visited.has(realDir)) return results;
+  visited.add(realDir);
   const { ignore } = getRoutingRules();
   try {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -76,9 +88,14 @@ var walkFiles = (dir, matcher, results = []) => {
       const fullPath = path.join(dir, entry.name);
       const relativePath = toForwardSlashRelative(fullPath);
       if (ignore(relativePath)) continue;
-      if (entry.isDirectory()) {
+      if (entry.isDirectory() || entry.isSymbolicLink()) {
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        walkFiles(fullPath, matcher, results);
+        try {
+          if (fs.statSync(fullPath).isDirectory()) {
+            walkFiles(fullPath, matcher, results, visited);
+          }
+        } catch {
+        }
         continue;
       }
       if (entry.isFile() && matcher(fullPath, entry.name)) {
@@ -93,27 +110,28 @@ var walkFiles = (dir, matcher, results = []) => {
 var findAllApiFiles = (srcDir) => {
   const apiSegment = apiMarkerSegment();
   return walkFiles(srcDir, (fullPath, entryName) => {
-    const normalized = fullPath.replace(/\\/g, "/");
+    const normalized = fullPath.replaceAll("\\", "/");
     return isApiFileName(entryName) && normalized.includes(apiSegment);
   });
 };
 var findAllSyncServerFiles = (srcDir) => {
   const syncSegment = syncMarkerSegment();
   return walkFiles(srcDir, (fullPath, entryName) => {
-    const normalized = fullPath.replace(/\\/g, "/");
+    const normalized = fullPath.replaceAll("\\", "/");
     return isSyncServerFileName(entryName) && normalized.includes(syncSegment);
   });
 };
 var findAllSyncClientFiles = (srcDir) => {
   const syncSegment = syncMarkerSegment();
   return walkFiles(srcDir, (fullPath, entryName) => {
-    const normalized = fullPath.replace(/\\/g, "/");
+    const normalized = fullPath.replaceAll("\\", "/");
     return isSyncClientFileName(entryName) && normalized.includes(syncSegment);
   });
 };
 
 // src/typeMap/routeMeta.ts
 import path2 from "path";
+import { getSrcDir } from "@luckystack/core";
 
 // src/routeConventions.ts
 var API_VERSION_TOKEN_REGEX = /_v(\d+)$/;
@@ -139,71 +157,76 @@ var stripVersionSuffix = (name) => {
   return name.replace(VERSION_SUFFIX_REGEX, "");
 };
 var extractVersionFromName = (name) => {
-  const match = name.match(VERSION_SUFFIX_REGEX);
+  const match = VERSION_SUFFIX_REGEX.exec(name);
   if (!match) return null;
   return `v${match[1]}`;
 };
 var extractPagePath = (filePath) => {
-  const normalized = filePath.replace(/\\/g, "/");
-  const match = normalized.match(/src\/(?:(.+?)\/)_api\//);
+  const normalized = filePath.replaceAll("\\", "/");
+  const srcDirNormalized = getSrcDir().replaceAll("\\", "/");
+  const rel = path2.posix.relative(srcDirNormalized, normalized);
+  if (rel.startsWith("..")) {
+    throw new Error(`[routeMeta] file is outside srcDir \u2014 cannot extract page path: ${filePath}`);
+  }
+  const match = /^(?:(.+?)\/)_api\//.exec(rel);
   if (match) {
-    return match[1] || "system";
+    return match[1] ?? "system";
   }
-  if (normalized.includes("/src/_api/")) {
+  if (rel.startsWith("_api/")) {
     return "system";
   }
   return "";
 };
 var extractApiName = (filePath) => {
-  const normalized = filePath.replace(/\\/g, "/");
-  const match = normalized.match(/_api\/(.+)\.ts$/);
+  const normalized = filePath.replaceAll("\\", "/");
+  const match = /_api\/(.+)\.ts$/.exec(normalized);
   const rawName = match?.[1] ?? path2.basename(filePath, ".ts");
   return stripVersionSuffix(rawName);
 };
 var extractApiVersion = (filePath) => {
-  const normalized = filePath.replace(/\\/g, "/");
-  const match = normalized.match(/_api\/(.+)\.ts$/);
+  const normalized = filePath.replaceAll("\\", "/");
+  const match = /_api\/(.+)\.ts$/.exec(normalized);
   const rawName = match?.[1] ?? path2.basename(filePath, ".ts");
-  return extractVersionFromName(rawName) || "v1";
+  return extractVersionFromName(rawName) ?? "v1";
 };
 var extractSyncPagePath = (filePath) => {
-  const normalized = filePath.replace(/\\/g, "/");
-  const match = normalized.match(/src\/(?:(.+?)\/)_sync\//);
+  const normalized = filePath.replaceAll("\\", "/");
+  const srcDirNormalized = getSrcDir().replaceAll("\\", "/");
+  const rel = path2.posix.relative(srcDirNormalized, normalized);
+  const match = /^(?:(.+?)\/)_sync\//.exec(rel);
   if (match) {
-    return match[1] || "root";
+    return match[1] ?? "system";
   }
-  if (normalized.includes("/src/_sync/")) {
-    return "root";
+  if (rel.startsWith("_sync/")) {
+    return "system";
   }
   return "";
 };
 var extractSyncName = (filePath) => {
-  const normalized = filePath.replace(/\\/g, "/");
-  const match = normalized.match(/_sync\/(.+)\.ts$/);
+  const normalized = filePath.replaceAll("\\", "/");
+  const match = /_sync\/(.+)\.ts$/.exec(normalized);
   if (!match) {
     const basename = path2.basename(filePath, ".ts");
-    const rawName2 = basename.replace(SYNC_VERSION_TOKEN_REGEX, "");
-    return rawName2;
+    return basename.replace(SYNC_VERSION_TOKEN_REGEX, "");
   }
-  const rawName = (match[1] ?? "").replace(SYNC_VERSION_TOKEN_REGEX, "");
-  return rawName;
+  return (match[1] ?? "").replace(SYNC_VERSION_TOKEN_REGEX, "");
 };
 var extractSyncVersion = (filePath) => {
-  const normalized = filePath.replace(/\\/g, "/");
-  const match = normalized.match(/_sync\/(.+)\.ts$/);
+  const normalized = filePath.replaceAll("\\", "/");
+  const match = /_sync\/(.+)\.ts$/.exec(normalized);
   if (!match) {
     const basename = path2.basename(filePath, ".ts");
-    const versionMatch2 = basename.match(SYNC_VERSION_TOKEN_REGEX);
+    const versionMatch2 = SYNC_VERSION_TOKEN_REGEX.exec(basename);
     return versionMatch2 ? `v${versionMatch2[2] ?? "1"}` : "v1";
   }
-  const versionMatch = (match[1] ?? "").match(SYNC_VERSION_TOKEN_REGEX);
+  const versionMatch = SYNC_VERSION_TOKEN_REGEX.exec(match[1] ?? "");
   return versionMatch ? `v${versionMatch[2] ?? "1"}` : "v1";
 };
 
 // src/typeMap/apiMeta.ts
 import * as ts from "typescript";
 import fs2 from "fs";
-import { inferHttpMethod } from "@luckystack/core";
+import { inferHttpMethod, tryCatchSync } from "@luckystack/core";
 var findExportedConst = (sourceFile, name) => {
   for (const statement of sourceFile.statements) {
     if (!ts.isVariableStatement(statement)) continue;
@@ -223,22 +246,24 @@ var unwrapExpression = (node) => {
   return current;
 };
 var extractHttpMethod = (filePath, apiName) => {
-  try {
+  const [error, method] = tryCatchSync(() => {
     const content = fs2.readFileSync(filePath, "utf8");
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
     const decl = findExportedConst(sourceFile, "httpMethod");
     const initializer = decl?.initializer ? unwrapExpression(decl.initializer) : void 0;
     if (initializer && ts.isStringLiteral(initializer)) {
-      const method = initializer.text.toUpperCase();
-      if (["GET", "POST", "PUT", "DELETE"].includes(method)) return method;
+      const candidate = initializer.text.toUpperCase();
+      if (["GET", "POST", "PUT", "DELETE"].includes(candidate)) return candidate;
     }
-  } catch (error) {
+    return void 0;
+  });
+  if (error) {
     console.error(`[TypeMapGenerator] Error extracting httpMethod from ${filePath}:`, error);
   }
-  return inferHttpMethod(apiName);
+  return method ?? inferHttpMethod(apiName);
 };
 var extractRateLimit = (filePath) => {
-  try {
+  const [error, rateLimit] = tryCatchSync(() => {
     const content = fs2.readFileSync(filePath, "utf8");
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
     const decl = findExportedConst(sourceFile, "rateLimit");
@@ -247,10 +272,12 @@ var extractRateLimit = (filePath) => {
       if (initializer.kind === ts.SyntaxKind.FalseKeyword) return false;
       if (ts.isNumericLiteral(initializer)) return Number(initializer.text);
     }
-  } catch (error) {
+    return void 0;
+  });
+  if (error) {
     console.error(`[TypeMapGenerator] Error extracting rateLimit from ${filePath}:`, error);
   }
-  return void 0;
+  return rateLimit ?? void 0;
 };
 var readPrimitive = (rawNode) => {
   const node = unwrapExpression(rawNode);
@@ -269,23 +296,23 @@ var parseAdditionalItem = (objectLiteral) => {
   }
   return item.key ? item : null;
 };
+var commentToString = (commentValue) => {
+  if (typeof commentValue === "string") return commentValue;
+  if (Array.isArray(commentValue)) {
+    return commentValue.map((part) => {
+      if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+        return part.text;
+      }
+      return "";
+    }).join("");
+  }
+  return "";
+};
 var extractDocsMeta = (filePath) => {
-  try {
+  const [error, docsMeta] = tryCatchSync(() => {
     const content = fs2.readFileSync(filePath, "utf8");
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
     const result = {};
-    const commentToString = (commentValue) => {
-      if (typeof commentValue === "string") return commentValue;
-      if (Array.isArray(commentValue)) {
-        return commentValue.map((part) => {
-          if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
-            return part.text;
-          }
-          return "";
-        }).join("");
-      }
-      return "";
-    };
     const consumeTag = (tag) => {
       if (tag.tagName.text !== "docs") return;
       const commentText = commentToString(tag.comment).trim();
@@ -311,19 +338,21 @@ var extractDocsMeta = (filePath) => {
       return void 0;
     }
     return result;
-  } catch (error) {
+  });
+  if (error) {
     console.error(`[TypeMapGenerator] Error extracting @docs metadata from ${filePath}:`, error);
     return void 0;
   }
+  return docsMeta ?? void 0;
 };
 var extractAuth = (filePath) => {
-  try {
+  const [, auth] = tryCatchSync(() => {
     const content = fs2.readFileSync(filePath, "utf8");
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
     const decl = findExportedConst(sourceFile, "auth");
     const authInitializer = decl?.initializer ? unwrapExpression(decl.initializer) : void 0;
-    if (!authInitializer || !ts.isObjectLiteralExpression(authInitializer)) return { login: true };
-    let login = true;
+    if (!authInitializer || !ts.isObjectLiteralExpression(authInitializer)) return { login: false };
+    let login = false;
     let additional;
     for (const prop of authInitializer.properties) {
       if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
@@ -341,9 +370,8 @@ var extractAuth = (filePath) => {
       }
     }
     return additional && additional.length > 0 ? { login, additional } : { login };
-  } catch {
-  }
-  return { login: true };
+  });
+  return auth ?? { login: false };
 };
 
 // src/typeMap/emitterArtifacts.ts
@@ -454,7 +482,7 @@ var convertTypeNode = (node) => {
       }
       return `${JSON.stringify(name)}: ${schema}`;
     }).filter((entry) => entry !== null);
-    return `z.object({ ${entries.join(", ")} })`;
+    return `z.object({ ${entries.join(", ")} }).strict()`;
   }
   if (ts2.isParenthesizedTypeNode(node)) {
     return convertTypeNode(node.type);
@@ -604,6 +632,37 @@ var validateGeneratedTypeIdentifiers = (content) => {
     throw new Error(`[TypeMapGenerator] Generated type map has unresolved type identifiers: ${unknown.join(", ")}`);
   }
 };
+var collectFallbacks = (typesByPage, syncTypesByPage) => {
+  const entries = [];
+  const flagField = (route, kind, field, value) => {
+    if (value === "{ }" || value === "{ status: string }") {
+      entries.push({ route, kind, field, fallback: value, reason: "default-fallback" });
+      return;
+    }
+    const zodSrc = typeTextToZodSource(value);
+    if (zodSrc?.includes("z.any()")) {
+      entries.push({ route, kind, field, fallback: value.slice(0, 80), reason: "zod-any-fallback" });
+    }
+  };
+  for (const [pagePath, apis] of typesByPage) {
+    for (const [apiKey, entry] of apis) {
+      const { name, version } = splitVersionedKey(apiKey);
+      const route = `${pagePath}/${name}@${version}`;
+      flagField(route, "api", "input", entry.input);
+      flagField(route, "api", "output", entry.output);
+    }
+  }
+  for (const [pagePath, syncs] of syncTypesByPage) {
+    for (const [syncKey, entry] of syncs) {
+      const { name, version } = splitVersionedKey(syncKey);
+      const route = `${pagePath}/${name}@${version}`;
+      flagField(route, "sync", "clientInput", entry.clientInput);
+      flagField(route, "sync", "serverOutput", entry.serverOutput);
+      flagField(route, "sync", "clientOutput", entry.clientOutput);
+    }
+  }
+  return entries;
+};
 var buildTypeMapArtifacts = ({
   typesByPage,
   syncTypesByPage,
@@ -701,7 +760,7 @@ type _ProjectApiTypeMap = {
 `;
         content += `        input: ${indentStr(entry.input, "        ")};
 `;
-        content += `        output: ${indentStr(entry.output, "        ")};
+        content += `        output: ${indentStr(entry.output, "        ")} | { status: 'error'; errorCode: string; [key: string]: unknown };
 `;
         content += `        stream: ${indentStr(entry.stream, "        ")};
 `;
@@ -844,16 +903,21 @@ type _ProjectSyncTypeMap = {
           clientOutput: entry.clientOutput,
           serverStream: entry.serverStream,
           clientStream: entry.clientStream,
-          path: pagePath === "root" ? `sync/${syncName}/${version}` : `sync/${pagePath}/${syncName}/${version}`,
+          //? `extractSyncPagePath` returns the `'system'` sentinel (NOT
+          //? `'root'`) for a src-root sync, matching the loader's runtime key
+          //? (`sync/system/<name>/<version>`) AND the wire name the typed
+          //? `syncRequest` sends. The old `pagePath === 'root'` branch is now
+          //? dead and would emit a non-matching path, so it is removed.
+          path: `sync/${pagePath}/${syncName}/${version}`,
           ...entry.meta ? { meta: entry.meta } : {}
         });
         content += `      '${version}': {
 `;
         content += `        clientInput: ${indentStr(entry.clientInput, "        ")};
 `;
-        content += `        serverOutput: ${indentStr(entry.serverOutput, "        ")};
+        content += `        serverOutput: ${indentStr(entry.serverOutput, "        ")} | { status: 'error'; errorCode: string; [key: string]: unknown };
 `;
-        content += `        clientOutput: ${indentStr(entry.clientOutput, "        ")};
+        content += `        clientOutput: ${indentStr(entry.clientOutput, "        ")} | { status: 'error'; errorCode: string; [key: string]: unknown };
 `;
         content += `        serverStream: ${indentStr(entry.serverStream, "        ")};
 `;
@@ -897,7 +961,15 @@ declare module '@luckystack/core/typemap' {
 `;
   validateGeneratedTypeIdentifiers(content);
   const schemasContent = buildSchemasContent({ typesByPage });
-  return { content, docsData, schemasContent };
+  const fallbacks = collectFallbacks(typesByPage, syncTypesByPage);
+  const totalRoutes = [...typesByPage.values()].reduce((n, m) => n + m.size, 0) + [...syncTypesByPage.values()].reduce((n, m) => n + m.size, 0);
+  const diagnosticsData = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalRoutes,
+    fallbackCount: fallbacks.length,
+    fallbacks
+  };
+  return { content, docsData, schemasContent, diagnosticsData };
 };
 var buildSchemasContent = ({
   typesByPage
@@ -954,7 +1026,8 @@ export const getApiInputSchema = (
 var writeTypeMapArtifacts = ({
   content,
   docsData,
-  schemasContent
+  schemasContent,
+  diagnosticsData
 }) => {
   try {
     const outputPath = getGeneratedSocketTypesPath();
@@ -978,6 +1051,17 @@ var writeTypeMapArtifacts = ({
     if (hasUpdatedDocs) {
       console.log("[TypeMapGenerator] Generated apiDocs.generated.json");
     }
+    if (diagnosticsData !== void 0) {
+      const diagnosticsPath = path3.join(path3.dirname(docsPath), "apiTypeDiagnostics.generated.json");
+      const diagnosticsContent = JSON.stringify(diagnosticsData, null, 2);
+      const hasUpdatedDiagnostics = writeFileIfChanged(diagnosticsPath, diagnosticsContent);
+      if (hasUpdatedDiagnostics) {
+        console.log("[TypeMapGenerator] Generated apiTypeDiagnostics.generated.json");
+      }
+      if (diagnosticsData.fallbackCount > 0) {
+        console.warn(`[TypeMapGenerator] ${diagnosticsData.fallbackCount} route(s) have degraded type extraction (see apiTypeDiagnostics.generated.json)`);
+      }
+    }
   } catch (error) {
     console.error("[TypeMapGenerator] Error writing type map or docs:", error);
   }
@@ -990,13 +1074,13 @@ import path5 from "path";
 // src/typeMap/tsProgram.ts
 import * as ts4 from "typescript";
 import path4 from "path";
-import { ROOT_DIR as ROOT_DIR2 } from "@luckystack/core";
+import { ROOT_DIR as ROOT_DIR2, getGeneratedSocketTypesPath as getGeneratedSocketTypesPath2 } from "@luckystack/core";
 var cachedProgram = null;
 var getServerProgram = () => {
   if (cachedProgram) return cachedProgram;
-  const tsconfigPath = ts4.findConfigFile(ROOT_DIR2, ts4.sys.fileExists, "tsconfig.server.json");
+  const tsconfigPath = ts4.findConfigFile(ROOT_DIR2, ts4.sys.fileExists.bind(ts4.sys), "tsconfig.server.json");
   if (!tsconfigPath) throw new Error("[TypeProgram] tsconfig.server.json not found");
-  const { config } = ts4.readConfigFile(tsconfigPath, ts4.sys.readFile);
+  const { config } = ts4.readConfigFile(tsconfigPath, ts4.sys.readFile.bind(ts4.sys));
   const { options, fileNames } = ts4.parseJsonConfigFileContent(
     config,
     ts4.sys,
@@ -1032,8 +1116,8 @@ var SKIP_EXPANSION = /* @__PURE__ */ new Set([
   "ReadonlyArray"
 ]);
 var isJsonLikeType = (type, checker) => {
-  const symbolName = type.symbol?.name || "";
-  const aliasName = type.aliasSymbol?.name || "";
+  const symbolName = type.symbol?.name ?? "";
+  const aliasName = type.aliasSymbol?.name ?? "";
   if (JSON_TYPE_NAMES.has(symbolName) || JSON_TYPE_NAMES.has(aliasName)) return true;
   const rendered = checker.typeToString(type);
   return /(\bPrisma\.)?(Input)?Json(Value|Object|Array)\b/.test(rendered);
@@ -1084,7 +1168,7 @@ var getLiteralTypeFromPropertySymbol = (symbol, checker, depth) => {
   return null;
 };
 var normalizeImportPath = (targetFilePath) => {
-  const fromDir = path4.join(ROOT_DIR2, "src", "_sockets");
+  const fromDir = path4.dirname(getGeneratedSocketTypesPath2());
   const from = fromDir.replaceAll("\\", "/");
   const to = targetFilePath.replaceAll("\\", "/");
   const normalized = path4.posix.relative(from, to).replaceAll("\\", "/");
@@ -1177,7 +1261,7 @@ var expandTypeDetailed = (type, checker, depth = 0, state) => {
       }
       if (objectType.objectFlags & ts4.ObjectFlags.Reference) {
         const refType = objectType;
-        const targetName = refType.target?.symbol?.name ?? "";
+        const targetName = refType.target.symbol.name;
         if (targetName === "Array" || targetName === "ReadonlyArray") {
           const typeArgs = checker.getTypeArguments(refType);
           const firstArg = typeArgs[0];
@@ -1194,7 +1278,7 @@ var expandTypeDetailed = (type, checker, depth = 0, state) => {
           return { text: checker.typeToString(type), unresolvedSymbols: [] };
         }
       }
-      const symbolName = type.symbol?.name || type.aliasSymbol?.name || "";
+      const symbolName = type.symbol.name || (type.aliasSymbol?.name ?? "");
       if (SKIP_EXPANSION.has(symbolName)) {
         return { text: checker.typeToString(type), unresolvedSymbols: [] };
       }
@@ -1249,7 +1333,7 @@ var expandType = (type, checker, depth = 0) => {
 };
 
 // src/typeMap/extractors.ts
-import { ROOT_DIR as ROOT_DIR3 } from "@luckystack/core";
+import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath3 } from "@luckystack/core";
 var TYPE_NAME_PATTERN = /\b[A-Z][A-Za-z0-9_]*\b/g;
 var KNOWN_GLOBAL_TYPE_NAMES = /* @__PURE__ */ new Set([
   "String",
@@ -1283,7 +1367,7 @@ var KNOWN_GLOBAL_TYPE_NAMES = /* @__PURE__ */ new Set([
   "JsonPrimitive"
 ]);
 var normalizeImportPath2 = (targetFilePath) => {
-  const fromDir = path5.join(ROOT_DIR3, "src", "_sockets");
+  const fromDir = path5.dirname(getGeneratedSocketTypesPath3());
   const from = fromDir.replaceAll("\\", "/");
   const to = targetFilePath.replaceAll("\\", "/");
   const normalized = path5.posix.relative(from, to).replaceAll("\\", "/");
@@ -1338,7 +1422,7 @@ var findInterface = (sourceFile, name) => {
 };
 var getInterfacePropertyType = (iface, propertyName, checker) => {
   for (const member of iface.members) {
-    if (ts5.isPropertySignature(member) && member.name && ts5.isIdentifier(member.name) && member.name.text === propertyName && member.type) {
+    if (ts5.isPropertySignature(member) && ts5.isIdentifier(member.name) && member.name.text === propertyName && member.type) {
       return checker.getTypeFromTypeNode(member.type);
     }
   }
@@ -1422,7 +1506,10 @@ var getInputTypeDetailsFromFile = (filePath) => {
   try {
     const program = getServerProgram();
     const sourceFile = program.getSourceFile(filePath);
-    if (!sourceFile) return { text: DEFAULT, unresolvedSymbols: [] };
+    if (!sourceFile) {
+      console.warn(`[TypeMapGenerator] getSourceFile miss for ${filePath} \u2014 input types will default to { }`);
+      return { text: DEFAULT, unresolvedSymbols: [] };
+    }
     const checker = program.getTypeChecker();
     const iface = findInterface(sourceFile, "ApiParams");
     if (!iface) return { text: DEFAULT, unresolvedSymbols: [] };
@@ -1561,10 +1648,10 @@ import path7 from "path";
 // src/typeMap/typeContext.ts
 import * as ts6 from "typescript";
 import path6 from "path";
-import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath2 } from "@luckystack/core";
+import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath4 } from "@luckystack/core";
 var toGeneratedImportPath = (source, filePath) => {
   if (!source.startsWith(".")) return source;
-  const outputDir = path6.dirname(getGeneratedSocketTypesPath2());
+  const outputDir = path6.dirname(getGeneratedSocketTypesPath4());
   const absoluteSource = path6.resolve(path6.dirname(filePath), source);
   let relPath = path6.relative(outputDir, absoluteSource).replaceAll("\\", "/");
   relPath = relPath.replace(/\.tsx?$/, "");
@@ -1651,7 +1738,7 @@ var sanitizeTypeAndCollectImports = ({
 };
 
 // src/typeMap/functionsMeta.ts
-import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath3, getServerFunctionDirs } from "@luckystack/core";
+import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath5, getServerFunctionDirs } from "@luckystack/core";
 var stripDefaultValues = (params) => {
   return params.replaceAll(/\s*=(?!>)[^,)]+/g, "");
 };
@@ -1679,7 +1766,7 @@ var simplifyInferredType = (value) => {
   if (/\bRedis\b/.test(value)) return "Redis";
   return value;
 };
-var getGeneratedFileDir = () => path7.dirname(getGeneratedSocketTypesPath3());
+var getGeneratedFileDir = () => path7.dirname(getGeneratedSocketTypesPath5());
 var relativizeModuleSpecifier = (specifier, sourceFilePath) => {
   if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
     return specifier;
@@ -2041,16 +2128,16 @@ var generateServerFunctions = (collectors) => {
 };
 
 // src/typeMapGenerator.ts
-import { getSrcDir } from "@luckystack/core";
+import { getSrcDir as getSrcDir2 } from "@luckystack/core";
 
 // src/routeNamingValidation.ts
 import fs5 from "fs";
 import path8 from "path";
-import { ROOT_DIR as ROOT_DIR4, validatePagePath } from "@luckystack/core";
+import { ROOT_DIR as ROOT_DIR3, validatePagePath } from "@luckystack/core";
 var normalizePath = (value) => {
   return value.replaceAll("\\", "/");
 };
-var toRel = (absolute) => path8.relative(ROOT_DIR4, absolute).replaceAll("\\", "/");
+var toRel = (absolute) => path8.relative(ROOT_DIR3, absolute).replaceAll("\\", "/");
 var walkRouteFiles = (dir, results = []) => {
   const entries = fs5.readdirSync(dir, { withFileTypes: true });
   const apiSeg = apiMarkerSegment();
@@ -2308,7 +2395,7 @@ var collectDuplicatePageRoutes = (srcDir) => {
     const result = validatePagePath(relative);
     if (!result.valid || !result.route) continue;
     const list = routeToFiles.get(result.route) ?? [];
-    list.push(normalizePath(path8.relative(ROOT_DIR4, absoluteFilePath)));
+    list.push(normalizePath(path8.relative(ROOT_DIR3, absoluteFilePath)));
     routeToFiles.set(result.route, list);
   }
   const issues = [];
@@ -2347,26 +2434,9 @@ var assertNoDuplicatePageRoutes = ({
 // src/typeMapGenerator.ts
 var namedImports = /* @__PURE__ */ new Map();
 var defaultImports = /* @__PURE__ */ new Map();
-var generateTypeMapFile = (options = {}) => {
-  const { quiet = false } = options;
-  assertValidRouteNaming({
-    srcDir: getSrcDir(),
-    context: "generating API/sync type maps"
-  });
-  assertNoDuplicateNormalizedRouteKeys({
-    srcDir: getSrcDir(),
-    context: "generating API/sync type maps"
-  });
-  assertNoDuplicatePageRoutes({
-    srcDir: getSrcDir(),
-    context: "generating API/sync type maps"
-  });
-  invalidateProgramCache();
-  namedImports.clear();
-  defaultImports.clear();
-  const apiFiles = findAllApiFiles(getSrcDir());
+var collectApiTypes = (apiFiles, collectors) => {
+  const { namedImports: namedImports2, unresolvedTypeAliases, quiet } = collectors;
   const typesByPage = /* @__PURE__ */ new Map();
-  const unresolvedTypeAliases = /* @__PURE__ */ new Set();
   if (!quiet) {
     console.log(" \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
     console.log(" \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
@@ -2393,15 +2463,17 @@ var generateTypeMapFile = (options = {}) => {
         console.error(`[TypeMapGenerator] Unresolved API type (${pagePath}/${apiName}/${apiVersion}): ${symbol.name}`);
         continue;
       }
-      getOrInit(namedImports, symbol.importPath, () => /* @__PURE__ */ new Set()).add(symbol.name);
+      getOrInit(namedImports2, symbol.importPath, () => /* @__PURE__ */ new Set()).add(symbol.name);
     }
     if (!quiet) {
       console.log(`[TypeMapGenerator] API: ${pagePath}/${apiName}/${apiVersion} (${httpMethod}${rateLimit === void 0 ? "" : `, rateLimit: ${rateLimit}`})`);
     }
     getOrInit(typesByPage, pagePath, () => /* @__PURE__ */ new Map()).set(`${apiName}@${apiVersion}`, { input: inputType, output: outputType, stream: streamType, method: httpMethod, rateLimit, auth, version: apiVersion, ...meta ? { meta } : {} });
   }
-  const syncServerFiles = findAllSyncServerFiles(getSrcDir());
-  const syncClientFiles = findAllSyncClientFiles(getSrcDir());
+  return typesByPage;
+};
+var collectSyncTypes = (syncServerFiles, syncClientFiles, collectors) => {
+  const { namedImports: namedImports2, unresolvedTypeAliases, quiet } = collectors;
   const syncTypesByPage = /* @__PURE__ */ new Map();
   if (!quiet) {
     console.log(" \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
@@ -2454,7 +2526,7 @@ var generateTypeMapFile = (options = {}) => {
         console.error(`[TypeMapGenerator] Unresolved Sync type (${pagePath}/${syncName}/${syncVersion}): ${symbol.name}`);
         continue;
       }
-      getOrInit(namedImports, symbol.importPath, () => /* @__PURE__ */ new Set()).add(symbol.name);
+      getOrInit(namedImports2, symbol.importPath, () => /* @__PURE__ */ new Set()).add(symbol.name);
     }
     if (!quiet) {
       console.log(`[TypeMapGenerator] Sync: ${pagePath}/${syncName}/${syncVersion} (server: ${!!serverFile}, client: ${!!clientFile})`);
@@ -2470,19 +2542,45 @@ var generateTypeMapFile = (options = {}) => {
       ...syncMeta ? { meta: syncMeta } : {}
     });
   }
+  return syncTypesByPage;
+};
+var generateTypeMapFile = (options = {}) => {
+  const { quiet = false } = options;
+  assertValidRouteNaming({
+    srcDir: getSrcDir2(),
+    context: "generating API/sync type maps"
+  });
+  assertNoDuplicateNormalizedRouteKeys({
+    srcDir: getSrcDir2(),
+    context: "generating API/sync type maps"
+  });
+  assertNoDuplicatePageRoutes({
+    srcDir: getSrcDir2(),
+    context: "generating API/sync type maps"
+  });
+  invalidateProgramCache();
+  namedImports.clear();
+  defaultImports.clear();
+  const unresolvedTypeAliases = /* @__PURE__ */ new Set();
+  const collectors = { namedImports, unresolvedTypeAliases, quiet };
+  const apiFiles = findAllApiFiles(getSrcDir2());
+  const typesByPage = collectApiTypes(apiFiles, collectors);
+  const syncServerFiles = findAllSyncServerFiles(getSrcDir2());
+  const syncClientFiles = findAllSyncClientFiles(getSrcDir2());
+  const syncTypesByPage = collectSyncTypes(syncServerFiles, syncClientFiles, collectors);
   const functionsInterface = generateServerFunctions({ namedImports, defaultImports });
   if (unresolvedTypeAliases.size > 0) {
     const unresolvedList = [...unresolvedTypeAliases].toSorted().join(", ");
     throw new Error(`[TypeMapGenerator] Aborting generation because unresolved type symbols were found: ${unresolvedList}`);
   }
-  const { content, docsData, schemasContent } = buildTypeMapArtifacts({
+  const { content, docsData, schemasContent, diagnosticsData } = buildTypeMapArtifacts({
     typesByPage,
     syncTypesByPage,
     namedImports,
     defaultImports,
     functionsInterface
   });
-  writeTypeMapArtifacts({ content, docsData, schemasContent });
+  writeTypeMapArtifacts({ content, docsData, schemasContent, diagnosticsData });
 };
 
 // src/templateRegistry.ts
@@ -2560,7 +2658,7 @@ registerDefaultTemplateRules();
 import fs6 from "fs";
 import path9 from "path";
 import { pathToFileURL } from "url";
-import { tryCatch, getServerFunctionDirs as getServerFunctionDirs2, getSrcDir as getSrcDir2 } from "@luckystack/core";
+import { tryCatch, getServerFunctionDirs as getServerFunctionDirs2, getSrcDir as getSrcDir3 } from "@luckystack/core";
 
 // src/runtimeTypeResolver.ts
 import * as ts8 from "typescript";
@@ -2610,8 +2708,19 @@ var splitTopLevel = (value, splitter) => {
   let depthBrace = 0;
   let depthBracket = 0;
   let depthAngle = 0;
+  let quote = null;
   let token = "";
   for (const char of value) {
+    if (quote !== null) {
+      if (char === quote) quote = null;
+      token += char;
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      token += char;
+      continue;
+    }
     if (char === "(") depthParen += 1;
     if (char === ")") depthParen -= 1;
     if (char === "{") depthBrace += 1;
@@ -2619,7 +2728,7 @@ var splitTopLevel = (value, splitter) => {
     if (char === "[") depthBracket += 1;
     if (char === "]") depthBracket -= 1;
     if (char === "<") depthAngle += 1;
-    if (char === ">") depthAngle -= 1;
+    if (char === ">") depthAngle = Math.max(0, depthAngle - 1);
     if (char === splitter && depthParen === 0 && depthBrace === 0 && depthBracket === 0 && depthAngle === 0) {
       if (token.trim()) items.push(token.trim());
       token = "";
@@ -2929,17 +3038,20 @@ var devSyncs = {};
 var devFunctions = {};
 var normalizePath2 = (value) => value.replaceAll("\\", "/");
 var mapApiPageLocation = (pageLocation) => {
-  return pageLocation ? pageLocation : "system";
+  return pageLocation || "system";
+};
+var mapSyncPageLocation = (pageLocation) => {
+  return pageLocation || "system";
 };
 var resolveApiRouteMetaFromPath = (filePath) => {
   const absolutePath = path9.resolve(filePath);
   const normalizedAbsolutePath = normalizePath2(absolutePath);
-  const normalizedSrcDir = normalizePath2(getSrcDir2());
+  const normalizedSrcDir = normalizePath2(getSrcDir3());
   if (!normalizedAbsolutePath.startsWith(normalizedSrcDir) || !normalizedAbsolutePath.endsWith(".ts")) {
     return null;
   }
   const rules2 = getRoutingRules();
-  const relativePath = normalizePath2(path9.relative(getSrcDir2(), absolutePath));
+  const relativePath = normalizePath2(path9.relative(getSrcDir3(), absolutePath));
   const segments = relativePath.split("/");
   const apiIndex = segments.indexOf(rules2.apiMarker);
   if (apiIndex === -1 || apiIndex === segments.length - 1) {
@@ -2961,12 +3073,12 @@ var resolveApiRouteMetaFromPath = (filePath) => {
 var resolveSyncRouteMetaFromPath = (filePath) => {
   const absolutePath = path9.resolve(filePath);
   const normalizedAbsolutePath = normalizePath2(absolutePath);
-  const normalizedSrcDir = normalizePath2(getSrcDir2());
+  const normalizedSrcDir = normalizePath2(getSrcDir3());
   if (!normalizedAbsolutePath.startsWith(normalizedSrcDir) || !normalizedAbsolutePath.endsWith(".ts")) {
     return null;
   }
   const rules2 = getRoutingRules();
-  const relativePath = normalizePath2(path9.relative(getSrcDir2(), absolutePath));
+  const relativePath = normalizePath2(path9.relative(getSrcDir3(), absolutePath));
   const segments = relativePath.split("/");
   const syncIndex = segments.indexOf(rules2.syncMarker);
   if (syncIndex === -1 || syncIndex === segments.length - 1) {
@@ -2982,7 +3094,8 @@ var resolveSyncRouteMetaFromPath = (filePath) => {
   const kind = match[1];
   const version = `v${match[2]}`;
   const syncName = rawSyncName.replace(rules2.syncVersionRegex, "");
-  const routeBaseKey = pageLocation ? `sync/${pageLocation}/${syncName}/${version}` : `sync/${syncName}/${version}`;
+  const mappedPageLocation = mapSyncPageLocation(pageLocation);
+  const routeBaseKey = `sync/${mappedPageLocation}/${syncName}/${version}`;
   return {
     routeKey: `${routeBaseKey}_${kind}`,
     kind,
@@ -2991,10 +3104,10 @@ var resolveSyncRouteMetaFromPath = (filePath) => {
 };
 var initializeAll = async () => {
   assertValidRouteNaming({
-    srcDir: getSrcDir2(),
+    srcDir: getSrcDir3(),
     context: "starting dev server (npm run server)"
   });
-  const pageRouteIssues = collectDuplicatePageRoutes(getSrcDir2());
+  const pageRouteIssues = collectDuplicatePageRoutes(getSrcDir3());
   if (pageRouteIssues.length > 0) {
     console.warn(formatDuplicatePageRouteIssues({
       issues: pageRouteIssues,
@@ -3011,6 +3124,7 @@ var collectTsFiles = (dir, relativeTo = "") => {
   const results = [];
   const entries = fs6.readdirSync(dir);
   for (const entry of entries) {
+    if (entry === "node_modules") continue;
     const entryPath = path9.join(dir, entry);
     const relPath = relativeTo ? `${relativeTo}/${entry}` : entry;
     if (fs6.statSync(entryPath).isDirectory()) {
@@ -3044,7 +3158,7 @@ var resolveFunctionModule = (loadedModule, fileName) => {
 var initializeApis = async () => {
   for (const key of Object.keys(devApis)) delete devApis[key];
   clearRuntimeTypeResolverCache();
-  const srcFolder = fs6.readdirSync(getSrcDir2());
+  const srcFolder = fs6.readdirSync(getSrcDir3());
   for (const file of srcFolder) {
     await scanApiFolder(file);
   }
@@ -3100,7 +3214,7 @@ var removeApiFromFile = (filePath) => {
   delete devApis[routeMeta.routeKey];
 };
 var scanApiFolder = async (file, basePath = "") => {
-  const fullPath = path9.join(getSrcDir2(), basePath, file);
+  const fullPath = path9.join(getSrcDir3(), basePath, file);
   if (!fs6.statSync(fullPath).isDirectory()) return;
   if (!file.toLowerCase().endsWith("api")) {
     const subFolders = fs6.readdirSync(fullPath);
@@ -3155,7 +3269,7 @@ var scanApiFolder = async (file, basePath = "") => {
 var initializeSyncs = async () => {
   for (const key of Object.keys(devSyncs)) delete devSyncs[key];
   clearRuntimeTypeResolverCache();
-  const srcFolder = fs6.readdirSync(getSrcDir2());
+  const srcFolder = fs6.readdirSync(getSrcDir3());
   for (const file of srcFolder) {
     await scanSyncFolder(file);
   }
@@ -3190,7 +3304,13 @@ var upsertSyncFromFile = async (filePath) => {
       main: resolvedSyncModule.main,
       auth: resolvedSyncModule.auth || {},
       inputType,
-      inputTypeFilePath: routeMeta.absolutePath
+      inputTypeFilePath: routeMeta.absolutePath,
+      //? Forward the per-route `validation` toggle + `errorFormatter` so the dev
+      //? loader's sync entry shape matches the prod generator's. Dropping them
+      //? made `validation: { input: 'skip' }` / a per-route errorFormatter work
+      //? in prod but silently no-op in dev (QUA-013 / QUA-044).
+      validation: resolvedSyncModule.validation,
+      errorFormatter: resolvedSyncModule.errorFormatter
     };
     return;
   }
@@ -3210,7 +3330,7 @@ var removeSyncFromFile = (filePath) => {
   delete devSyncs[routeMeta.routeKey];
 };
 var scanSyncFolder = async (file, basePath = "") => {
-  const fullPath = path9.join(getSrcDir2(), basePath, file);
+  const fullPath = path9.join(getSrcDir3(), basePath, file);
   if (!fs6.statSync(fullPath).isDirectory()) return;
   if (!file.toLowerCase().endsWith("sync")) {
     const subFolders = fs6.readdirSync(fullPath);
@@ -3235,7 +3355,8 @@ var scanSyncFolder = async (file, basePath = "") => {
     const kind = syncMatch[1];
     const version = `v${syncMatch[2]}`;
     const syncName = rawSyncFileName.replace(syncRules.syncVersionRegex, "");
-    const routeBaseKey = pageLocation ? `sync/${pageLocation}/${syncName}/${version}` : `sync/${syncName}/${version}`;
+    const mappedPageLocation = mapSyncPageLocation(pageLocation);
+    const routeBaseKey = `sync/${mappedPageLocation}/${syncName}/${version}`;
     const filePath = path9.resolve(path9.join(fullPath, relFile));
     const [fileError, fileResult] = await tryCatch(async () => importFile(filePath));
     if (fileError) {
@@ -3249,7 +3370,11 @@ var scanSyncFolder = async (file, basePath = "") => {
         main: resolvedSyncModule.main,
         auth: resolvedSyncModule.auth || {},
         inputType,
-        inputTypeFilePath: filePath
+        inputTypeFilePath: filePath,
+        //? Forward `validation` + `errorFormatter` so the dev loader matches the
+        //? prod generator's sync entry shape (QUA-013 / QUA-044).
+        validation: resolvedSyncModule.validation,
+        errorFormatter: resolvedSyncModule.errorFormatter
       };
     } else {
       devSyncs[`${routeBaseKey}_client`] = resolvedSyncModule.main;
@@ -3315,18 +3440,19 @@ var scanFunctionsFolder = async (dir, rootDir, basePath = []) => {
 
 // src/hotReload.ts
 import { watch } from "chokidar";
-import fs9 from "fs";
-import path12 from "path";
+import fs10 from "fs";
+import path13 from "path";
 
 // src/templateInjector.ts
 import fs7 from "fs";
 import path10 from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "url";
-import { ROOT_DIR as ROOT_DIR5, getGeneratedSocketTypesPath as getGeneratedSocketTypesPath4, getSrcDir as getSrcDir3, validatePagePath as validatePagePath2 } from "@luckystack/core";
+import * as ts9 from "typescript";
+import { ROOT_DIR as ROOT_DIR4, getGeneratedSocketTypesPath as getGeneratedSocketTypesPath6, getSrcDir as getSrcDir4, validatePagePath as validatePagePath2 } from "@luckystack/core";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path10.dirname(__filename);
 var templatesDir = path10.join(__dirname, "templates");
-var getConsumerTemplatesDir = () => path10.join(ROOT_DIR5, ".luckystack", "templates");
+var getConsumerTemplatesDir = () => path10.join(ROOT_DIR4, ".luckystack", "templates");
 var templateContentFilenames = (kind) => {
   const builtIn = BUILT_IN_TEMPLATE_FILENAMES[kind];
   if (builtIn) return [builtIn];
@@ -3420,7 +3546,7 @@ var isVersionedSyncFile = (filePath) => {
   return isVersionedSyncFileName(filePath);
 };
 var getFileName = (filePath) => {
-  return path10.basename(filePath.replace(/\\/g, "/"));
+  return path10.basename(filePath.replaceAll("\\", "/"));
 };
 var stripTsExtension = (fileName) => {
   return fileName.replace(/\.ts$/, "");
@@ -3464,7 +3590,7 @@ var getSyncFilenameReason = (fileName) => {
   return "Missing required sync kind and version suffix.";
 };
 var getRouteFilenameValidationMessage = (filePath) => {
-  const normalized = filePath.replace(/\\/g, "/");
+  const normalized = filePath.replaceAll("\\", "/");
   const fileName = getFileName(normalized);
   if (isInApiFolder(normalized) && !isVersionedApiFile(normalized)) {
     const base = toApiBaseName(fileName);
@@ -3489,13 +3615,13 @@ var getRouteFilenameValidationMessage = (filePath) => {
   return null;
 };
 var getInvalidVersionMessage = (filePath) => {
-  const validationMessage = getRouteFilenameValidationMessage(filePath) || "Invalid route filename.";
+  const validationMessage = getRouteFilenameValidationMessage(filePath) ?? "Invalid route filename.";
   return `// ${validationMessage}
 `;
 };
 var computeSrcRelativePath = (filePath) => {
   try {
-    const srcDir = getSrcDir3();
+    const srcDir = getSrcDir4();
     const absolute = path10.resolve(filePath);
     const normalizedSrc = srcDir.replaceAll("\\", "/");
     const normalizedAbs = absolute.replaceAll("\\", "/");
@@ -3549,7 +3675,9 @@ var hasPairedFile = (filePath) => {
 var extractSyncPagePath2 = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
   const match = /src\/(.+?)\/_sync\//.exec(normalized);
-  return match?.[1] ?? "";
+  if (match?.[1]) return match[1];
+  if (/(?:^|\/)src\/_sync\//.test(normalized)) return "system";
+  return "";
 };
 var extractSyncName2 = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
@@ -3565,11 +3693,16 @@ var extractClientInputFromFile = (filePath) => {
     const content = fs7.readFileSync(filePath, "utf8");
     const syncParamsMatch = /interface\s+SyncParams\s*\{/.exec(content);
     if (!syncParamsMatch) return null;
-    const clientInputMatch = /clientInput\s*:\s*\{/.exec(content);
+    const searchRegion = content.slice(syncParamsMatch.index + syncParamsMatch[0].length);
+    const clientInputMatch = /clientInput\s*:\s*\{/.exec(searchRegion);
     if (!clientInputMatch) return null;
-    const startIndex = content.indexOf("{", clientInputMatch.index);
+    const startIndex = content.indexOf(
+      "{",
+      syncParamsMatch.index + syncParamsMatch[0].length + clientInputMatch.index
+    );
+    if (startIndex === -1) return null;
     let depth = 0;
-    let endIndex = startIndex;
+    let endIndex = -1;
     for (let i = startIndex; i < content.length; i++) {
       if (content[i] === "{") depth++;
       else if (content[i] === "}") depth--;
@@ -3578,7 +3711,8 @@ var extractClientInputFromFile = (filePath) => {
         break;
       }
     }
-    return content.substring(startIndex, endIndex + 1);
+    if (endIndex === -1) return null;
+    return content.slice(startIndex, endIndex + 1);
   } catch (error) {
     console.error(`[TemplateInjector] Error extracting clientInput from ${filePath}:`, error);
     return null;
@@ -3586,7 +3720,7 @@ var extractClientInputFromFile = (filePath) => {
 };
 var extractClientInputFromGeneratedTypes = (pagePath, syncName) => {
   try {
-    const generatedTypesPath = getGeneratedSocketTypesPath4();
+    const generatedTypesPath = getGeneratedSocketTypesPath6();
     const content = fs7.readFileSync(generatedTypesPath, "utf8");
     const escapeRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
     const escapedPagePath = escapeRegex(pagePath);
@@ -3610,7 +3744,7 @@ var extractClientInputFromGeneratedTypes = (pagePath, syncName) => {
     const braceStart = content.indexOf("{", searchStart - 1);
     if (braceStart === -1) return null;
     let depth = 0;
-    let endIndex = braceStart;
+    let endIndex = -1;
     for (let i = braceStart; i < content.length; i++) {
       if (content[i] === "{") depth++;
       else if (content[i] === "}") depth--;
@@ -3619,7 +3753,8 @@ var extractClientInputFromGeneratedTypes = (pagePath, syncName) => {
         break;
       }
     }
-    const extracted = content.substring(braceStart, endIndex + 1);
+    if (endIndex === -1) return null;
+    const extracted = content.slice(braceStart, endIndex + 1);
     console.log(`[TemplateInjector] Extracted clientInput types: ${extracted}`);
     return extracted;
   } catch (error) {
@@ -3629,6 +3764,18 @@ var extractClientInputFromGeneratedTypes = (pagePath, syncName) => {
 };
 var calculateRelativePath = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
+  const srcRelative = computeSrcRelativePath(filePath);
+  if (srcRelative !== null) {
+    try {
+      const srcDepthFromRoot = path10.relative(ROOT_DIR4, getSrcDir4()).replaceAll("\\", "/").split("/").filter((segment) => segment.length > 0).length;
+      const dirSegmentsAfterSrc = Math.max(
+        0,
+        srcRelative.split("/").filter((segment) => segment.length > 0).length - 1
+      );
+      return "../".repeat(srcDepthFromRoot + dirSegmentsAfterSrc);
+    } catch {
+    }
+  }
   const srcIndex = normalized.indexOf("src/");
   if (srcIndex === -1) {
     console.warn(`[TemplateInjector] Could not find /src/ in path: ${filePath}`);
@@ -3638,58 +3785,68 @@ var calculateRelativePath = (filePath) => {
   const segments = relativePath.split("/").filter((s) => s.length > 0).length;
   return "../".repeat(segments);
 };
-var getTemplate = (filePath) => {
-  let fileKind;
-  let hasPairedServer = false;
-  let srcRelativePath = null;
+var classifyFile = (filePath) => {
   if (isInApiFolder(filePath)) {
-    fileKind = "api";
-  } else if (isInSyncFolder(filePath)) {
+    return { fileKind: "api", hasPairedServer: false, srcRelativePath: null };
+  }
+  if (isInSyncFolder(filePath)) {
     if (isSyncServerFile(filePath)) {
-      fileKind = "sync_server";
-    } else if (isSyncClientFile(filePath)) {
-      fileKind = "sync_client";
-      hasPairedServer = hasPairedFile(filePath);
-    } else {
-      console.log(`[TemplateInjector] Unknown sync file type: ${filePath}`);
-      return null;
+      return { fileKind: "sync_server", hasPairedServer: false, srcRelativePath: null };
     }
-  } else if (isPageFile(filePath)) {
-    fileKind = "page";
-    srcRelativePath = computeSrcRelativePath(filePath);
-    if (srcRelativePath !== null) {
-      const placement = validatePagePath2(srcRelativePath);
-      if (!placement.valid) {
-        return getInvalidPagePlacementMessage(filePath, placement.reason ?? "invalid placement", srcRelativePath);
-      }
+    if (isSyncClientFile(filePath)) {
+      return { fileKind: "sync_client", hasPairedServer: hasPairedFile(filePath), srcRelativePath: null };
     }
-  } else {
+    console.log(`[TemplateInjector] Unknown sync file type: ${filePath}`);
     return null;
   }
-  const ctx = { filePath, fileKind, hasPairedServer, srcRelativePath };
-  const templateKind = resolveTemplateKind(ctx);
-  if (!templateKind) {
-    console.log(`[TemplateInjector] No template rule matched for ${filePath} (fileKind=${fileKind})`);
-    return null;
+  if (isPageFile(filePath)) {
+    return { fileKind: "page", hasPairedServer: false, srcRelativePath: computeSrcRelativePath(filePath) };
   }
-  let content = resolveTemplateContent(templateKind);
-  if (content === null) return null;
+  return null;
+};
+var checkPagePlacement = (filePath, srcRelativePath) => {
+  if (srcRelativePath === null) return null;
+  const placement = validatePagePath2(srcRelativePath);
+  if (!placement.valid) {
+    return getInvalidPagePlacementMessage(filePath, placement.reason ?? "invalid placement", srcRelativePath);
+  }
+  return null;
+};
+var applyTemplatePlaceholders = (content, filePath, fileKind) => {
   const relPath = calculateRelativePath(filePath);
   const pragmaPattern = /\/\/\s*@ts-(?:ignore|expect-error).*\r?\n(.*)\{\{REL_PATH\}\}/g;
-  content = content.replaceAll(pragmaPattern, (_, prefix) => `${prefix}${relPath}`);
-  content = content.replaceAll("{{REL_PATH}}", relPath);
+  let result = content.replaceAll(pragmaPattern, (_, prefix) => `${prefix}${relPath}`);
+  result = result.replaceAll("{{REL_PATH}}", relPath);
   if (fileKind === "sync_client" || fileKind === "sync_server") {
     const pagePath = extractSyncPagePath2(filePath);
     const syncName = extractSyncName2(filePath);
-    content = content.replaceAll("{{PAGE_PATH}}", pagePath);
-    content = content.replaceAll("{{SYNC_NAME}}", syncName);
+    result = result.replaceAll("{{PAGE_PATH}}", pagePath);
+    result = result.replaceAll("{{SYNC_NAME}}", syncName);
   }
-  return content;
+  return result;
+};
+var getTemplate = (filePath) => {
+  const classification = classifyFile(filePath);
+  if (!classification) return null;
+  const { fileKind, hasPairedServer, srcRelativePath } = classification;
+  if (fileKind === "page") {
+    const placementWarning = checkPagePlacement(filePath, srcRelativePath);
+    if (placementWarning !== null) return placementWarning;
+  }
+  const ctx = { filePath, fileKind, hasPairedServer, srcRelativePath };
+  const templateKind = resolveTemplateKind(ctx);
+  if (!templateKind) {
+    console.log(`[TemplateInjector] No template rule matched for ${filePath} (fileKind=${fileKind})`);
+    return null;
+  }
+  const rawContent = resolveTemplateContent(templateKind);
+  if (rawContent === null) return null;
+  return applyTemplatePlaceholders(rawContent, filePath, fileKind);
 };
 var injectTemplate = async (filePath) => {
   await ensureConsumerTemplateConfigLoaded();
   if (getRouteFilenameValidationMessage(filePath)) {
-    fs7.writeFileSync(filePath, getInvalidVersionMessage(filePath), "utf-8");
+    fs7.writeFileSync(filePath, getInvalidVersionMessage(filePath), "utf8");
     console.log(`[TemplateInjector] Invalid route filename, injected guidance: ${filePath}`);
     return true;
   }
@@ -3698,7 +3855,7 @@ var injectTemplate = async (filePath) => {
     return false;
   }
   try {
-    fs7.writeFileSync(filePath, template, "utf-8");
+    fs7.writeFileSync(filePath, template, "utf8");
     console.log(`[TemplateInjector] Injected template into: ${filePath}`);
     return true;
   } catch (error) {
@@ -3706,62 +3863,142 @@ var injectTemplate = async (filePath) => {
     return false;
   }
 };
-var shouldInjectTemplate = (filePath) => {
+var shouldInjectTemplate = (filePath, options = {}) => {
   const { disableTemplateInjection } = getRoutingRules();
-  if (disableTemplateInjection && disableTemplateInjection(filePath)) {
+  if (disableTemplateInjection?.(filePath)) {
     return false;
   }
   if (!(isInApiFolder(filePath) || isInSyncFolder(filePath) || isPageFile(filePath))) {
     return false;
   }
-  return isEmptyFile(filePath) || isCommentOnlyFile(filePath);
+  if (isEmptyFile(filePath)) return true;
+  if (options.isNewFile) return isCommentOnlyFile(filePath);
+  return false;
 };
-var updateClientFileForPairedServer = async (clientFilePath) => {
-  try {
-    const pagePath = extractSyncPagePath2(clientFilePath);
-    const syncName = extractSyncName2(clientFilePath);
-    let content = fs7.readFileSync(clientFilePath, "utf8");
-    if (!content.includes("SyncClientInput")) {
-      content = content.replace(
-        /import \{([^}]+)\} from ['"]([^'"]*apiTypes\.generated)['"]/,
-        (_match, imports, path13) => {
-          return `import {${imports}, SyncClientInput, SyncServerOutput } from '${path13}'`;
-        }
-      );
+var ensureImportedTypes = (content, clientFilePath) => {
+  if (content.includes("SyncClientInput")) return content;
+  let result = content.replace(
+    /import \{([^}]+)\} from ['"]([^'"]*apiTypes\.generated)['"]/,
+    (_match, imports, importPath) => {
+      return `import {${imports}, SyncClientInput, SyncServerOutput } from '${importPath}'`;
     }
-    if (!content.includes("type PagePath")) {
-      const importEndMatch = content.match(/import .+?;[\r\n]+/g);
-      if (importEndMatch) {
-        const lastImport = importEndMatch.at(-1);
-        if (!lastImport) {
-          return false;
-        }
-        const lastImportEnd = content.lastIndexOf(lastImport) + lastImport.length;
-        const typeAliases = `
+  );
+  if (!result.includes("SyncClientInput")) {
+    const relPath = calculateRelativePath(clientFilePath);
+    result = `import { SyncClientInput, SyncServerOutput } from '${relPath}src/_sockets/apiTypes.generated';
+` + result;
+  }
+  return result;
+};
+var insertTypeAliases = (content, pagePath, syncName) => {
+  if (content.includes("type PagePath")) return content;
+  const importEndMatch = content.match(/import .+?;[\r\n]+/g);
+  if (!importEndMatch) return content;
+  const lastImport = importEndMatch.at(-1);
+  if (!lastImport) return content;
+  const lastImportEnd = content.lastIndexOf(lastImport) + lastImport.length;
+  const typeAliases = `
 // Types are imported from the generated file based on the _server.ts definition
 type PagePath = '${pagePath}';
 type SyncName = '${syncName}';
 `;
-        content = content.slice(0, lastImportEnd) + typeAliases + content.slice(lastImportEnd);
-      }
+  return content.slice(0, lastImportEnd) + typeAliases + content.slice(lastImportEnd);
+};
+var rewriteClientInputType = (content) => {
+  return content.replace(
+    /^(\s*)clientInput:\s*\{[^}]*\}/m,
+    "$1clientInput: SyncClientInput<PagePath, SyncName>"
+  );
+};
+var rewriteClientInputTypeAst = (content, sourceFileName) => {
+  const parseSource = (src) => ts9.createSourceFile(
+    sourceFileName,
+    src,
+    ts9.ScriptTarget.Latest,
+    /* setParentNodes */
+    true,
+    ts9.ScriptKind.TS
+  );
+  const sourceFile = parseSource(content);
+  let syncParamsInterface;
+  for (const stmt of sourceFile.statements) {
+    if (ts9.isInterfaceDeclaration(stmt) && stmt.name.text === "SyncParams") {
+      syncParamsInterface = stmt;
+      break;
+    }
+  }
+  if (!syncParamsInterface) return null;
+  let clientInputMember;
+  for (const member of syncParamsInterface.members) {
+    if (ts9.isPropertySignature(member) && ts9.isIdentifier(member.name) && member.name.text === "clientInput") {
+      clientInputMember = member;
+      break;
+    }
+  }
+  if (!clientInputMember?.type) return null;
+  if (!ts9.isTypeLiteralNode(clientInputMember.type)) return null;
+  const typeNode = clientInputMember.type;
+  const start = typeNode.getStart(sourceFile);
+  const end = typeNode.getEnd();
+  const rewritten = `${content.slice(0, start)}SyncClientInput<PagePath, SyncName>${content.slice(end)}`;
+  const reparsedFile = parseSource(rewritten);
+  const verifyProgram = ts9.createProgram({
+    rootNames: [sourceFileName],
+    options: { noResolve: true, skipLibCheck: true },
+    // Supply the in-memory source so `ts.createProgram` never touches the disk.
+    host: {
+      ...ts9.createCompilerHost({}),
+      getSourceFile: (name) => name === sourceFileName ? reparsedFile : void 0,
+      fileExists: (name) => name === sourceFileName,
+      readFile: (name) => name === sourceFileName ? rewritten : void 0
     }
-    content = content.replace(
-      /^(\s*)clientInput:\s*\{[^}]*\}/m,
-      "$1clientInput: SyncClientInput<PagePath, SyncName>"
+  });
+  const syntaxErrors = verifyProgram.getSyntacticDiagnostics(reparsedFile);
+  if (syntaxErrors.length > 0) {
+    console.log(
+      `[TemplateInjector] AST rewrite produced invalid TypeScript for ${sourceFileName} \u2014 leaving untouched`,
+      "yellow"
     );
-    if (!content.includes("serverOutput:")) {
-      content = content.replace(
-        /^(\s*)(clientInput:\s*SyncClientInput<PagePath, SyncName>);?\s*$/m,
-        "$1$2;\n$1serverOutput: SyncServerOutput<PagePath, SyncName>;"
-      );
-    }
-    if (content.includes("main") && !/\{\s*[^}]*serverOutput[^}]*\}\s*:\s*SyncParams/.test(content)) {
-      content = content.replace(
-        /\{\s*([^}]*?clientInput)([^}]*)\}\s*:\s*SyncParams/,
-        "{ $1, serverOutput$2 }: SyncParams"
+    return null;
+  }
+  return rewritten;
+};
+var addServerOutputToParams = (content) => {
+  if (content.includes("serverOutput:")) return content;
+  return content.replace(
+    /^(\s*)(clientInput:\s*SyncClientInput<PagePath, SyncName>);?\s*$/m,
+    "$1$2;\n$1serverOutput: SyncServerOutput<PagePath, SyncName>;"
+  );
+};
+var addServerOutputToDestructuring = (content) => {
+  if (!content.includes("main") || /\{\s*[^}]*serverOutput[^}]*\}\s*:\s*SyncParams/.test(content)) {
+    return content;
+  }
+  return content.replace(
+    /\{\s*([^}]*?clientInput)([^}]*)\}\s*:\s*SyncParams/,
+    "{ $1, serverOutput$2 }: SyncParams"
+  );
+};
+var updateClientFileForPairedServer = async (clientFilePath) => {
+  try {
+    const pagePath = extractSyncPagePath2(clientFilePath);
+    const syncName = extractSyncName2(clientFilePath);
+    let content = fs7.readFileSync(clientFilePath, "utf8");
+    content = ensureImportedTypes(content, clientFilePath);
+    content = insertTypeAliases(content, pagePath, syncName);
+    const astResult = rewriteClientInputTypeAst(content, path10.basename(clientFilePath));
+    if (astResult === null) {
+      console.log(
+        `[TemplateInjector] AST clientInput rewrite unavailable for ${clientFilePath} \u2014 using regex fallback`,
+        "yellow"
       );
+      content = rewriteClientInputType(content);
+    } else {
+      content = astResult;
     }
-    fs7.writeFileSync(clientFilePath, content, "utf-8");
+    content = addServerOutputToParams(content);
+    content = addServerOutputToDestructuring(content);
+    fs7.writeFileSync(clientFilePath, content, "utf8");
     console.log(`[TemplateInjector] Updated client file to use paired types (preserved code): ${clientFilePath}`);
     return true;
   } catch (error) {
@@ -3769,34 +4006,39 @@ type SyncName = '${syncName}';
     return false;
   }
 };
+var inlineClientInputType = (content, clientInputTypes) => {
+  return content.replace(
+    /^(\s*)clientInput:\s*SyncClientInput<[^>]+>/m,
+    (_match, indent) => `${indent}clientInput: ${clientInputTypes}`
+  ).replace(
+    /^(\s*)clientInput:\s*\{[^}]*\}/m,
+    (_match, indent) => `${indent}clientInput: ${clientInputTypes}`
+  );
+};
+var removeServerOutputFromParams = (content) => {
+  return content.replace(/^[ \t]*serverOutput:\s*SyncServerOutput<[^>]+>;?\s*\r?\n?/m, "").replace(/^[ \t]*serverOutput:\s*\{[^}]*\};?\s*\r?\n?/m, "");
+};
+var removeServerOutputFromDestructuring = (content) => {
+  return content.replaceAll(/,\s*serverOutput(?=\s*[,}])/g, "").replaceAll(/serverOutput\s*,\s*/g, "");
+};
+var removeGeneratedTypeImports = (content) => {
+  return content.replaceAll(/,\s*SyncClientInput(?=\s*[,}])/g, "").replaceAll(/,\s*SyncServerOutput(?=\s*[,}])/g, "");
+};
+var removeTypeAliases = (content) => {
+  let result = content.replaceAll(/\/\/\s*Types are imported.*\n?/g, "");
+  result = result.replaceAll(/type PagePath = '[^']*';\s*\n?/g, "");
+  return result.replaceAll(/type SyncName = '[^']*';\s*\n?/g, "");
+};
 var updateClientFileForDeletedServer = async (clientFilePath, clientInputTypes) => {
   try {
     let content = fs7.readFileSync(clientFilePath, "utf8");
-    content = content.replace(
-      /^(\s*)clientInput:\s*SyncClientInput<[^>]+>/m,
-      `$1clientInput: ${clientInputTypes}`
-    );
-    content = content.replace(
-      /^(\s*)clientInput:\s*\{[^}]*\}/m,
-      `$1clientInput: ${clientInputTypes}`
-    );
-    content = content.replace(
-      /^[ \t]*serverOutput:\s*SyncServerOutput<[^>]+>;?\s*\r?\n?/m,
-      ""
-    );
-    content = content.replace(
-      /^[ \t]*serverOutput:\s*\{[^}]*\};?\s*\r?\n?/m,
-      ""
-    );
-    content = content.replaceAll(/,\s*serverOutput(?=\s*[,}])/g, "");
-    content = content.replaceAll(/serverOutput\s*,\s*/g, "");
-    content = content.replaceAll(/,\s*SyncClientInput(?=\s*[,}])/g, "");
-    content = content.replaceAll(/,\s*SyncServerOutput(?=\s*[,}])/g, "");
-    content = content.replaceAll(/\/\/\s*Types are imported.*\n?/g, "");
-    content = content.replaceAll(/type PagePath = '[^']*';\s*\n?/g, "");
-    content = content.replaceAll(/type SyncName = '[^']*';\s*\n?/g, "");
+    content = inlineClientInputType(content, clientInputTypes);
+    content = removeServerOutputFromParams(content);
+    content = removeServerOutputFromDestructuring(content);
+    content = removeGeneratedTypeImports(content);
+    content = removeTypeAliases(content);
     content = content.replaceAll(/\n{3,}/g, "\n\n");
-    fs7.writeFileSync(clientFilePath, content, "utf-8");
+    fs7.writeFileSync(clientFilePath, content, "utf8");
     console.log(`[TemplateInjector] Updated client file for deleted server (preserved code): ${clientFilePath}`);
     return true;
   } catch (error) {
@@ -3820,9 +4062,9 @@ var injectServerTemplateWithClientInput = async (serverFilePath, clientInputType
     content = content.replaceAll("{{REL_PATH}}", relPath);
     content = content.replace(
       /clientInput:\s*\{[^}]*\}/s,
-      `clientInput: ${clientInputTypes}`
+      (_match) => `clientInput: ${clientInputTypes}`
     );
-    fs7.writeFileSync(serverFilePath, content, "utf-8");
+    fs7.writeFileSync(serverFilePath, content, "utf8");
     console.log(`[TemplateInjector] Injected server template with clientInput: ${serverFilePath}`);
     return true;
   } catch (error) {
@@ -3834,7 +4076,7 @@ var injectServerTemplateWithClientInput = async (serverFilePath, clientInputType
 // src/importDependencyGraph.ts
 import fs8 from "fs";
 import path11 from "path";
-import { ROOT_DIR as ROOT_DIR6, getServerFunctionDirs as getServerFunctionDirs3, getSharedDir, getSrcDir as getSrcDir4 } from "@luckystack/core";
+import { ROOT_DIR as ROOT_DIR5, getServerFunctionDirs as getServerFunctionDirs3, getSharedDir, getSrcDir as getSrcDir5 } from "@luckystack/core";
 var SUPPORTED_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"];
 var normalizePath3 = (value) => path11.resolve(value).replaceAll("\\", "/");
 var isSupportedScriptFile = (value) => {
@@ -3854,15 +4096,26 @@ var existsDirectory = (value) => {
     return false;
   }
 };
-var collectScriptFiles = (dir, output) => {
+var collectScriptFiles = (dir, output, visited = /* @__PURE__ */ new Set()) => {
   if (!existsDirectory(dir)) {
     return;
   }
-  const entries = fs8.readdirSync(dir);
+  let realDir;
+  try {
+    realDir = fs8.realpathSync(dir);
+  } catch {
+    return;
+  }
+  if (visited.has(realDir)) return;
+  visited.add(realDir);
+  const entries = fs8.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path11.join(dir, entry);
-    if (existsDirectory(fullPath)) {
-      collectScriptFiles(fullPath, output);
+    if (entry.name === "node_modules") continue;
+    const fullPath = path11.join(dir, entry.name);
+    if (entry.isDirectory() || entry.isSymbolicLink()) {
+      if (existsDirectory(fullPath)) {
+        collectScriptFiles(fullPath, output, visited);
+      }
       continue;
     }
     const normalizedPath = normalizePath3(fullPath);
@@ -3889,8 +4142,8 @@ var extractImportSpecifiers = (filePath) => {
   try {
     const source = fs8.readFileSync(filePath, "utf8");
     const specifiers = /* @__PURE__ */ new Set();
-    const importExportRegex = /(?:import|export)\s+(?:[^'"\n]*?\s+from\s+)?['"]([^'"\n]+)['"]/g;
-    const dynamicImportRegex = /import\(\s*['"]([^'"\n]+)['"]\s*\)/g;
+    const importExportRegex = /(?:import|export)\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+    const dynamicImportRegex = /import\(\s*['"]([^'"]+)['"]\s*\)/g;
     let match = null;
     while ((match = importExportRegex.exec(source)) !== null) {
       if (match[1]) specifiers.add(match[1]);
@@ -3935,7 +4188,7 @@ var resolveImportToFile = (importerPath, specifier) => {
     return null;
   }
   if (specifier === "config") {
-    return tryResolveWithExtensions(path11.join(ROOT_DIR6, "config"));
+    return tryResolveWithExtensions(path11.join(ROOT_DIR5, "config"));
   }
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
     const relativeBase = path11.resolve(path11.dirname(importerPath), specifier);
@@ -3943,7 +4196,7 @@ var resolveImportToFile = (importerPath, specifier) => {
   }
   if (specifier.startsWith("src/") || specifier.startsWith("@/")) {
     const sourcePath = specifier.startsWith("@/") ? specifier.slice(2) : specifier.slice(4);
-    return tryResolveWithExtensions(path11.join(getSrcDir4(), sourcePath));
+    return tryResolveWithExtensions(path11.join(getSrcDir5(), sourcePath));
   }
   if (specifier.startsWith("shared/")) {
     return tryResolveWithExtensions(path11.join(getSharedDir(), specifier.slice(7)));
@@ -3959,12 +4212,12 @@ var collectScopedFiles = () => {
     return scopedFilesCache.files;
   }
   const files = /* @__PURE__ */ new Set();
-  collectScriptFiles(getSrcDir4(), files);
+  collectScriptFiles(getSrcDir5(), files);
   collectScriptFiles(getSharedDir(), files);
   for (const dir of getServerFunctionDirs3()) {
     collectScriptFiles(dir, files);
   }
-  const configFile = tryResolveWithExtensions(path11.join(ROOT_DIR6, "config"));
+  const configFile = tryResolveWithExtensions(path11.join(ROOT_DIR5, "config"));
   if (configFile) {
     files.add(configFile);
   }
@@ -4011,37 +4264,46 @@ var findDependentRouteFiles = (changedFilePath) => {
   return affectedRoutes;
 };
 
+// src/prismaClientCheck.ts
+import fs9 from "fs";
+import path12 from "path";
+import { spawn } from "child_process";
+import { ROOT_DIR as ROOT_DIR6, tryCatch as tryCatch2 } from "@luckystack/core";
+var GENERATED_CLIENT_DIR = path12.join(ROOT_DIR6, "node_modules", ".prisma", "client");
+var DEFAULT_SCHEMA_PATH = path12.join(ROOT_DIR6, "prisma", "schema.prisma");
+var isPrismaClientMissing = () => fs9.existsSync(DEFAULT_SCHEMA_PATH) && !fs9.existsSync(GENERATED_CLIENT_DIR);
+var runPrismaGenerate = async () => tryCatch2(
+  () => new Promise((resolve, reject) => {
+    const child = spawn("npx", ["prisma", "generate"], {
+      cwd: ROOT_DIR6,
+      stdio: "inherit",
+      //? `npx` resolves to `npx.cmd` on Windows, which requires shell
+      //? invocation to be found on PATH. Dev-only, fixed argv (no user
+      //? input interpolated), so the shell is not an injection surface.
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      resolve(code ?? 0);
+    });
+  })
+);
+
 // src/hotReload.ts
-import { tryCatch as tryCatch2, getProjectConfig, getLocaleReloader } from "@luckystack/core";
-var setupWatchers = () => {
-  const isDevMode = process.env.NODE_ENV !== "production";
-  if (!isDevMode) return;
-  const apiMarkerSlash = `/${getRoutingRules().apiMarker}/`;
-  const syncMarkerSlash = `/${getRoutingRules().syncMarker}/`;
-  const apiMarkerNoLead = `${getRoutingRules().apiMarker}/`;
-  const syncMarkerNoLead = `${getRoutingRules().syncMarker}/`;
-  const pathsCfg = getProjectConfig().paths;
-  const srcSegment = `/${pathsCfg.srcDir.replaceAll("\\", "/")}/`;
-  const sharedSegment = `/${pathsCfg.sharedDir.replaceAll("\\", "/")}/`;
-  const serverFunctionsSegments = (pathsCfg.serverFunctionDirs ?? [pathsCfg.serverFunctionsDir]).map(
-    (dir) => `/${dir.replaceAll("\\", "/")}/`
-  );
-  const isInServerFunctionsDir = (normalizedPath) => serverFunctionsSegments.some((segment) => normalizedPath.includes(segment));
-  const localesSegment = `${srcSegment}_locales/`;
-  const reloadTimers = /* @__PURE__ */ new Map();
-  const pendingApiUpserts = /* @__PURE__ */ new Set();
-  const pendingApiDeletes = /* @__PURE__ */ new Set();
-  const pendingSyncUpserts = /* @__PURE__ */ new Set();
-  const pendingSyncDeletes = /* @__PURE__ */ new Set();
-  const normalizeFsPath = (value) => path12.resolve(value).replaceAll("\\", "/");
-  const typeMapQueue = { pending: false, running: false };
-  const runTypeMapRegeneration = () => {
-    typeMapQueue.running = true;
-    typeMapQueue.pending = false;
+import { tryCatch as tryCatch3, getProjectConfig, getLocaleReloader } from "@luckystack/core";
+var normalizeFsPath = (value) => path13.resolve(value).replaceAll("\\", "/");
+var isGeneratedPath = (normalizedPath) => {
+  return normalizedPath.includes("apiTypes.generated.ts") || normalizedPath.includes("apiDocs.generated.json");
+};
+var createTypeMapQueue = () => {
+  const queue = { pending: false, running: false };
+  const run = () => {
+    queue.running = true;
+    queue.pending = false;
     const startedAt = Date.now();
     setImmediate(() => {
       void (async () => {
-        const [err] = await tryCatch2(() => {
+        const [err] = await tryCatch3(() => {
           generateTypeMapFile({ quiet: true });
         });
         if (err) {
@@ -4049,39 +4311,142 @@ var setupWatchers = () => {
         } else {
           console.log(`[HotReload] type map ready in ${Date.now() - startedAt}ms`, "green");
         }
-        typeMapQueue.running = false;
-        if (typeMapQueue.pending) {
-          runTypeMapRegeneration();
+        queue.running = false;
+        if (queue.pending) {
+          run();
         }
       })();
     });
   };
-  const requestTypeMapRegeneration = () => {
-    if (typeMapQueue.running) {
-      typeMapQueue.pending = true;
+  const request = () => {
+    if (queue.running) {
+      queue.pending = true;
       return;
     }
-    runTypeMapRegeneration();
+    run();
   };
-  const isRouteDependencyFile = (normalizedPath) => {
-    if (!normalizedPath.endsWith(".ts") && !normalizedPath.endsWith(".tsx")) {
-      return false;
+  return { request };
+};
+var createPendingChangeSets = () => ({
+  apiUpserts: /* @__PURE__ */ new Set(),
+  apiDeletes: /* @__PURE__ */ new Set(),
+  syncUpserts: /* @__PURE__ */ new Set(),
+  syncDeletes: /* @__PURE__ */ new Set()
+});
+var buildPathSegments = () => {
+  const rules2 = getRoutingRules();
+  const pathsCfg = getProjectConfig().paths;
+  const srcSegment = `/${pathsCfg.srcDir.replaceAll("\\", "/")}/`;
+  const sharedSegment = `/${pathsCfg.sharedDir.replaceAll("\\", "/")}/`;
+  return {
+    apiMarkerSlash: `/${rules2.apiMarker}/`,
+    syncMarkerSlash: `/${rules2.syncMarker}/`,
+    apiMarkerNoLead: `${rules2.apiMarker}/`,
+    syncMarkerNoLead: `${rules2.syncMarker}/`,
+    srcSegment,
+    sharedSegment,
+    localesSegment: `${srcSegment}_locales/`,
+    serverFunctionsSegments: pathsCfg.serverFunctionDirs.map(
+      (dir) => `/${dir.replaceAll("\\", "/")}/`
+    )
+  };
+};
+var makeIsInServerFunctionsDir = (segments) => (normalizedPath) => segments.serverFunctionsSegments.some((seg) => normalizedPath.includes(seg));
+var makeIsRouteDependencyFile = (segments) => (normalizedPath) => {
+  if (!normalizedPath.endsWith(".ts") && !normalizedPath.endsWith(".tsx")) return false;
+  if (!normalizedPath.includes(segments.srcSegment)) return false;
+  if (normalizedPath.includes(segments.apiMarkerSlash) || normalizedPath.includes(segments.syncMarkerSlash)) return false;
+  if (isGeneratedPath(normalizedPath)) return false;
+  return true;
+};
+var makeIsSharedDependencyFile = (segments, isInServerFunctionsDir) => (normalizedPath) => {
+  if (!(normalizedPath.endsWith(".ts") || normalizedPath.endsWith(".tsx"))) return false;
+  if (normalizedPath.includes(segments.sharedSegment)) return true;
+  return isInServerFunctionsDir(normalizedPath);
+};
+var makeIsTypeMapRelevantFile = (segments) => (normalizedPath) => {
+  if (isGeneratedPath(normalizedPath)) return false;
+  if (!(normalizedPath.endsWith(".ts") || normalizedPath.endsWith(".tsx"))) return false;
+  if (normalizedPath.includes(segments.apiMarkerSlash) || normalizedPath.includes(segments.syncMarkerSlash)) return false;
+  return normalizedPath.includes(segments.srcSegment) || normalizedPath.endsWith("/config.ts") || normalizedPath.includes(segments.sharedSegment);
+};
+var makeIsLocaleFile = (segments) => (normalizedPath) => normalizedPath.includes(segments.localesSegment) && normalizedPath.endsWith(".json");
+var createReloadScheduler = (debounceMs) => {
+  const timers = /* @__PURE__ */ new Map();
+  return (key, task, delay = debounceMs()) => {
+    const active = timers.get(key);
+    if (active) clearTimeout(active);
+    const timer = setTimeout(() => {
+      timers.delete(key);
+      Promise.resolve(task()).catch((error) => {
+        console.log(`[HotReload] Scheduled task threw an error: ${String(error)}`, "red");
+      });
+    }, delay);
+    timers.set(key, timer);
+  };
+};
+var mountWatchers = (onAdd, onChange, onDelete, onFunctionChange) => {
+  const devConfig = getProjectConfig().dev;
+  const pathsConfig = getProjectConfig().paths;
+  watch(pathsConfig.srcDir, {
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: devConfig.watcherStabilityThresholdMs,
+      pollInterval: devConfig.watcherPollIntervalMs
     }
-    if (!normalizedPath.includes(srcSegment)) {
-      return false;
+  }).on("add", onAdd).on("change", onChange).on("unlink", onDelete);
+  for (const dir of pathsConfig.serverFunctionDirs) {
+    watch(dir, { ignoreInitial: true }).on("add", onFunctionChange).on("change", onFunctionChange).on("unlink", onFunctionChange);
+  }
+  watch(pathsConfig.sharedDir, { ignoreInitial: true }).on("add", onFunctionChange).on("change", onFunctionChange).on("unlink", onFunctionChange);
+};
+var setupWatchers = () => {
+  const isDevMode = process.env.NODE_ENV !== "production";
+  if (!isDevMode) return;
+  const segments = buildPathSegments();
+  const isInServerFunctionsDir = makeIsInServerFunctionsDir(segments);
+  const isRouteDependencyFile = makeIsRouteDependencyFile(segments);
+  const isSharedDependencyFile = makeIsSharedDependencyFile(segments, isInServerFunctionsDir);
+  const isTypeMapRelevantFile = makeIsTypeMapRelevantFile(segments);
+  const isLocaleFile = makeIsLocaleFile(segments);
+  const typeMap = createTypeMapQueue();
+  const pending = createPendingChangeSets();
+  const scheduleReload = createReloadScheduler(() => getProjectConfig().dev.hotReloadDebounceMs);
+  const processPendingApiChanges = async ({ regenerateTypeMap = false } = {}) => {
+    const deletePaths = [...pending.apiDeletes];
+    const upsertPaths = [...pending.apiUpserts];
+    pending.apiDeletes.clear();
+    pending.apiUpserts.clear();
+    if (regenerateTypeMap) {
+      console.log(`[HotReload] API routes changed (add/delete), scheduling type map regeneration`, "blue");
+      typeMap.request();
     }
-    if (normalizedPath.includes(apiMarkerSlash) || normalizedPath.includes(syncMarkerSlash)) {
-      return false;
+    for (const deletePath of deletePaths) {
+      removeApiFromFile(deletePath);
+      console.log(`[HotReload] API removed: ${deletePath}`, "yellow");
     }
-    if (isGeneratedPath(normalizedPath)) {
-      return false;
+    for (const upsertPath of upsertPaths) {
+      await upsertApiFromFile(upsertPath);
+      console.log(`[HotReload] API reloaded: ${upsertPath}`, "green");
     }
-    return true;
   };
-  const isSharedDependencyFile = (normalizedPath) => {
-    if (!(normalizedPath.endsWith(".ts") || normalizedPath.endsWith(".tsx"))) return false;
-    if (normalizedPath.includes(sharedSegment)) return true;
-    return isInServerFunctionsDir(normalizedPath);
+  const processPendingSyncChanges = async ({ regenerateTypeMap = false } = {}) => {
+    const deletePaths = [...pending.syncDeletes];
+    const upsertPaths = [...pending.syncUpserts];
+    pending.syncDeletes.clear();
+    pending.syncUpserts.clear();
+    if (regenerateTypeMap) {
+      console.log(`[HotReload] Sync routes changed (add/delete), scheduling type map regeneration`, "blue");
+      typeMap.request();
+    }
+    for (const deletePath of deletePaths) {
+      removeSyncFromFile(deletePath);
+      console.log(`[HotReload] Sync removed: ${deletePath}`, "yellow");
+    }
+    for (const upsertPath of upsertPaths) {
+      await upsertSyncFromFile(upsertPath);
+      console.log(`[HotReload] Sync reloaded: ${upsertPath}`, "green");
+    }
   };
   const enqueueAffectedRoutesFromDependency = (changedPath) => {
     const affectedRoutes = findDependentRouteFiles(changedPath);
@@ -4092,13 +4457,13 @@ var setupWatchers = () => {
     let queuedApiCount = 0;
     let queuedSyncCount = 0;
     for (const routePath of affectedRoutes) {
-      if (routePath.includes(apiMarkerSlash)) {
-        pendingApiDeletes.delete(routePath);
-        pendingApiUpserts.add(routePath);
+      if (routePath.includes(segments.apiMarkerSlash)) {
+        pending.apiDeletes.delete(routePath);
+        pending.apiUpserts.add(routePath);
         queuedApiCount += 1;
-      } else if (routePath.includes(syncMarkerSlash)) {
-        pendingSyncDeletes.delete(routePath);
-        pendingSyncUpserts.add(routePath);
+      } else if (routePath.includes(segments.syncMarkerSlash)) {
+        pending.syncDeletes.delete(routePath);
+        pending.syncUpserts.add(routePath);
         queuedSyncCount += 1;
       }
     }
@@ -4117,36 +4482,13 @@ var setupWatchers = () => {
       });
     }
   };
-  const isGeneratedPath = (normalizedPath) => {
-    return normalizedPath.includes("apiTypes.generated.ts") || normalizedPath.includes("apiDocs.generated.json");
-  };
-  const isTypeMapRelevantFile = (normalizedPath) => {
-    if (isGeneratedPath(normalizedPath)) return false;
-    if (!(normalizedPath.endsWith(".ts") || normalizedPath.endsWith(".tsx"))) return false;
-    if (normalizedPath.includes(apiMarkerSlash) || normalizedPath.includes(syncMarkerSlash)) return false;
-    return normalizedPath.includes(srcSegment) || normalizedPath.endsWith("/config.ts") || normalizedPath.includes(sharedSegment);
-  };
-  const isLocaleFile = (normalizedPath) => {
-    return normalizedPath.includes(localesSegment) && normalizedPath.endsWith(".json");
-  };
-  const scheduleReload = (key, task, delay = getProjectConfig().dev.hotReloadDebounceMs) => {
-    const activeTimer = reloadTimers.get(key);
-    if (activeTimer) {
-      clearTimeout(activeTimer);
-    }
-    const timer = setTimeout(() => {
-      reloadTimers.delete(key);
-      void task();
-    }, delay);
-    reloadTimers.set(key, timer);
-  };
-  const handleAdd = async (path13) => {
-    const normalizedPath = normalizeFsPath(path13);
+  const handleAdd = async (filePath) => {
+    const normalizedPath = normalizeFsPath(filePath);
     invalidateGraphForFile(normalizedPath);
     const routeValidationMessage = getRouteFilenameValidationMessage(normalizedPath);
     if (routeValidationMessage) {
-      if (shouldInjectTemplate(path13)) {
-        const injected = await injectTemplate(path13);
+      if (shouldInjectTemplate(filePath, { isNewFile: true })) {
+        const injected = await injectTemplate(filePath);
         if (injected) {
           return;
         }
@@ -4154,87 +4496,57 @@ var setupWatchers = () => {
       console.log(`[HotReload] ${routeValidationMessage}`, "yellow");
       return;
     }
-    if (shouldInjectTemplate(path13)) {
+    if (shouldInjectTemplate(filePath, { isNewFile: true })) {
       if (isSyncServerFile(normalizedPath)) {
         const clientPath = getPairedSyncFile(normalizedPath);
-        if (clientPath && fs9.existsSync(clientPath) && !isEmptyFile(clientPath)) {
+        if (clientPath && fs10.existsSync(clientPath) && !isEmptyFile(clientPath)) {
           const clientInputTypes = extractClientInputFromFile(clientPath);
           if (clientInputTypes) {
-            await injectServerTemplateWithClientInput(path13, clientInputTypes);
-            requestTypeMapRegeneration();
-            await updateClientFileForPairedServer(clientPath);
-            await upsertSyncFromFile(path13);
+            await injectServerTemplateWithClientInput(filePath, clientInputTypes);
+            typeMap.request();
+            const clientRewritten = await updateClientFileForPairedServer(clientPath);
+            if (!clientRewritten) {
+              console.log(`[HotReload] Paired client rewrite failed, skipping upsert for: ${clientPath}`, "yellow");
+              return;
+            }
+            await upsertSyncFromFile(filePath);
             await upsertSyncFromFile(clientPath);
             return;
           }
         }
       }
-      const injected = await injectTemplate(path13);
+      const injected = await injectTemplate(filePath);
       if (injected) {
         return;
       }
     }
-    if (normalizedPath.includes(apiMarkerNoLead)) {
-      pendingApiDeletes.delete(normalizedPath);
-      pendingApiUpserts.add(normalizedPath);
+    if (normalizedPath.includes(segments.apiMarkerNoLead)) {
+      pending.apiDeletes.delete(normalizedPath);
+      pending.apiUpserts.add(normalizedPath);
       scheduleReload("api", async () => {
         await processPendingApiChanges({ regenerateTypeMap: true });
       });
       return;
     }
-    if (normalizedPath.includes(syncMarkerNoLead)) {
-      pendingSyncDeletes.delete(normalizedPath);
-      pendingSyncUpserts.add(normalizedPath);
+    if (normalizedPath.includes(segments.syncMarkerNoLead)) {
+      pending.syncDeletes.delete(normalizedPath);
+      pending.syncUpserts.add(normalizedPath);
       scheduleReload("sync", async () => {
         await processPendingSyncChanges({ regenerateTypeMap: true });
       });
       return;
     }
-    handleChange(path13);
-  };
-  const processPendingApiChanges = async ({ regenerateTypeMap = false } = {}) => {
-    const deletePaths = [...pendingApiDeletes];
-    const upsertPaths = [...pendingApiUpserts];
-    pendingApiDeletes.clear();
-    pendingApiUpserts.clear();
-    if (regenerateTypeMap) {
-      console.log(`[HotReload] API routes changed (add/delete), scheduling type map regeneration`, "blue");
-      requestTypeMapRegeneration();
-    }
-    for (const deletePath of deletePaths) {
-      removeApiFromFile(deletePath);
-      console.log(`[HotReload] API removed: ${deletePath}`, "yellow");
-    }
-    for (const upsertPath of upsertPaths) {
-      await upsertApiFromFile(upsertPath);
-      console.log(`[HotReload] API reloaded: ${upsertPath}`, "green");
-    }
-  };
-  const processPendingSyncChanges = async ({ regenerateTypeMap = false } = {}) => {
-    const deletePaths = [...pendingSyncDeletes];
-    const upsertPaths = [...pendingSyncUpserts];
-    pendingSyncDeletes.clear();
-    pendingSyncUpserts.clear();
-    if (regenerateTypeMap) {
-      console.log(`[HotReload] Sync routes changed (add/delete), scheduling type map regeneration`, "blue");
-      requestTypeMapRegeneration();
-    }
-    for (const deletePath of deletePaths) {
-      removeSyncFromFile(deletePath);
-      console.log(`[HotReload] Sync removed: ${deletePath}`, "yellow");
-    }
-    for (const upsertPath of upsertPaths) {
-      await upsertSyncFromFile(upsertPath);
-      console.log(`[HotReload] Sync reloaded: ${upsertPath}`, "green");
-    }
+    handleChange(filePath).catch((error) => {
+      console.log(`[HotReload] handleChange threw an error: ${String(error)}`, "red");
+    });
   };
-  const handleChange = async (path13) => {
-    const normalizedPath = normalizeFsPath(path13);
+  const handleChange = async (filePath) => {
+    const normalizedPath = normalizeFsPath(filePath);
     invalidateGraphForFile(normalizedPath);
     const routeValidationMessage = getRouteFilenameValidationMessage(normalizedPath);
     if (routeValidationMessage) {
-      if (shouldInjectTemplate(path13)) {
-        const injected = await injectTemplate(path13);
+      if (shouldInjectTemplate(filePath)) {
+        const injected = await injectTemplate(filePath);
         if (injected) {
           return;
         }
@@ -4242,8 +4554,8 @@ var setupWatchers = () => {
       console.log(`[HotReload] ${routeValidationMessage}`, "yellow");
       return;
     }
-    if (shouldInjectTemplate(path13)) {
-      const injected = await injectTemplate(path13);
+    if (shouldInjectTemplate(filePath)) {
+      const injected = await injectTemplate(filePath);
       if (injected) {
         return;
       }
@@ -4260,7 +4572,7 @@ var setupWatchers = () => {
     if (isRouteDependencyFile(normalizedPath)) {
       scheduleReload("typemap", () => {
         console.log(`[HotReload] Route dependency changed, scheduling type map regeneration`, "blue");
-        requestTypeMapRegeneration();
+        typeMap.request();
       });
       enqueueAffectedRoutesFromDependency(normalizedPath);
       return;
@@ -4268,26 +4580,26 @@ var setupWatchers = () => {
     if (isTypeMapRelevantFile(normalizedPath)) {
       scheduleReload("typemap", () => {
         console.log(`[HotReload] Route dependency changed, scheduling type map regeneration`, "blue");
-        requestTypeMapRegeneration();
+        typeMap.request();
       });
     }
-    if (normalizedPath.includes(apiMarkerNoLead)) {
+    if (normalizedPath.includes(segments.apiMarkerNoLead)) {
       scheduleReload("typemap", () => {
         console.log(`[HotReload] API changed, scheduling type map regeneration`, "blue");
-        requestTypeMapRegeneration();
+        typeMap.request();
       });
-      pendingApiDeletes.delete(normalizedPath);
-      pendingApiUpserts.add(normalizedPath);
+      pending.apiDeletes.delete(normalizedPath);
+      pending.apiUpserts.add(normalizedPath);
       scheduleReload("api", async () => {
         await processPendingApiChanges();
       });
-    } else if (normalizedPath.includes(syncMarkerNoLead)) {
+    } else if (normalizedPath.includes(segments.syncMarkerNoLead)) {
       scheduleReload("typemap", () => {
         console.log(`[HotReload] Sync changed, scheduling type map regeneration`, "blue");
-        requestTypeMapRegeneration();
+        typeMap.request();
       });
-      pendingSyncDeletes.delete(normalizedPath);
-      pendingSyncUpserts.add(normalizedPath);
+      pending.syncDeletes.delete(normalizedPath);
+      pending.syncUpserts.add(normalizedPath);
       scheduleReload("sync", async () => {
         await processPendingSyncChanges();
       });
@@ -4297,15 +4609,15 @@ var setupWatchers = () => {
     const normalizedPath = normalizeFsPath(changedPath);
     invalidateGraphForFile(normalizedPath);
     scheduleReload("functions", async () => {
-      requestTypeMapRegeneration();
+      typeMap.request();
       await initializeFunctions();
     });
     if (isSharedDependencyFile(normalizedPath)) {
       enqueueAffectedRoutesFromDependency(normalizedPath);
     }
   };
-  const handleDelete = async (path13) => {
-    const normalizedPath = normalizeFsPath(path13);
+  const handleDelete = (filePath) => {
+    const normalizedPath = normalizeFsPath(filePath);
     invalidateGraphForFile(normalizedPath);
     if (isGeneratedPath(normalizedPath)) {
       return;
@@ -4319,7 +4631,7 @@ var setupWatchers = () => {
     if (isRouteDependencyFile(normalizedPath)) {
       scheduleReload("typemap", () => {
         console.log(`[HotReload] Route dependency deleted, scheduling type map regeneration`, "blue");
-        requestTypeMapRegeneration();
+        typeMap.request();
       });
       enqueueAffectedRoutesFromDependency(normalizedPath);
       return;
@@ -4327,237 +4639,80 @@ var setupWatchers = () => {
     if (isTypeMapRelevantFile(normalizedPath)) {
       scheduleReload("typemap", () => {
         console.log(`[HotReload] Route dependency deleted, scheduling type map regeneration`, "blue");
-        requestTypeMapRegeneration();
+        typeMap.request();
       });
     }
-    if (normalizedPath.includes(apiMarkerNoLead)) {
+    if (normalizedPath.includes(segments.apiMarkerNoLead)) {
       scheduleReload("typemap", () => {
         console.log(`[HotReload] API deleted, scheduling type map regeneration`, "blue");
-        requestTypeMapRegeneration();
+        typeMap.request();
       });
-      pendingApiUpserts.delete(normalizedPath);
-      pendingApiDeletes.add(normalizedPath);
+      pending.apiUpserts.delete(normalizedPath);
+      pending.apiDeletes.add(normalizedPath);
       scheduleReload("api", async () => {
         await processPendingApiChanges();
       });
-    } else if (normalizedPath.includes(syncMarkerNoLead)) {
+    } else if (normalizedPath.includes(segments.syncMarkerNoLead)) {
       scheduleReload("typemap", () => {
         console.log(`[HotReload] Sync deleted, scheduling type map regeneration`, "blue");
-        requestTypeMapRegeneration();
+        typeMap.request();
       });
-      pendingSyncUpserts.delete(normalizedPath);
-      pendingSyncDeletes.add(normalizedPath);
+      pending.syncUpserts.delete(normalizedPath);
+      pending.syncDeletes.add(normalizedPath);
       scheduleReload("sync", async () => {
         if (isSyncServerFile(normalizedPath)) {
           const clientPath = getPairedSyncFile(normalizedPath);
-          if (clientPath && fs9.existsSync(clientPath)) {
+          if (clientPath && fs10.existsSync(clientPath)) {
             const pagePath = extractSyncPagePath2(normalizedPath);
             const syncName = extractSyncName2(normalizedPath);
             const clientInputTypes = extractClientInputFromGeneratedTypes(pagePath, syncName);
-            if (clientInputTypes) {
-              await updateClientFileForDeletedServer(clientPath, clientInputTypes);
-            } else {
-              await updateClientFileForDeletedServer(clientPath, "{\n    // Types were in _server.ts - please add them here\n  }");
-            }
+            await updateClientFileForDeletedServer(
+              clientPath,
+              clientInputTypes ?? "{\n    // Types were in _server.ts - please add them here\n  }"
+            );
           }
         }
         await processPendingSyncChanges();
       });
     }
   };
-  const devConfig = getProjectConfig().dev;
-  const pathsConfig = getProjectConfig().paths;
-  watch(pathsConfig.srcDir, {
-    ignoreInitial: true,
-    awaitWriteFinish: {
-      stabilityThreshold: devConfig.watcherStabilityThresholdMs,
-      pollInterval: devConfig.watcherPollIntervalMs
-    }
-  }).on("add", handleAdd).on("change", handleChange).on("unlink", handleDelete);
-  const serverFunctionDirsToWatch = pathsConfig.serverFunctionDirs && pathsConfig.serverFunctionDirs.length > 0 ? pathsConfig.serverFunctionDirs : [pathsConfig.serverFunctionsDir];
-  for (const dir of serverFunctionDirsToWatch) {
-    watch(dir, { ignoreInitial: true }).on("add", handleFunctionChange).on("change", handleFunctionChange).on("unlink", handleFunctionChange);
-  }
-  watch(pathsConfig.sharedDir, { ignoreInitial: true }).on("add", handleFunctionChange).on("change", handleFunctionChange).on("unlink", handleFunctionChange);
+  const safeHandleAdd = (p) => {
+    void handleAdd(p).catch((error) => {
+      console.log(`[HotReload] handleAdd threw an error: ${String(error)}`, "red");
+    });
+  };
+  const safeHandleChange = (p) => {
+    void handleChange(p).catch((error) => {
+      console.log(`[HotReload] handleChange threw an error: ${String(error)}`, "red");
+    });
+  };
+  const safeHandleDelete = (p) => {
+    handleDelete(p);
+  };
+  mountWatchers(safeHandleAdd, safeHandleChange, safeHandleDelete, handleFunctionChange);
   setImmediate(() => {
     void (async () => {
-      const [err] = await tryCatch2(() => {
+      if (isPrismaClientMissing()) {
+        console.log(`[HotReload] @prisma/client not generated yet \u2014 running prisma generate (no DB needed)\u2026`, "blue");
+        const [generateErr, exitCode] = await runPrismaGenerate();
+        if (generateErr || exitCode !== 0) {
+          console.log(`[HotReload] prisma generate failed${generateErr ? `: ${String(generateErr)}` : ` (exit code ${String(exitCode)})`} \u2014 run \`npm run prisma:generate\` manually and restart`, "red");
+        } else {
+          console.log(`[HotReload] prisma generate complete`, "green");
+        }
+      }
+      const [err] = await tryCatch3(() => {
         generateTypeMapFile({ quiet: true });
       });
       if (err) {
-        console.log(`[HotReload] initial type map generation failed: ${String(err)}`, "red");
+        const hint = isPrismaClientMissing() ? "\n  \u2192 This usually means @prisma/client is not generated. Run `npm run prisma:generate` and restart." : "";
+        console.log(`[HotReload] initial type map generation failed: ${String(err)}${hint}`, "red");
       } else {
         console.log(`[HotReload] type map ready in background`, "green");
       }
     })();
   });
 };
-
-// src/validateDeploy.ts
-var validateDeploy = ({
-  services,
-  deploy,
-  env = process.env
-}) => {
-  const findings = [];
-  const serviceNames = new Set(Object.keys(services.services));
-  const servicesInPresets = /* @__PURE__ */ new Map();
-  for (const [presetKey, preset] of Object.entries(services.presets)) {
-    for (const service of preset.services) {
-      const existing = servicesInPresets.get(service) ?? [];
-      existing.push(presetKey);
-      servicesInPresets.set(service, existing);
-    }
-  }
-  for (const service of serviceNames) {
-    const owners = servicesInPresets.get(service) ?? [];
-    if (owners.length === 0) {
-      findings.push({
-        severity: "error",
-        code: "service-unassigned",
-        message: `Service "${service}" is declared in services.services but not assigned to any preset. Every service must belong to exactly one preset.`,
-        location: `services.config.ts > services.${service}`
-      });
-    } else if (owners.length > 1) {
-      findings.push({
-        severity: "error",
-        code: "service-in-multiple-presets",
-        message: `Service "${service}" is in multiple presets: ${owners.join(", ")}. A service may belong to exactly one preset.`,
-        location: `services.config.ts > services.${service}`
-      });
-    }
-  }
-  for (const [presetKey, preset] of Object.entries(services.presets)) {
-    for (const service of preset.services) {
-      if (!serviceNames.has(service)) {
-        findings.push({
-          severity: "error",
-          code: "preset-references-unknown-service",
-          message: `Preset "${presetKey}" references unknown service "${service}". Add it to services.services or remove the reference.`,
-          location: `services.config.ts > presets.${presetKey}.services`
-        });
-      }
-    }
-  }
-  const environments = deploy.environments ?? {};
-  const resourceNames = new Set(Object.keys(deploy.resources));
-  for (const [envKey, envDef] of Object.entries(environments)) {
-    for (const [bindingService, bindingUrl] of Object.entries(envDef.bindings)) {
-      if (!serviceNames.has(bindingService)) {
-        findings.push({
-          severity: "error",
-          code: "binding-references-unknown-service",
-          message: `Environment "${envKey}" binds unknown service "${bindingService}". Either add it to services.services or remove the binding.`,
-          location: `deploy.config.ts > environments.${envKey}.bindings`
-        });
-      }
-      let parsed = null;
-      try {
-        parsed = new URL(bindingUrl);
-      } catch {
-        findings.push({
-          severity: "error",
-          code: "binding-invalid-url",
-          message: `Environment "${envKey}" service "${bindingService}" binding is not a valid URL: "${bindingUrl}".`,
-          location: `deploy.config.ts > environments.${envKey}.bindings.${bindingService}`
-        });
-      }
-      if (parsed && !parsed.port) {
-        findings.push({
-          severity: "error",
-          code: "binding-missing-port",
-          message: `Environment "${envKey}" service "${bindingService}" binding "${bindingUrl}" is missing an explicit port. Set one to avoid the URL-spec default (80/443) silently winning.`,
-          location: `deploy.config.ts > environments.${envKey}.bindings.${bindingService}`
-        });
-      }
-    }
-    if (!resourceNames.has(envDef.redis)) {
-      findings.push({
-        severity: "error",
-        code: "unknown-redis-resource",
-        message: `Environment "${envKey}" references unknown redis resource "${envDef.redis}". Add it to deploy.resources.`,
-        location: `deploy.config.ts > environments.${envKey}.redis`
-      });
-    }
-    if (!resourceNames.has(envDef.mongo)) {
-      findings.push({
-        severity: "error",
-        code: "unknown-mongo-resource",
-        message: `Environment "${envKey}" references unknown mongo resource "${envDef.mongo}". Add it to deploy.resources.`,
-        location: `deploy.config.ts > environments.${envKey}.mongo`
-      });
-    }
-    if (envDef.fallback) {
-      const fallbackEnv = environments[envDef.fallback];
-      if (fallbackEnv) {
-        if (fallbackEnv.redis !== envDef.redis) {
-          findings.push({
-            severity: "error",
-            code: "fallback-redis-mismatch",
-            message: `Environment "${envKey}" and its fallback "${envDef.fallback}" reference different redis resources ("${envDef.redis}" vs "${fallbackEnv.redis}"). Fallback envs must share the same redis resource key to keep the shared-Redis invariant.`,
-            location: `deploy.config.ts > environments.${envKey}.fallback`
-          });
-        }
-        if (fallbackEnv.mongo !== envDef.mongo) {
-          findings.push({
-            severity: "error",
-            code: "fallback-mongo-mismatch",
-            message: `Environment "${envKey}" and its fallback "${envDef.fallback}" reference different mongo resources ("${envDef.mongo}" vs "${fallbackEnv.mongo}"). Fallback envs must share the same mongo resource key.`,
-            location: `deploy.config.ts > environments.${envKey}.fallback`
-          });
-        }
-      } else {
-        findings.push({
-          severity: "error",
-          code: "unknown-fallback-env",
-          message: `Environment "${envKey}" has fallback "${envDef.fallback}" which does not exist in deploy.environments.`,
-          location: `deploy.config.ts > environments.${envKey}.fallback`
-        });
-      }
-    }
-  }
-  for (const [resourceKey, resource] of Object.entries(deploy.resources)) {
-    const urlValue = env[resource.urlEnvKey];
-    if (urlValue === void 0 || urlValue === "") {
-      findings.push({
-        severity: "warning",
-        code: "missing-resource-env-var",
-        message: `Resource "${resourceKey}" expects env var "${resource.urlEnvKey}" but it is unset. The framework will still boot if the env is provided at runtime, but config-time tooling cannot verify the value.`,
-        location: `deploy.config.ts > resources.${resourceKey}.urlEnvKey`
-      });
-    }
-    for (const synchronizedKey of resource.synchronizedEnvKeys ?? []) {
-      const value = env[synchronizedKey];
-      if (value === void 0 || value === "") {
-        findings.push({
-          severity: "warning",
-          code: "missing-synchronized-env-var",
-          message: `Resource "${resourceKey}" requires synchronized env var "${synchronizedKey}" but it is unset. Boot will compute an empty hash and fall back to warning-only.`,
-          location: `deploy.config.ts > resources.${resourceKey}.synchronizedEnvKeys`
-        });
-      }
-    }
-  }
-  for (const service of serviceNames) {
-    const boundIn = Object.entries(environments).filter(([, env2]) => service in env2.bindings);
-    if (boundIn.length === 0) {
-      findings.push({
-        severity: "warning",
-        code: "service-bound-in-no-environment",
-        message: `Service "${service}" is in services.services and assigned to a preset but never bound in any environment. Requests for this service will fall through to the missing-service handler.`,
-        location: `services.config.ts > services.${service}`
-      });
-    }
-  }
-  const errorCount = findings.filter((f) => f.severity === "error").length;
-  const warningCount = findings.filter((f) => f.severity === "warning").length;
-  return {
-    ok: errorCount === 0,
-    findings,
-    errorCount,
-    warningCount
-  };
-};
 export {
   API_VERSION_TOKEN_REGEX,
   BUILT_IN_TEMPLATE_FILENAMES,