@luckystack/devkit 0.1.0

package/dist/index.js

@@ -0,0 +1,4606 @@
+// src/typeMap/discovery.ts
+import fs from "fs";
+import path from "path";
+import { ROOT_DIR } from "@luckystack/core";
+
+// src/routingRules.ts
+import { validatePagePath as corePagePath } from "@luckystack/core";
+var DEFAULT_RULES = {
+  apiMarker: "_api",
+  syncMarker: "_sync",
+  apiVersionRegex: /_v(\d+)$/,
+  syncServerVersionRegex: /_server_v(\d+)$/,
+  syncClientVersionRegex: /_client_v(\d+)$/,
+  syncVersionRegex: /_(server|client)_v(\d+)$/,
+  ignore: () => false,
+  privateFolderPrefix: "_",
+  scaffoldIgnoredFolders: [
+    "_api",
+    "_sync",
+    "_function",
+    "_functions",
+    "_component",
+    "_components",
+    "_provider",
+    "_providers",
+    "_locale",
+    "_locales",
+    "_socket",
+    "_sockets",
+    "_shared",
+    "_server"
+  ]
+};
+var activeRules = DEFAULT_RULES;
+var registerRoutingRules = (overrides2) => {
+  activeRules = { ...DEFAULT_RULES, ...overrides2 };
+  return activeRules;
+};
+var getRoutingRules = () => activeRules;
+var apiMarkerSegment = () => `/${getRoutingRules().apiMarker}/`;
+var syncMarkerSegment = () => `/${getRoutingRules().syncMarker}/`;
+var isApiFileName = (fileName) => {
+  if (!fileName.endsWith(".ts")) return false;
+  const stem = fileName.slice(0, -3);
+  return getRoutingRules().apiVersionRegex.test(stem);
+};
+var isSyncServerFileName = (fileName) => {
+  if (!fileName.endsWith(".ts")) return false;
+  const stem = fileName.slice(0, -3);
+  return getRoutingRules().syncServerVersionRegex.test(stem);
+};
+var isSyncClientFileName = (fileName) => {
+  if (!fileName.endsWith(".ts")) return false;
+  const stem = fileName.slice(0, -3);
+  return getRoutingRules().syncClientVersionRegex.test(stem);
+};
+var isSyncFileName = (fileName) => {
+  if (!fileName.endsWith(".ts")) return false;
+  const stem = fileName.slice(0, -3);
+  return getRoutingRules().syncVersionRegex.test(stem);
+};
+var isRouteTestFile = (fileNameOrPath) => {
+  return fileNameOrPath.endsWith(".tests.ts");
+};
+
+// src/typeMap/discovery.ts
+var toForwardSlashRelative = (absolute) => {
+  const rel = path.relative(ROOT_DIR, absolute);
+  return rel.replaceAll("\\", "/");
+};
+var walkFiles = (dir, matcher, results = []) => {
+  const { ignore } = getRoutingRules();
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = toForwardSlashRelative(fullPath);
+      if (ignore(relativePath)) continue;
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        walkFiles(fullPath, matcher, results);
+        continue;
+      }
+      if (entry.isFile() && matcher(fullPath, entry.name)) {
+        results.push(fullPath);
+      }
+    }
+  } catch (error) {
+    console.error(`[TypeMapDiscovery] Error scanning directory ${dir}:`, error);
+  }
+  return results;
+};
+var findAllApiFiles = (srcDir) => {
+  const apiSegment = apiMarkerSegment();
+  return walkFiles(srcDir, (fullPath, entryName) => {
+    const normalized = fullPath.replace(/\\/g, "/");
+    return isApiFileName(entryName) && normalized.includes(apiSegment);
+  });
+};
+var findAllSyncServerFiles = (srcDir) => {
+  const syncSegment = syncMarkerSegment();
+  return walkFiles(srcDir, (fullPath, entryName) => {
+    const normalized = fullPath.replace(/\\/g, "/");
+    return isSyncServerFileName(entryName) && normalized.includes(syncSegment);
+  });
+};
+var findAllSyncClientFiles = (srcDir) => {
+  const syncSegment = syncMarkerSegment();
+  return walkFiles(srcDir, (fullPath, entryName) => {
+    const normalized = fullPath.replace(/\\/g, "/");
+    return isSyncClientFileName(entryName) && normalized.includes(syncSegment);
+  });
+};
+
+// src/typeMap/routeMeta.ts
+import path2 from "path";
+
+// src/routeConventions.ts
+var API_VERSION_TOKEN_REGEX = /_v(\d+)$/;
+var SYNC_VERSION_TOKEN_REGEX = /_(server|client)_v(\d+)$/;
+var ROUTE_NAMING_RULES = {
+  api: "<name>_v<number>.ts",
+  syncServer: "<name>_server_v<number>.ts",
+  syncClient: "<name>_client_v<number>.ts"
+};
+var ROUTE_NAMING_EXAMPLES = {
+  api: "updateUser_v1.ts",
+  syncServer: "updateCounter_server_v1.ts",
+  syncClient: "updateCounter_client_v1.ts"
+};
+var isVersionedApiFileName = (fileName) => isApiFileName(fileName);
+var isVersionedSyncFileName = (fileName) => isSyncFileName(fileName);
+var isVersionedSyncServerFileName = (fileName) => isSyncServerFileName(fileName);
+var isVersionedSyncClientFileName = (fileName) => isSyncClientFileName(fileName);
+
+// src/typeMap/routeMeta.ts
+var VERSION_SUFFIX_REGEX = API_VERSION_TOKEN_REGEX;
+var stripVersionSuffix = (name) => {
+  return name.replace(VERSION_SUFFIX_REGEX, "");
+};
+var extractVersionFromName = (name) => {
+  const match = name.match(VERSION_SUFFIX_REGEX);
+  if (!match) return null;
+  return `v${match[1]}`;
+};
+var extractPagePath = (filePath) => {
+  const normalized = filePath.replace(/\\/g, "/");
+  const match = normalized.match(/src\/(?:(.+?)\/)_api\//);
+  if (match) {
+    return match[1] || "system";
+  }
+  if (normalized.includes("/src/_api/")) {
+    return "system";
+  }
+  return "";
+};
+var extractApiName = (filePath) => {
+  const normalized = filePath.replace(/\\/g, "/");
+  const match = normalized.match(/_api\/(.+)\.ts$/);
+  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 rawName = match?.[1] ?? path2.basename(filePath, ".ts");
+  return extractVersionFromName(rawName) || "v1";
+};
+var extractSyncPagePath = (filePath) => {
+  const normalized = filePath.replace(/\\/g, "/");
+  const match = normalized.match(/src\/(?:(.+?)\/)_sync\//);
+  if (match) {
+    return match[1] || "root";
+  }
+  if (normalized.includes("/src/_sync/")) {
+    return "root";
+  }
+  return "";
+};
+var extractSyncName = (filePath) => {
+  const normalized = filePath.replace(/\\/g, "/");
+  const match = normalized.match(/_sync\/(.+)\.ts$/);
+  if (!match) {
+    const basename = path2.basename(filePath, ".ts");
+    const rawName2 = basename.replace(SYNC_VERSION_TOKEN_REGEX, "");
+    return rawName2;
+  }
+  const rawName = (match[1] ?? "").replace(SYNC_VERSION_TOKEN_REGEX, "");
+  return rawName;
+};
+var extractSyncVersion = (filePath) => {
+  const normalized = filePath.replace(/\\/g, "/");
+  const match = normalized.match(/_sync\/(.+)\.ts$/);
+  if (!match) {
+    const basename = path2.basename(filePath, ".ts");
+    const versionMatch2 = basename.match(SYNC_VERSION_TOKEN_REGEX);
+    return versionMatch2 ? `v${versionMatch2[2] ?? "1"}` : "v1";
+  }
+  const versionMatch = (match[1] ?? "").match(SYNC_VERSION_TOKEN_REGEX);
+  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";
+var findExportedConst = (sourceFile, name) => {
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    const hasExport = statement.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+    if (!hasExport) continue;
+    for (const decl of statement.declarationList.declarations) {
+      if (ts.isIdentifier(decl.name) && decl.name.text === name) return decl;
+    }
+  }
+  return null;
+};
+var unwrapExpression = (node) => {
+  let current = node;
+  while (ts.isAsExpression(current) || ts.isSatisfiesExpression(current) || ts.isParenthesizedExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+};
+var extractHttpMethod = (filePath, apiName) => {
+  try {
+    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;
+    }
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error extracting httpMethod from ${filePath}:`, error);
+  }
+  return inferHttpMethod(apiName);
+};
+var extractRateLimit = (filePath) => {
+  try {
+    const content = fs2.readFileSync(filePath, "utf8");
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const decl = findExportedConst(sourceFile, "rateLimit");
+    if (decl?.initializer) {
+      const initializer = unwrapExpression(decl.initializer);
+      if (initializer.kind === ts.SyntaxKind.FalseKeyword) return false;
+      if (ts.isNumericLiteral(initializer)) return Number(initializer.text);
+    }
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error extracting rateLimit from ${filePath}:`, error);
+  }
+  return void 0;
+};
+var readPrimitive = (rawNode) => {
+  const node = unwrapExpression(rawNode);
+  if (ts.isStringLiteral(node)) return node.text;
+  if (ts.isNumericLiteral(node)) return Number(node.text);
+  if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+  return void 0;
+};
+var parseAdditionalItem = (objectLiteral) => {
+  const item = {};
+  for (const prop of objectLiteral.properties) {
+    if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+    const value = readPrimitive(prop.initializer);
+    if (value !== void 0) item[prop.name.text] = value;
+  }
+  return item.key ? item : null;
+};
+var extractDocsMeta = (filePath) => {
+  try {
+    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();
+      if (commentText.length === 0) return;
+      const spaceIdx = commentText.search(/\s/);
+      const subkey = (spaceIdx === -1 ? commentText : commentText.slice(0, spaceIdx)).toLowerCase();
+      const value = spaceIdx === -1 ? "" : commentText.slice(spaceIdx + 1).trim();
+      if (subkey === "owner" && value.length > 0) {
+        result.owner = value;
+      } else if (subkey === "tags" && value.length > 0) {
+        const tags = value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+        if (tags.length > 0) result.tags = tags;
+      } else if (subkey === "deprecated") {
+        result.deprecated = value.length > 0 ? value : true;
+      }
+    };
+    for (const statement of sourceFile.statements) {
+      for (const tag of ts.getJSDocTags(statement)) {
+        consumeTag(tag);
+      }
+    }
+    if (result.owner === void 0 && result.tags === void 0 && result.deprecated === void 0) {
+      return void 0;
+    }
+    return result;
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error extracting @docs metadata from ${filePath}:`, error);
+    return void 0;
+  }
+};
+var extractAuth = (filePath) => {
+  try {
+    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;
+    let additional;
+    for (const prop of authInitializer.properties) {
+      if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+      const propInit = unwrapExpression(prop.initializer);
+      if (prop.name.text === "login") {
+        login = propInit.kind === ts.SyntaxKind.TrueKeyword;
+      }
+      if (prop.name.text === "additional" && ts.isArrayLiteralExpression(propInit)) {
+        additional = [];
+        for (const element of propInit.elements) {
+          if (!ts.isObjectLiteralExpression(element)) continue;
+          const item = parseAdditionalItem(element);
+          if (item) additional.push(item);
+        }
+      }
+    }
+    return additional && additional.length > 0 ? { login, additional } : { login };
+  } catch {
+  }
+  return { login: true };
+};
+
+// src/typeMap/emitterArtifacts.ts
+import fs3 from "fs";
+import path3 from "path";
+import * as ts3 from "typescript";
+import { getGeneratedApiDocsPath, getGeneratedApiSchemasPath, getGeneratedSocketTypesPath } from "@luckystack/core";
+
+// src/internal/mapUtils.ts
+var getOrInit = (map, key, factory) => {
+  const existing = map.get(key);
+  if (existing !== void 0) return existing;
+  const fresh = factory();
+  map.set(key, fresh);
+  return fresh;
+};
+var mustGet = (map, key, label) => {
+  const value = map.get(key);
+  if (value === void 0) {
+    throw new Error(`[devkit] invariant violation: '${String(key)}' missing from ${label}`);
+  }
+  return value;
+};
+
+// src/typeMap/zodEmitter.ts
+import * as ts2 from "typescript";
+var wrapOptional = (inner) => `${inner}.optional()`;
+var anyFallback = (reason) => `z.any() /* ${reason} */`;
+var convertTypeNode = (node) => {
+  if (node.kind === ts2.SyntaxKind.StringKeyword) return "z.string()";
+  if (node.kind === ts2.SyntaxKind.NumberKeyword) return "z.number()";
+  if (node.kind === ts2.SyntaxKind.BooleanKeyword) return "z.boolean()";
+  if (node.kind === ts2.SyntaxKind.NullKeyword) return "z.null()";
+  if (node.kind === ts2.SyntaxKind.UndefinedKeyword) return "z.undefined()";
+  if (node.kind === ts2.SyntaxKind.AnyKeyword) return "z.any()";
+  if (node.kind === ts2.SyntaxKind.UnknownKeyword) return "z.unknown()";
+  if (node.kind === ts2.SyntaxKind.NeverKeyword) return "z.never()";
+  if (ts2.isLiteralTypeNode(node)) {
+    const literal = node.literal;
+    if (ts2.isStringLiteral(literal)) return `z.literal(${JSON.stringify(literal.text)})`;
+    if (ts2.isNumericLiteral(literal)) return `z.literal(${literal.text})`;
+    if (literal.kind === ts2.SyntaxKind.TrueKeyword) return "z.literal(true)";
+    if (literal.kind === ts2.SyntaxKind.FalseKeyword) return "z.literal(false)";
+    if (literal.kind === ts2.SyntaxKind.NullKeyword) return "z.null()";
+    return anyFallback("unknown literal");
+  }
+  if (ts2.isArrayTypeNode(node)) {
+    return `z.array(${convertTypeNode(node.elementType)})`;
+  }
+  if (ts2.isUnionTypeNode(node)) {
+    const members = node.types;
+    const hasUndefined = members.some((m) => m.kind === ts2.SyntaxKind.UndefinedKeyword);
+    const nonUndef = members.filter((m) => m.kind !== ts2.SyntaxKind.UndefinedKeyword);
+    if (nonUndef.length === 0) return "z.undefined()";
+    const firstNonUndef = nonUndef[0];
+    const innerSchema = nonUndef.length === 1 && firstNonUndef ? convertTypeNode(firstNonUndef) : `z.union([${nonUndef.map((m) => convertTypeNode(m)).join(", ")}])`;
+    return hasUndefined ? wrapOptional(innerSchema) : innerSchema;
+  }
+  if (ts2.isTypeReferenceNode(node)) {
+    const name = node.typeName.getText();
+    const args = node.typeArguments ?? [];
+    switch (name) {
+      case "Record": {
+        const arg0 = args[0];
+        const arg1 = args[1];
+        if (args.length === 2 && arg0 && arg1) {
+          return `z.record(${convertTypeNode(arg0)}, ${convertTypeNode(arg1)})`;
+        }
+        return anyFallback("Record with unexpected arity");
+      }
+      case "Partial": {
+        const arg0 = args[0];
+        return args.length === 1 && arg0 ? `${convertTypeNode(arg0)}.partial()` : anyFallback("Partial without type arg");
+      }
+      case "Array": {
+        const arg0 = args[0];
+        return args.length === 1 && arg0 ? `z.array(${convertTypeNode(arg0)})` : anyFallback("Array without element type");
+      }
+      case "Date": {
+        return "z.date()";
+      }
+      default: {
+        return anyFallback(`unresolved TypeReference '${name}'`);
+      }
+    }
+  }
+  if (ts2.isTypeLiteralNode(node)) {
+    const indexSignatures = node.members.filter((m) => ts2.isIndexSignatureDeclaration(m));
+    const propertySignatures = node.members.filter((m) => ts2.isPropertySignature(m));
+    if (indexSignatures.length === 1 && propertySignatures.length === 0 && indexSignatures[0]?.type.kind === ts2.SyntaxKind.NeverKeyword) {
+      return "z.object({}).strict()";
+    }
+    if (indexSignatures.length > 0 && propertySignatures.length === 0) {
+      const sig = indexSignatures[0];
+      const keyType = sig?.parameters[0]?.type;
+      const valueType = sig?.type;
+      if (sig && keyType && valueType) {
+        return `z.record(${convertTypeNode(keyType)}, ${convertTypeNode(valueType)})`;
+      }
+    }
+    const entries = propertySignatures.map((prop) => {
+      if (!ts2.isIdentifier(prop.name)) return null;
+      if (!prop.type) return null;
+      const name = prop.name.text;
+      let schema = convertTypeNode(prop.type);
+      if (prop.questionToken && !schema.endsWith(".optional()")) {
+        schema = wrapOptional(schema);
+      }
+      return `${JSON.stringify(name)}: ${schema}`;
+    }).filter((entry) => entry !== null);
+    return `z.object({ ${entries.join(", ")} })`;
+  }
+  if (ts2.isParenthesizedTypeNode(node)) {
+    return convertTypeNode(node.type);
+  }
+  if (ts2.isIntersectionTypeNode(node)) {
+    return anyFallback("intersection not yet supported");
+  }
+  return anyFallback(`unsupported TypeNode kind=${String(node.kind)}`);
+};
+var typeTextToZodSource = (typeText) => {
+  const trimmed = typeText.trim();
+  if (!trimmed) return null;
+  const synthetic = `type __X = ${trimmed};`;
+  const source = ts2.createSourceFile("__zod.ts", synthetic, ts2.ScriptTarget.Latest, true);
+  const statement = source.statements[0];
+  if (!statement || !ts2.isTypeAliasDeclaration(statement)) return null;
+  return convertTypeNode(statement.type);
+};
+
+// src/typeMap/emitterArtifacts.ts
+var buildImportStatements = ({
+  namedImports: namedImports2,
+  defaultImports: defaultImports2
+}) => {
+  let importStatements = "";
+  for (const [importPath, types] of namedImports2) {
+    importStatements += `import { ${[...types].join(", ")} } from "${importPath}";
+`;
+  }
+  for (const [importPath, defaultName] of defaultImports2) {
+    importStatements += `import ${defaultName} from "${importPath}";
+`;
+  }
+  return importStatements;
+};
+var splitVersionedKey = (value) => {
+  const [name, version] = value.split("@");
+  return { name: name ?? "", version: version ?? "v1" };
+};
+var writeFileIfChanged = (filePath, content) => {
+  if (fs3.existsSync(filePath)) {
+    const currentContent = fs3.readFileSync(filePath, "utf8");
+    if (currentContent === content) {
+      return false;
+    }
+  }
+  fs3.writeFileSync(filePath, content, "utf8");
+  return true;
+};
+var indentStr = (str, indentText) => {
+  return str.split("\n").map((line, i) => i === 0 ? line : indentText + line).join("\n");
+};
+var validateGeneratedTypeIdentifiers = (content) => {
+  const sourceFile = ts3.createSourceFile("apiTypes.generated.ts", content, ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
+  const knownSymbols = /* @__PURE__ */ new Set();
+  const referencedSymbols = /* @__PURE__ */ new Set();
+  const builtIns = /* @__PURE__ */ new Set([
+    "string",
+    "number",
+    "boolean",
+    "null",
+    "undefined",
+    "unknown",
+    "any",
+    "never",
+    "void",
+    "object",
+    "bigint",
+    "symbol",
+    "Record",
+    "Partial",
+    "Required",
+    "Pick",
+    "Omit",
+    "Readonly",
+    "Exclude",
+    "Extract",
+    "NonNullable",
+    "ReturnType",
+    "Awaited",
+    "Promise",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "Array",
+    "ReadonlyArray",
+    "Date",
+    "Error",
+    "RegExp",
+    "True",
+    "False",
+    "JsonPrimitive",
+    "JsonValue",
+    "JsonObject",
+    "JsonArray"
+  ]);
+  const addDeclaredName = (name) => {
+    if (!name?.text) return;
+    knownSymbols.add(name.text);
+  };
+  const collectTypeParams = (node) => {
+    if (!("typeParameters" in node)) return;
+    const maybeTypeParameters = node.typeParameters;
+    if (!maybeTypeParameters) return;
+    for (const typeParameter of maybeTypeParameters) {
+      knownSymbols.add(typeParameter.name.text);
+    }
+  };
+  const collectKnownSymbols = (node) => {
+    if (ts3.isInferTypeNode(node)) {
+      knownSymbols.add(node.typeParameter.name.text);
+    }
+    if (ts3.isMappedTypeNode(node)) {
+      knownSymbols.add(node.typeParameter.name.text);
+    }
+    if (ts3.isImportDeclaration(node)) {
+      const importClause = node.importClause;
+      if (importClause?.name) knownSymbols.add(importClause.name.text);
+      if (importClause?.namedBindings && ts3.isNamedImports(importClause.namedBindings)) {
+        for (const importElement of importClause.namedBindings.elements) {
+          knownSymbols.add((importElement.propertyName ?? importElement.name).text);
+        }
+      }
+      if (importClause?.namedBindings && ts3.isNamespaceImport(importClause.namedBindings)) {
+        knownSymbols.add(importClause.namedBindings.name.text);
+      }
+    }
+    if (ts3.isInterfaceDeclaration(node) || ts3.isTypeAliasDeclaration(node) || ts3.isClassDeclaration(node) || ts3.isEnumDeclaration(node) || ts3.isFunctionDeclaration(node)) {
+      addDeclaredName(node.name);
+      collectTypeParams(node);
+    }
+    if (ts3.isTypeReferenceNode(node)) {
+      const typeName = node.typeName;
+      if (ts3.isIdentifier(typeName)) {
+        referencedSymbols.add(typeName.text);
+      }
+      if (ts3.isQualifiedName(typeName) && ts3.isIdentifier(typeName.left)) {
+        referencedSymbols.add(typeName.left.text);
+      }
+    }
+    ts3.forEachChild(node, collectKnownSymbols);
+  };
+  collectKnownSymbols(sourceFile);
+  const unknown = [...referencedSymbols].filter((name) => !knownSymbols.has(name) && !builtIns.has(name)).toSorted();
+  if (unknown.length > 0) {
+    throw new Error(`[TypeMapGenerator] Generated type map has unresolved type identifiers: ${unknown.join(", ")}`);
+  }
+};
+var buildTypeMapArtifacts = ({
+  typesByPage,
+  syncTypesByPage,
+  namedImports: namedImports2,
+  defaultImports: defaultImports2,
+  functionsInterface
+}) => {
+  const importStatements = buildImportStatements({ namedImports: namedImports2, defaultImports: defaultImports2 });
+  let content = `/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+/* eslint-disable @typescript-eslint/ban-types */
+
+/**
+ * Auto-generated type map for all API and Sync endpoints.
+ * Enables type-safe apiRequest and syncRequest calls.
+ */
+
+${importStatements}
+export interface Functions {
+${functionsInterface}
+};
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export interface JsonObject {
+	[key: string]: JsonValue | undefined;
+}
+export type JsonArray = JsonValue[];
+export type MaybePromise<T> = T | Promise<T>;
+
+export type StreamPayload = {
+	[key: string]: unknown;
+};
+
+export type ApiStreamEmitter<T extends StreamPayload = StreamPayload> = (payload?: T) => void | Promise<void>;
+export type SyncServerStreamEmitter<T extends StreamPayload = StreamPayload> = (payload?: T) => void | Promise<void>;
+export type SyncClientStreamEmitter<T extends StreamPayload = StreamPayload> = (payload?: T) => void | Promise<void>;
+//? Broadcast \xE2\u20AC\u201D fan-out to every socket in the receiver room (cross-instance via the Redis adapter).
+export type SyncBroadcastStreamEmitter<T extends StreamPayload = StreamPayload> = (payload?: T) => void;
+//? Targeted \xE2\u20AC\u201D emit only to the listed session tokens (each token is its own room).
+export type SyncStreamToEmitter<T extends StreamPayload = StreamPayload> = (
+	tokens: string | string[],
+	payload?: T,
+) => void;
+
+// 
+// API Type Definitions
+// 
+
+export type ApiResponse<T = unknown> =
+	| ({ status: 'success'; httpStatus?: number; APINAME?: never; [key: string]: unknown } & T)
+	| { status: 'error'; httpStatus?: number; errorCode: string; errorParams?: { key: string; value: string | number | boolean; }[]; APINAME?: never };
+
+export type ApiNetworkResponse<T = unknown> =
+	| ({ status: 'success'; httpStatus: number; APINAME?: never; [key: string]: unknown } & T)
+	| { status: 'error'; httpStatus: number; message: string; errorCode: string; errorParams?: { key: string; value: string | number | boolean; }[]; APINAME?: never };
+
+//
+// API Type Map
+//
+
+type _ProjectApiTypeMap = {
+`;
+  const sortedPages = [...typesByPage.keys()].toSorted();
+  const sortedSyncPages = [...syncTypesByPage.keys()].toSorted();
+  const docsData = { apis: {}, syncs: {} };
+  for (const pagePath of sortedPages) {
+    const apis = mustGet(typesByPage, pagePath, "typesByPage");
+    const grouped = /* @__PURE__ */ new Map();
+    docsData.apis[pagePath] = [];
+    for (const [apiKey, entry] of apis.entries()) {
+      const { name, version } = splitVersionedKey(apiKey);
+      if (!grouped.has(name)) grouped.set(name, []);
+      mustGet(grouped, name, "grouped").push({ version, entry });
+    }
+    content += `  '${pagePath}': {
+`;
+    for (const apiName of [...grouped.keys()].toSorted()) {
+      content += `    '${apiName}': {
+`;
+      for (const { version, entry } of mustGet(grouped, apiName, "grouped").toSorted((a, b) => a.version.localeCompare(b.version, void 0, { numeric: true }))) {
+        docsData.apis[pagePath].push({
+          page: pagePath,
+          name: apiName,
+          version,
+          method: entry.method,
+          input: entry.input,
+          output: entry.output,
+          stream: entry.stream,
+          rateLimit: entry.rateLimit,
+          auth: entry.auth,
+          path: pagePath === "root" ? `api/${apiName}/${version}` : `api/${pagePath}/${apiName}/${version}`,
+          ...entry.meta ? { meta: entry.meta } : {}
+        });
+        content += `      '${version}': {
+`;
+        content += `        input: ${indentStr(entry.input, "        ")};
+`;
+        content += `        output: ${indentStr(entry.output, "        ")};
+`;
+        content += `        stream: ${indentStr(entry.stream, "        ")};
+`;
+        content += `        method: '${entry.method}';
+`;
+        if (entry.rateLimit !== void 0) {
+          content += `        rateLimit: ${entry.rateLimit};
+`;
+        }
+        content += `      };
+`;
+      }
+      content += `    };
+`;
+    }
+    content += `  };
+`;
+  }
+  content += `};
+
+export interface ApiTypeMap extends _ProjectApiTypeMap {}
+
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+
+export type PagePath = keyof ApiTypeMap;
+export type ApiName<P extends PagePath> = keyof ApiTypeMap[P];
+export type ApiVersion<P extends PagePath, N extends ApiName<P>> = keyof ApiTypeMap[P][N];
+export type ApiInput<P extends PagePath, N extends ApiName<P>, V extends ApiVersion<P, N> = ApiVersion<P, N>> = ApiTypeMap[P][N][V] extends { input: infer I } ? I : never;
+export type ApiOutput<P extends PagePath, N extends ApiName<P>, V extends ApiVersion<P, N> = ApiVersion<P, N>> = ApiTypeMap[P][N][V] extends { output: infer O } ? O : never;
+export type ApiStream<P extends PagePath, N extends ApiName<P>, V extends ApiVersion<P, N> = ApiVersion<P, N>> = ApiTypeMap[P][N][V] extends { stream: infer S } ? S : never;
+export type ApiMethod<P extends PagePath, N extends ApiName<P>, V extends ApiVersion<P, N> = ApiVersion<P, N>> = ApiTypeMap[P][N][V] extends { method: infer M } ? M : never;
+
+export type FullApiPath<P extends PagePath, N extends ApiName<P>, V extends ApiVersion<P, N>> = \`api/\${P}/\${N & string}/\${V & string}\`;
+
+export const apiMethodMap: Record<string, Record<string, Record<string, HttpMethod>>> = {
+`;
+  for (const pagePath of sortedPages) {
+    const apis = mustGet(typesByPage, pagePath, "typesByPage");
+    const grouped = /* @__PURE__ */ new Map();
+    for (const [apiKey, entry] of apis.entries()) {
+      const { name, version } = splitVersionedKey(apiKey);
+      if (!grouped.has(name)) grouped.set(name, []);
+      mustGet(grouped, name, "grouped").push({ version, method: entry.method });
+    }
+    content += `  '${pagePath}': {
+`;
+    for (const apiName of [...grouped.keys()].toSorted()) {
+      content += `    '${apiName}': {`;
+      const methods = mustGet(grouped, apiName, "grouped").toSorted((a, b) => a.version.localeCompare(b.version, void 0, { numeric: true })).map((item) => ` '${item.version}': '${item.method}'`).join(",");
+      content += `${methods} },
+`;
+    }
+    content += `  },
+`;
+  }
+  content += `};
+
+export const getApiMethod = (pagePath: string, apiName: string, version: string): HttpMethod | undefined => {
+	return apiMethodMap[pagePath]?.[apiName]?.[version];
+};
+
+export interface ApiMetaEntry {
+	method: HttpMethod;
+	auth: { login: boolean; additional?: Record<string, unknown>[] };
+	rateLimit?: number | false;
+}
+
+export const apiMetaMap: Record<string, Record<string, Record<string, ApiMetaEntry>>> = {
+`;
+  for (const pagePath of sortedPages) {
+    const apis = mustGet(typesByPage, pagePath, "typesByPage");
+    const grouped = /* @__PURE__ */ new Map();
+    for (const [apiKey, entry] of apis.entries()) {
+      const { name, version } = splitVersionedKey(apiKey);
+      if (!grouped.has(name)) grouped.set(name, []);
+      mustGet(grouped, name, "grouped").push({ version, entry });
+    }
+    content += `  '${pagePath}': {
+`;
+    for (const apiName of [...grouped.keys()].toSorted()) {
+      content += `    '${apiName}': {
+`;
+      for (const { version, entry } of mustGet(grouped, apiName, "grouped").toSorted((a, b) => a.version.localeCompare(b.version, void 0, { numeric: true }))) {
+        const auth = entry.auth && typeof entry.auth === "object" ? entry.auth : { login: true };
+        const rateLimitPart = entry.rateLimit === void 0 ? "" : `, rateLimit: ${entry.rateLimit === false ? "false" : String(entry.rateLimit)}`;
+        const additionalPart = auth.additional && auth.additional.length > 0 ? `, additional: ${JSON.stringify(auth.additional)}` : "";
+        content += `      '${version}': { method: '${entry.method}', auth: { login: ${auth.login ? "true" : "false"}${additionalPart} }${rateLimitPart} },
+`;
+      }
+      content += `    },
+`;
+    }
+    content += `  },
+`;
+  }
+  content += `};
+
+export const getApiMeta = (pagePath: string, apiName: string, version: string): ApiMetaEntry | undefined => {
+	return apiMetaMap[pagePath]?.[apiName]?.[version];
+};
+
+// Sync Type Definitions
+// 
+
+export type SyncServerResponse<T = unknown> =
+	| ({ status: 'success'; [key: string]: unknown } & T)
+	| { status: 'error'; errorCode: string; errorParams?: { key: string; value: string | number | boolean; }[] };
+
+export type SyncClientResponse<T = unknown> =
+	| ({ status: 'success'; [key: string]: unknown } & T)
+	| { status: 'error'; errorCode: string; errorParams?: { key: string; value: string | number | boolean; }[] };
+
+//
+// Sync Type Map
+//
+
+type _ProjectSyncTypeMap = {
+`;
+  for (const pagePath of sortedSyncPages) {
+    const syncs = mustGet(syncTypesByPage, pagePath, "syncTypesByPage");
+    const grouped = /* @__PURE__ */ new Map();
+    docsData.syncs[pagePath] = [];
+    for (const [syncKey, entry] of syncs.entries()) {
+      const { name, version } = splitVersionedKey(syncKey);
+      if (!grouped.has(name)) grouped.set(name, []);
+      mustGet(grouped, name, "grouped").push({ version, entry });
+    }
+    content += `  '${pagePath}': {
+`;
+    for (const syncName of [...grouped.keys()].toSorted()) {
+      content += `    '${syncName}': {
+`;
+      for (const { version, entry } of mustGet(grouped, syncName, "grouped").toSorted((a, b) => a.version.localeCompare(b.version, void 0, { numeric: true }))) {
+        docsData.syncs[pagePath].push({
+          page: pagePath,
+          name: syncName,
+          version,
+          clientInput: entry.clientInput,
+          serverOutput: entry.serverOutput,
+          clientOutput: entry.clientOutput,
+          serverStream: entry.serverStream,
+          clientStream: entry.clientStream,
+          path: pagePath === "root" ? `sync/${syncName}/${version}` : `sync/${pagePath}/${syncName}/${version}`,
+          ...entry.meta ? { meta: entry.meta } : {}
+        });
+        content += `      '${version}': {
+`;
+        content += `        clientInput: ${indentStr(entry.clientInput, "        ")};
+`;
+        content += `        serverOutput: ${indentStr(entry.serverOutput, "        ")};
+`;
+        content += `        clientOutput: ${indentStr(entry.clientOutput, "        ")};
+`;
+        content += `        serverStream: ${indentStr(entry.serverStream, "        ")};
+`;
+        content += `        clientStream: ${indentStr(entry.clientStream, "        ")};
+`;
+        content += `      };
+`;
+      }
+      content += `    };
+`;
+    }
+    content += `  };
+`;
+  }
+  content += `};
+
+export interface SyncTypeMap extends _ProjectSyncTypeMap {}
+
+export type SyncPagePath = keyof SyncTypeMap;
+export type SyncName<P extends SyncPagePath> = keyof SyncTypeMap[P];
+export type SyncVersion<P extends SyncPagePath, N extends SyncName<P>> = keyof SyncTypeMap[P][N];
+export type SyncClientInput<P extends SyncPagePath, N extends SyncName<P>, V extends SyncVersion<P, N> = SyncVersion<P, N>> = SyncTypeMap[P][N][V] extends { clientInput: infer C } ? C : never;
+export type SyncServerOutput<P extends SyncPagePath, N extends SyncName<P>, V extends SyncVersion<P, N> = SyncVersion<P, N>> = SyncTypeMap[P][N][V] extends { serverOutput: infer S } ? S : never;
+export type SyncClientOutput<P extends SyncPagePath, N extends SyncName<P>, V extends SyncVersion<P, N> = SyncVersion<P, N>> = SyncTypeMap[P][N][V] extends { clientOutput: infer O } ? O : never;
+export type SyncServerStream<P extends SyncPagePath, N extends SyncName<P>, V extends SyncVersion<P, N> = SyncVersion<P, N>> = SyncTypeMap[P][N][V] extends { serverStream: infer S } ? S : never;
+export type SyncClientStream<P extends SyncPagePath, N extends SyncName<P>, V extends SyncVersion<P, N> = SyncVersion<P, N>> = SyncTypeMap[P][N][V] extends { clientStream: infer O } ? O : never;
+
+export type FullSyncPath<P extends SyncPagePath, N extends SyncName<P>, V extends SyncVersion<P, N>> = \`sync/\${P}/\${N & string}/\${V & string}\`;
+
+//
+// Type-level augmentation \xE2\u20AC\u201D merges the project's concrete ApiTypeMap / SyncTypeMap
+// into the @luckystack/core/typemap stub-declaration module so framework code
+// (apiRequest / syncRequest) sees the project routes without deep-relative
+// imports. Augmenting the module that DECLARES the stubs (not the re-exporting
+// barrel) is what makes the merge land for consumers installing the built dist.
+//
+declare module '@luckystack/core/typemap' {
+	interface ApiTypeMap extends _ProjectApiTypeMap {}
+	interface SyncTypeMap extends _ProjectSyncTypeMap {}
+}
+`;
+  validateGeneratedTypeIdentifiers(content);
+  const schemasContent = buildSchemasContent({ typesByPage });
+  return { content, docsData, schemasContent };
+};
+var buildSchemasContent = ({
+  typesByPage
+}) => {
+  const sortedPages = [...typesByPage.keys()].toSorted();
+  let body = `/* eslint-disable */
+//? Auto-generated Zod schemas for every API input. Driven by the same walk
+//? as apiTypes.generated.ts; see @luckystack/devkit/src/typeMap/zodEmitter.ts
+//? for the TS-AST \xE2\u2020\u2019 Zod converter. Types that fall outside the converter's
+//? scope emit \`z.any()\` with a TODO comment.
+
+import { z } from 'zod';
+
+export const apiInputSchemas: Record<string, Record<string, Record<string, z.ZodTypeAny>>> = {
+`;
+  for (const pagePath of sortedPages) {
+    const apis = mustGet(typesByPage, pagePath, "typesByPage");
+    const grouped = /* @__PURE__ */ new Map();
+    for (const [apiKey, entry] of apis.entries()) {
+      const { name, version } = splitVersionedKey(apiKey);
+      if (!grouped.has(name)) grouped.set(name, []);
+      mustGet(grouped, name, "grouped").push({ version, entry });
+    }
+    body += `  '${pagePath}': {
+`;
+    for (const apiName of [...grouped.keys()].toSorted()) {
+      body += `    '${apiName}': {
+`;
+      for (const { version, entry } of mustGet(grouped, apiName, "grouped").toSorted(
+        (a, b) => a.version.localeCompare(b.version, void 0, { numeric: true })
+      )) {
+        const schemaSrc = typeTextToZodSource(entry.input) ?? "z.any() /* unparseable input type */";
+        body += `      '${version}': ${schemaSrc},
+`;
+      }
+      body += `    },
+`;
+    }
+    body += `  },
+`;
+  }
+  body += `};
+
+export const getApiInputSchema = (
+	pagePath: string,
+	apiName: string,
+	version: string,
+): z.ZodTypeAny | undefined => {
+	return apiInputSchemas[pagePath]?.[apiName]?.[version];
+};
+`;
+  return body;
+};
+var writeTypeMapArtifacts = ({
+  content,
+  docsData,
+  schemasContent
+}) => {
+  try {
+    const outputPath = getGeneratedSocketTypesPath();
+    const hasUpdatedTypeMap = writeFileIfChanged(outputPath, content);
+    if (hasUpdatedTypeMap) {
+      console.log("[TypeMapGenerator] Generated apiTypes.generated.ts");
+    }
+    if (schemasContent !== void 0) {
+      const hasUpdatedSchemas = writeFileIfChanged(getGeneratedApiSchemasPath(), schemasContent);
+      if (hasUpdatedSchemas) {
+        console.log("[TypeMapGenerator] Generated apiInputSchemas.generated.ts");
+      }
+    }
+    const docsPath = getGeneratedApiDocsPath();
+    const docsDir = path3.dirname(docsPath);
+    if (!fs3.existsSync(docsDir)) {
+      fs3.mkdirSync(docsDir, { recursive: true });
+    }
+    const docsContent = JSON.stringify(docsData, null, 2);
+    const hasUpdatedDocs = writeFileIfChanged(docsPath, docsContent);
+    if (hasUpdatedDocs) {
+      console.log("[TypeMapGenerator] Generated apiDocs.generated.json");
+    }
+  } catch (error) {
+    console.error("[TypeMapGenerator] Error writing type map or docs:", error);
+  }
+};
+
+// src/typeMap/extractors.ts
+import * as ts5 from "typescript";
+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";
+var cachedProgram = null;
+var getServerProgram = () => {
+  if (cachedProgram) return cachedProgram;
+  const tsconfigPath = ts4.findConfigFile(ROOT_DIR2, ts4.sys.fileExists, "tsconfig.server.json");
+  if (!tsconfigPath) throw new Error("[TypeProgram] tsconfig.server.json not found");
+  const { config } = ts4.readConfigFile(tsconfigPath, ts4.sys.readFile);
+  const { options, fileNames } = ts4.parseJsonConfigFileContent(
+    config,
+    ts4.sys,
+    path4.dirname(tsconfigPath)
+  );
+  cachedProgram = ts4.createProgram(fileNames, options);
+  return cachedProgram;
+};
+var invalidateProgramCache = () => {
+  cachedProgram = null;
+};
+var DEPTH_LIMIT = 12;
+var JSON_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "Json",
+  "JsonValue",
+  "JsonObject",
+  "JsonArray",
+  "InputJsonValue",
+  "InputJsonObject",
+  "InputJsonArray"
+]);
+var SKIP_EXPANSION = /* @__PURE__ */ new Set([
+  "Promise",
+  "Map",
+  "WeakMap",
+  "Set",
+  "WeakSet",
+  "Error",
+  "Date",
+  "RegExp",
+  "Buffer",
+  "ArrayBuffer",
+  "ReadonlyArray"
+]);
+var isJsonLikeType = (type, checker) => {
+  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);
+};
+var getLiteralTypeFromExpression = (expression, checker, depth) => {
+  if (ts4.isParenthesizedExpression(expression)) {
+    return getLiteralTypeFromExpression(expression.expression, checker, depth);
+  }
+  if (ts4.isAsExpression(expression) || ts4.isTypeAssertionExpression(expression)) {
+    return getLiteralTypeFromExpression(expression.expression, checker, depth);
+  }
+  if (expression.kind === ts4.SyntaxKind.TrueKeyword) return "true";
+  if (expression.kind === ts4.SyntaxKind.FalseKeyword) return "false";
+  if (expression.kind === ts4.SyntaxKind.NullKeyword) return "null";
+  if (ts4.isStringLiteral(expression) || ts4.isNoSubstitutionTemplateLiteral(expression)) {
+    return `'${expression.text.replaceAll("\\", "\\\\").replaceAll("'", String.raw`\'`)}'`;
+  }
+  if (ts4.isNumericLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts4.isPrefixUnaryExpression(expression) && expression.operator === ts4.SyntaxKind.MinusToken && ts4.isNumericLiteral(expression.operand)) {
+    return `-${expression.operand.text}`;
+  }
+  if (ts4.isIdentifier(expression)) {
+    const identifierType = checker.getTypeAtLocation(expression);
+    const isLiteralType = (identifierType.flags & (ts4.TypeFlags.StringLiteral | ts4.TypeFlags.NumberLiteral | ts4.TypeFlags.BooleanLiteral | ts4.TypeFlags.Null | ts4.TypeFlags.Undefined)) !== 0;
+    if (isLiteralType || identifierType.isUnion()) {
+      const expanded = expandTypeDetailed(identifierType, checker, depth).text;
+      if (expanded.includes("'") || /\btrue\b|\bfalse\b|\bnull\b|\bundefined\b/.test(expanded)) {
+        return expanded;
+      }
+    }
+  }
+  return null;
+};
+var getLiteralTypeFromPropertySymbol = (symbol, checker, depth) => {
+  const declarations = symbol.declarations ?? [];
+  for (const declaration of declarations) {
+    if (ts4.isPropertyAssignment(declaration)) {
+      const literal = getLiteralTypeFromExpression(declaration.initializer, checker, depth);
+      if (literal) return literal;
+    }
+    if (ts4.isShorthandPropertyAssignment(declaration)) {
+      const literal = getLiteralTypeFromExpression(declaration.name, checker, depth);
+      if (literal) return literal;
+    }
+  }
+  return null;
+};
+var normalizeImportPath = (targetFilePath) => {
+  const fromDir = path4.join(ROOT_DIR2, "src", "_sockets");
+  const from = fromDir.replaceAll("\\", "/");
+  const to = targetFilePath.replaceAll("\\", "/");
+  const normalized = path4.posix.relative(from, to).replaceAll("\\", "/");
+  const withoutExtension = normalized.replace(/(\.d)?\.(ts|tsx|js|jsx)$/i, "");
+  if (withoutExtension.startsWith(".")) return withoutExtension;
+  return `./${withoutExtension}`;
+};
+var mergeUnresolvedSymbols = (left, right) => {
+  const merged = [...left];
+  const seen = new Set(merged.map((symbol) => `${symbol.name}|${symbol.importPath ?? ""}|${symbol.sourceFile ?? ""}`));
+  for (const symbol of right) {
+    const key = `${symbol.name}|${symbol.importPath ?? ""}|${symbol.sourceFile ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(symbol);
+  }
+  return merged;
+};
+var collectTypeSymbolFallback = (type) => {
+  const symbol = type.aliasSymbol ?? type.getSymbol();
+  if (!symbol) return [];
+  const name = symbol.getName();
+  if (!name || name.startsWith("__")) return [];
+  const declaration = symbol.declarations?.[0];
+  if (!declaration) return [{ name }];
+  const sourceFile = declaration.getSourceFile().fileName;
+  if (!sourceFile || sourceFile.includes("/node_modules/") || sourceFile.includes("\\node_modules\\")) {
+    return [{ name }];
+  }
+  return [{
+    name,
+    sourceFile,
+    importPath: normalizeImportPath(sourceFile)
+  }];
+};
+var expandTypeDetailed = (type, checker, depth = 0, state) => {
+  const expandState = state ?? { stackTypeIds: /* @__PURE__ */ new Set() };
+  const typeId = type.id;
+  if (typeId !== void 0) {
+    if (expandState.stackTypeIds.has(typeId)) {
+      return {
+        text: checker.typeToString(type),
+        unresolvedSymbols: collectTypeSymbolFallback(type)
+      };
+    }
+    expandState.stackTypeIds.add(typeId);
+  }
+  try {
+    if (depth > DEPTH_LIMIT) {
+      return {
+        text: checker.typeToString(type),
+        unresolvedSymbols: collectTypeSymbolFallback(type)
+      };
+    }
+    if (isJsonLikeType(type, checker)) return { text: "JsonValue", unresolvedSymbols: [] };
+    if (type.isStringLiteral()) return { text: `'${type.value.replaceAll("\\", "\\\\").replaceAll("'", String.raw`\'`)}'`, unresolvedSymbols: [] };
+    if (type.isNumberLiteral()) return { text: String(type.value), unresolvedSymbols: [] };
+    if (type.flags & (ts4.TypeFlags.String | ts4.TypeFlags.Number | ts4.TypeFlags.Boolean | ts4.TypeFlags.BooleanLiteral | ts4.TypeFlags.Undefined | ts4.TypeFlags.Null | ts4.TypeFlags.Any | ts4.TypeFlags.Unknown | ts4.TypeFlags.Never | ts4.TypeFlags.Void)) {
+      return { text: checker.typeToString(type), unresolvedSymbols: [] };
+    }
+    if (type.isUnion()) {
+      let unresolvedSymbols = [];
+      const expandedTypes = type.types.map((innerType) => {
+        const expanded = expandTypeDetailed(innerType, checker, depth + 1, expandState);
+        unresolvedSymbols = mergeUnresolvedSymbols(unresolvedSymbols, expanded.unresolvedSymbols);
+        return expanded.text;
+      });
+      return { text: expandedTypes.join(" | "), unresolvedSymbols };
+    }
+    if (type.isIntersection()) {
+      let unresolvedSymbols = [];
+      const expandedTypes = type.types.map((innerType) => {
+        const expanded = expandTypeDetailed(innerType, checker, depth + 1, expandState);
+        unresolvedSymbols = mergeUnresolvedSymbols(unresolvedSymbols, expanded.unresolvedSymbols);
+        return expanded.text;
+      });
+      return { text: expandedTypes.join(" & "), unresolvedSymbols };
+    }
+    if (type.flags & ts4.TypeFlags.Object) {
+      const objectType = type;
+      if (objectType.objectFlags & ts4.ObjectFlags.Tuple) {
+        const typeArgs = checker.getTypeArguments(objectType);
+        let unresolvedSymbols = [];
+        const tupleTypes = typeArgs.map((innerType) => {
+          const expanded = expandTypeDetailed(innerType, checker, depth + 1, expandState);
+          unresolvedSymbols = mergeUnresolvedSymbols(unresolvedSymbols, expanded.unresolvedSymbols);
+          return expanded.text;
+        });
+        return { text: `[${tupleTypes.join(", ")}]`, unresolvedSymbols };
+      }
+      if (objectType.objectFlags & ts4.ObjectFlags.Reference) {
+        const refType = objectType;
+        const targetName = refType.target?.symbol?.name ?? "";
+        if (targetName === "Array" || targetName === "ReadonlyArray") {
+          const typeArgs = checker.getTypeArguments(refType);
+          const firstArg = typeArgs[0];
+          if (firstArg) {
+            const expanded = expandTypeDetailed(firstArg, checker, depth + 1, expandState);
+            const elementType = /\s[|&]\s/.test(expanded.text) ? `(${expanded.text})` : expanded.text;
+            return {
+              text: `${elementType}[]`,
+              unresolvedSymbols: expanded.unresolvedSymbols
+            };
+          }
+        }
+        if (SKIP_EXPANSION.has(targetName)) {
+          return { text: checker.typeToString(type), unresolvedSymbols: [] };
+        }
+      }
+      const symbolName = type.symbol?.name || type.aliasSymbol?.name || "";
+      if (SKIP_EXPANSION.has(symbolName)) {
+        return { text: checker.typeToString(type), unresolvedSymbols: [] };
+      }
+      const props = checker.getPropertiesOfType(type);
+      const indexInfos = checker.getIndexInfosOfType(type);
+      if (props.length > 0 || indexInfos.length > 0) {
+        const fields = [];
+        let unresolvedSymbols = [];
+        for (const prop of props) {
+          const propType = checker.getTypeOfSymbol(prop);
+          const literalType = getLiteralTypeFromPropertySymbol(prop, checker, depth + 1);
+          const isOptional = (prop.flags & ts4.SymbolFlags.Optional) !== 0;
+          if (literalType) {
+            fields.push(`${prop.name}${isOptional ? "?" : ""}: ${literalType}`);
+            continue;
+          }
+          const expandedProp = expandTypeDetailed(propType, checker, depth + 1, expandState);
+          unresolvedSymbols = mergeUnresolvedSymbols(unresolvedSymbols, expandedProp.unresolvedSymbols);
+          fields.push(`${prop.name}${isOptional ? "?" : ""}: ${expandedProp.text}`);
+        }
+        for (const indexInfo of indexInfos) {
+          const keyType = expandTypeDetailed(indexInfo.keyType, checker, depth + 1, expandState);
+          const valueType = expandTypeDetailed(indexInfo.type, checker, depth + 1, expandState);
+          unresolvedSymbols = mergeUnresolvedSymbols(unresolvedSymbols, keyType.unresolvedSymbols);
+          unresolvedSymbols = mergeUnresolvedSymbols(unresolvedSymbols, valueType.unresolvedSymbols);
+          fields.push(`[key: ${keyType.text}]: ${valueType.text}`);
+        }
+        const indent = "  ".repeat(depth + 1);
+        const outerIndent = "  ".repeat(depth);
+        return {
+          text: `{
+${indent}${fields.join(`;
+${indent}`)}
+${outerIndent}}`,
+          unresolvedSymbols
+        };
+      }
+      return { text: "{ }", unresolvedSymbols: [] };
+    }
+    return {
+      text: checker.typeToString(type),
+      unresolvedSymbols: collectTypeSymbolFallback(type)
+    };
+  } finally {
+    if (typeId !== void 0) {
+      expandState.stackTypeIds.delete(typeId);
+    }
+  }
+};
+var expandType = (type, checker, depth = 0) => {
+  return expandTypeDetailed(type, checker, depth).text;
+};
+
+// src/typeMap/extractors.ts
+import { ROOT_DIR as ROOT_DIR3 } 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",
+  "Number",
+  "Boolean",
+  "Object",
+  "Array",
+  "ReadonlyArray",
+  "Promise",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Date",
+  "RegExp",
+  "Error",
+  "Record",
+  "Partial",
+  "Required",
+  "Pick",
+  "Omit",
+  "Readonly",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "ReturnType",
+  "Awaited",
+  "JsonValue",
+  "JsonObject",
+  "JsonArray",
+  "JsonPrimitive"
+]);
+var normalizeImportPath2 = (targetFilePath) => {
+  const fromDir = path5.join(ROOT_DIR3, "src", "_sockets");
+  const from = fromDir.replaceAll("\\", "/");
+  const to = targetFilePath.replaceAll("\\", "/");
+  const normalized = path5.posix.relative(from, to).replaceAll("\\", "/");
+  const withoutExtension = normalized.replace(/(\.d)?\.(ts|tsx|js|jsx)$/i, "");
+  if (withoutExtension.startsWith(".")) return withoutExtension;
+  return `./${withoutExtension}`;
+};
+var mergeUnresolvedSymbols2 = (left, right) => {
+  const merged = [...left];
+  const seen = new Set(merged.map((symbol) => `${symbol.name}|${symbol.importPath ?? ""}|${symbol.sourceFile ?? ""}`));
+  for (const symbol of right) {
+    const key = `${symbol.name}|${symbol.importPath ?? ""}|${symbol.sourceFile ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(symbol);
+  }
+  return merged;
+};
+var collectFallbackSymbolsFromTypeText = (typeText, scopeNode, checker) => {
+  const names = new Set((typeText.match(TYPE_NAME_PATTERN) ?? []).filter((name) => !KNOWN_GLOBAL_TYPE_NAMES.has(name)));
+  const symbolsInScope = checker.getSymbolsInScope(
+    scopeNode,
+    ts5.SymbolFlags.TypeAlias | ts5.SymbolFlags.Interface | ts5.SymbolFlags.Class | ts5.SymbolFlags.Enum | ts5.SymbolFlags.Alias
+  );
+  const unresolvedSymbols = [];
+  for (const name of names) {
+    const localSymbol = symbolsInScope.find((symbol) => symbol.name === name);
+    if (!localSymbol) continue;
+    const targetSymbol = (localSymbol.flags & ts5.SymbolFlags.Alias) === 0 ? localSymbol : checker.getAliasedSymbol(localSymbol);
+    const declaration = targetSymbol.declarations?.[0];
+    if (!declaration) {
+      unresolvedSymbols.push({ name });
+      continue;
+    }
+    const sourceFile = declaration.getSourceFile().fileName;
+    if (!sourceFile || sourceFile.includes("/node_modules/") || sourceFile.includes("\\node_modules\\")) {
+      continue;
+    }
+    unresolvedSymbols.push({
+      name,
+      sourceFile,
+      importPath: normalizeImportPath2(sourceFile)
+    });
+  }
+  return unresolvedSymbols;
+};
+var findInterface = (sourceFile, name) => {
+  for (const stmt of sourceFile.statements) {
+    if (ts5.isInterfaceDeclaration(stmt) && stmt.name.text === name) return stmt;
+  }
+  return null;
+};
+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) {
+      return checker.getTypeFromTypeNode(member.type);
+    }
+  }
+  return null;
+};
+var findMainFunction = (sourceFile) => {
+  for (const stmt of sourceFile.statements) {
+    if (ts5.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (ts5.isIdentifier(decl.name) && decl.name.text === "main" && decl.initializer && (ts5.isArrowFunction(decl.initializer) || ts5.isFunctionExpression(decl.initializer))) {
+          return decl.initializer;
+        }
+      }
+    }
+    if (ts5.isFunctionDeclaration(stmt) && stmt.name?.text === "main") {
+      return stmt;
+    }
+  }
+  return null;
+};
+var collectReturnObjectTypeDetails = (funcNode, checker) => {
+  const types = [];
+  let unresolvedSymbols = [];
+  const visit = (node) => {
+    if (ts5.isReturnStatement(node) && node.expression && ts5.isObjectLiteralExpression(node.expression)) {
+      const type = checker.getTypeAtLocation(node.expression);
+      const expanded = expandTypeDetailed(type, checker);
+      types.push(expanded.text);
+      unresolvedSymbols = mergeUnresolvedSymbols2(unresolvedSymbols, expanded.unresolvedSymbols);
+      unresolvedSymbols = mergeUnresolvedSymbols2(
+        unresolvedSymbols,
+        collectFallbackSymbolsFromTypeText(expanded.text, node.expression, checker)
+      );
+    }
+    if (!ts5.isArrowFunction(node) && !ts5.isFunctionExpression(node) && !ts5.isFunctionDeclaration(node)) {
+      ts5.forEachChild(node, visit);
+    }
+  };
+  ts5.forEachChild(funcNode, visit);
+  return { text: unionTypes(types), unresolvedSymbols };
+};
+var STREAM_EMIT_NAMES = /* @__PURE__ */ new Set(["stream", "broadcastStream", "streamTo"]);
+var collectStreamCallPayloadTypeDetails = (funcNode, checker) => {
+  const types = [];
+  let unresolvedSymbols = [];
+  const visit = (node) => {
+    if (ts5.isCallExpression(node) && ts5.isIdentifier(node.expression) && STREAM_EMIT_NAMES.has(node.expression.text)) {
+      const callName = node.expression.text;
+      const payloadIndex = callName === "streamTo" ? 1 : 0;
+      const payloadArg = node.arguments[payloadIndex];
+      if (payloadArg) {
+        const argType = checker.getTypeAtLocation(payloadArg);
+        const nonNullableArgType = checker.getNonNullableType(argType);
+        const expanded = expandTypeDetailed(nonNullableArgType, checker);
+        if (expanded.text.trim().length > 0) {
+          types.push(expanded.text);
+        }
+        unresolvedSymbols = mergeUnresolvedSymbols2(unresolvedSymbols, expanded.unresolvedSymbols);
+        unresolvedSymbols = mergeUnresolvedSymbols2(
+          unresolvedSymbols,
+          collectFallbackSymbolsFromTypeText(expanded.text, payloadArg, checker)
+        );
+      }
+    }
+    if (!ts5.isArrowFunction(node) && !ts5.isFunctionExpression(node) && !ts5.isFunctionDeclaration(node)) {
+      ts5.forEachChild(node, visit);
+    }
+  };
+  ts5.forEachChild(funcNode, visit);
+  return { text: unionTypes(types), unresolvedSymbols };
+};
+var unionTypes = (types) => {
+  const unique = [...new Set(types)];
+  return unique.length > 0 ? unique.join(" | ") : "";
+};
+var getInputTypeFromFile = (filePath) => {
+  return getInputTypeDetailsFromFile(filePath).text;
+};
+var getInputTypeDetailsFromFile = (filePath) => {
+  const DEFAULT = "{ }";
+  try {
+    const program = getServerProgram();
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) return { text: DEFAULT, unresolvedSymbols: [] };
+    const checker = program.getTypeChecker();
+    const iface = findInterface(sourceFile, "ApiParams");
+    if (!iface) return { text: DEFAULT, unresolvedSymbols: [] };
+    const dataType = getInterfacePropertyType(iface, "data", checker);
+    if (!dataType) return { text: DEFAULT, unresolvedSymbols: [] };
+    const expanded = expandTypeDetailed(dataType, checker);
+    return { text: expanded.text || DEFAULT, unresolvedSymbols: expanded.unresolvedSymbols };
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error extracting input type from ${filePath}:`, error);
+    return { text: DEFAULT, unresolvedSymbols: [] };
+  }
+};
+var getApiStreamPayloadTypeDetailsFromFile = (filePath) => {
+  const DEFAULT = "never";
+  try {
+    const program = getServerProgram();
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) return { text: DEFAULT, unresolvedSymbols: [] };
+    const checker = program.getTypeChecker();
+    const mainFn = findMainFunction(sourceFile);
+    if (!mainFn) return { text: DEFAULT, unresolvedSymbols: [] };
+    const details = collectStreamCallPayloadTypeDetails(mainFn, checker);
+    return { text: details.text || DEFAULT, unresolvedSymbols: details.unresolvedSymbols };
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error extracting API stream payload type from ${filePath}:`, error);
+    return { text: DEFAULT, unresolvedSymbols: [] };
+  }
+};
+var getOutputTypeDetailsFromFile = (filePath) => {
+  const DEFAULT = "{ status: string }";
+  try {
+    const program = getServerProgram();
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) return { text: DEFAULT, unresolvedSymbols: [] };
+    const checker = program.getTypeChecker();
+    const mainFn = findMainFunction(sourceFile);
+    if (!mainFn) return { text: DEFAULT, unresolvedSymbols: [] };
+    const details = collectReturnObjectTypeDetails(mainFn, checker);
+    return { text: details.text || DEFAULT, unresolvedSymbols: details.unresolvedSymbols };
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error extracting output type from ${filePath}:`, error);
+    return { text: DEFAULT, unresolvedSymbols: [] };
+  }
+};
+var getSyncClientDataType = (filePath) => {
+  return getSyncClientDataTypeDetailsFromFile(filePath).text;
+};
+var getSyncClientDataTypeDetailsFromFile = (filePath) => {
+  const DEFAULT = "{ }";
+  try {
+    const program = getServerProgram();
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) return { text: DEFAULT, unresolvedSymbols: [] };
+    const checker = program.getTypeChecker();
+    const iface = findInterface(sourceFile, "SyncParams");
+    if (!iface) return { text: DEFAULT, unresolvedSymbols: [] };
+    const dataType = getInterfacePropertyType(iface, "clientInput", checker) ?? getInterfacePropertyType(iface, "clientData", checker);
+    if (!dataType) return { text: DEFAULT, unresolvedSymbols: [] };
+    const expanded = expandTypeDetailed(dataType, checker);
+    return { text: expanded.text || DEFAULT, unresolvedSymbols: expanded.unresolvedSymbols };
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error extracting sync clientData type from ${filePath}:`, error);
+    return { text: DEFAULT, unresolvedSymbols: [] };
+  }
+};
+var getSyncServerStreamPayloadTypeDetailsFromFile = (filePath) => {
+  const DEFAULT = "never";
+  try {
+    const program = getServerProgram();
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) return { text: DEFAULT, unresolvedSymbols: [] };
+    const checker = program.getTypeChecker();
+    const mainFn = findMainFunction(sourceFile);
+    if (!mainFn) return { text: DEFAULT, unresolvedSymbols: [] };
+    const details = collectStreamCallPayloadTypeDetails(mainFn, checker);
+    return { text: details.text || DEFAULT, unresolvedSymbols: details.unresolvedSymbols };
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error extracting sync server stream payload type from ${filePath}:`, error);
+    return { text: DEFAULT, unresolvedSymbols: [] };
+  }
+};
+var getSyncServerOutputTypeDetailsFromFile = (filePath) => {
+  const DEFAULT = "{ status: string }";
+  try {
+    const program = getServerProgram();
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) return { text: DEFAULT, unresolvedSymbols: [] };
+    const checker = program.getTypeChecker();
+    const mainFn = findMainFunction(sourceFile);
+    if (!mainFn) return { text: DEFAULT, unresolvedSymbols: [] };
+    const details = collectReturnObjectTypeDetails(mainFn, checker);
+    return { text: details.text || DEFAULT, unresolvedSymbols: details.unresolvedSymbols };
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error extracting sync serverOutput type from ${filePath}:`, error);
+    return { text: DEFAULT, unresolvedSymbols: [] };
+  }
+};
+var getSyncClientStreamPayloadTypeDetailsFromFile = (filePath) => {
+  const DEFAULT = "never";
+  try {
+    const program = getServerProgram();
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) return { text: DEFAULT, unresolvedSymbols: [] };
+    const checker = program.getTypeChecker();
+    const mainFn = findMainFunction(sourceFile);
+    if (!mainFn) return { text: DEFAULT, unresolvedSymbols: [] };
+    const details = collectStreamCallPayloadTypeDetails(mainFn, checker);
+    return { text: details.text || DEFAULT, unresolvedSymbols: details.unresolvedSymbols };
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error extracting sync client stream payload type from ${filePath}:`, error);
+    return { text: DEFAULT, unresolvedSymbols: [] };
+  }
+};
+var getSyncClientOutputTypeDetailsFromFile = (filePath) => {
+  const DEFAULT = "{ }";
+  try {
+    const program = getServerProgram();
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) return { text: DEFAULT, unresolvedSymbols: [] };
+    const checker = program.getTypeChecker();
+    const mainFn = findMainFunction(sourceFile);
+    if (!mainFn) return { text: DEFAULT, unresolvedSymbols: [] };
+    const details = collectReturnObjectTypeDetails(mainFn, checker);
+    return { text: details.text || DEFAULT, unresolvedSymbols: details.unresolvedSymbols };
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error extracting sync clientOutput type from ${filePath}:`, error);
+    return { text: DEFAULT, unresolvedSymbols: [] };
+  }
+};
+
+// src/typeMap/functionsMeta.ts
+import * as ts7 from "typescript";
+import fs4 from "fs";
+import path7 from "path";
+
+// src/typeMap/typeContext.ts
+import * as ts6 from "typescript";
+import path6 from "path";
+import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath2 } from "@luckystack/core";
+var toGeneratedImportPath = (source, filePath) => {
+  if (!source.startsWith(".")) return source;
+  const outputDir = path6.dirname(getGeneratedSocketTypesPath2());
+  const absoluteSource = path6.resolve(path6.dirname(filePath), source);
+  let relPath = path6.relative(outputDir, absoluteSource).replaceAll("\\", "/");
+  relPath = relPath.replace(/\.tsx?$/, "");
+  if (!relPath.startsWith(".")) relPath = `./${relPath}`;
+  return relPath;
+};
+var parseFileTypeContext = (content) => {
+  const availableExports = /* @__PURE__ */ new Set();
+  const fileImports = /* @__PURE__ */ new Map();
+  const sourceFile = ts6.createSourceFile(
+    "__temp__.ts",
+    content,
+    ts6.ScriptTarget.Latest,
+    true
+  );
+  for (const statement of sourceFile.statements) {
+    if (ts6.isInterfaceDeclaration(statement) || ts6.isTypeAliasDeclaration(statement) || ts6.isClassDeclaration(statement) || ts6.isEnumDeclaration(statement)) {
+      const hasExport = statement.modifiers?.some((m) => m.kind === ts6.SyntaxKind.ExportKeyword);
+      if (hasExport && statement.name) {
+        availableExports.add(statement.name.text);
+      }
+      continue;
+    }
+    if (!ts6.isImportDeclaration(statement)) continue;
+    const moduleSpecifier = statement.moduleSpecifier;
+    if (!ts6.isStringLiteral(moduleSpecifier)) continue;
+    const source = moduleSpecifier.text;
+    const importClause = statement.importClause;
+    if (!importClause) continue;
+    if (importClause.name) {
+      fileImports.set(importClause.name.text, { source, isDefault: true });
+    }
+    const namedBindings = importClause.namedBindings;
+    if (!namedBindings) continue;
+    if (ts6.isNamespaceImport(namedBindings)) {
+      fileImports.set(namedBindings.name.text, { source, isDefault: true });
+      continue;
+    }
+    if (ts6.isNamedImports(namedBindings)) {
+      for (const specifier of namedBindings.elements) {
+        const localName = specifier.name.text;
+        const originalName = specifier.propertyName?.text ?? localName;
+        fileImports.set(localName, { source, isDefault: false, originalName });
+      }
+    }
+  }
+  return { availableExports, fileImports };
+};
+var sanitizeTypeAndCollectImports = ({
+  type,
+  filePath,
+  availableExports,
+  fileImports,
+  collectors,
+  knownGenerics = /* @__PURE__ */ new Set()
+}) => {
+  const { namedImports: namedImports2, defaultImports: defaultImports2 } = collectors;
+  return type.replaceAll(/\b([A-Z][a-zA-Z0-9_]*)(<[^>]+>)?(\[\])?\b/g, (match, typeName, _generics, isArray) => {
+    const builtins = ["Promise", "Date", "Function", "Array", "Record", "Partial", "Pick", "Omit", "Error", "Map", "Set", "Buffer", "Uint8Array", "Object"];
+    const existingImports = ["SessionLayout"];
+    if (builtins.includes(typeName) || existingImports.includes(typeName) || knownGenerics.has(typeName)) {
+      return match;
+    }
+    const importConfig = fileImports.get(typeName);
+    if (importConfig) {
+      const isInternal = importConfig.source.startsWith(".") || importConfig.source.startsWith("/") || importConfig.source.startsWith("src/") || importConfig.source.startsWith("shared/") || importConfig.source.startsWith("server/");
+      if (!isInternal) {
+        const importPath = toGeneratedImportPath(importConfig.source, filePath);
+        if (importConfig.isDefault) {
+          if (!defaultImports2.has(importPath) || defaultImports2.get(importPath) === typeName) {
+            defaultImports2.set(importPath, typeName);
+            return match;
+          }
+        } else {
+          getOrInit(namedImports2, importPath, () => /* @__PURE__ */ new Set()).add(importConfig.originalName ?? typeName);
+          return match;
+        }
+      }
+    }
+    if (availableExports.has(typeName)) {
+    }
+    return `any${isArray || ""}`;
+  });
+};
+
+// src/typeMap/functionsMeta.ts
+import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath3, getServerFunctionDirs } from "@luckystack/core";
+var stripDefaultValues = (params) => {
+  return params.replaceAll(/\s*=(?!>)[^,)]+/g, "");
+};
+var stripLineComments = (value) => {
+  const scanner = ts7.createScanner(
+    ts7.ScriptTarget.Latest,
+    /* skipTrivia */
+    false,
+    ts7.LanguageVariant.Standard,
+    value
+  );
+  let result = "";
+  let token = scanner.scan();
+  while (token !== ts7.SyntaxKind.EndOfFileToken) {
+    result += token === ts7.SyntaxKind.SingleLineCommentTrivia ? " " : scanner.getTokenText();
+    token = scanner.scan();
+  }
+  return result;
+};
+var normalizeInlineType = (value) => {
+  return stripLineComments(value).replaceAll(/\s+/g, " ").trim();
+};
+var simplifyInferredType = (value) => {
+  if (/\bPrismaClient\b/.test(value)) return "PrismaClient";
+  if (/\bRedis\b/.test(value)) return "Redis";
+  return value;
+};
+var getGeneratedFileDir = () => path7.dirname(getGeneratedSocketTypesPath3());
+var relativizeModuleSpecifier = (specifier, sourceFilePath) => {
+  if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+    return specifier;
+  }
+  const absolute = path7.resolve(path7.dirname(sourceFilePath), specifier);
+  const rel = path7.relative(getGeneratedFileDir(), absolute);
+  const normalized = rel.split(path7.sep).join("/");
+  return normalized.startsWith(".") ? normalized : `./${normalized}`;
+};
+var findProgramVariableDeclaration = (sourceFile, exportName) => {
+  for (const statement of sourceFile.statements) {
+    if (!ts7.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts7.isIdentifier(declaration.name) && declaration.name.text === exportName) {
+        return declaration;
+      }
+    }
+  }
+  return null;
+};
+var findProgramTypeDeclaration = (sourceFile, typeName) => {
+  for (const statement of sourceFile.statements) {
+    if (ts7.isInterfaceDeclaration(statement) && statement.name.text === typeName) return statement;
+    if (ts7.isTypeAliasDeclaration(statement) && statement.name.text === typeName) return statement;
+    if (ts7.isClassDeclaration(statement) && statement.name?.text === typeName) return statement;
+    if (ts7.isEnumDeclaration(statement) && statement.name.text === typeName) return statement;
+  }
+  return null;
+};
+var resolveLocalExportedTypes = ({
+  type,
+  availableExports,
+  checker,
+  programSource
+}) => {
+  if (availableExports.size === 0) return type;
+  let resolved = type;
+  for (const exportName of availableExports) {
+    const hasReference = new RegExp(String.raw`\b${exportName}\b`).test(resolved);
+    if (!hasReference) continue;
+    const declaration = findProgramTypeDeclaration(programSource, exportName);
+    if (!declaration) continue;
+    const declarationNode = ts7.isClassDeclaration(declaration) ? declaration.name ?? declaration : ts7.isTypeAliasDeclaration(declaration) ? declaration.type : declaration;
+    const declarationType = checker.getTypeAtLocation(declarationNode);
+    const expanded = normalizeInlineType(expandType(declarationType, checker));
+    resolved = resolved.replaceAll(new RegExp(String.raw`\b${exportName}\b`, "g"), expanded);
+  }
+  return resolved;
+};
+var findSourceVariableDeclaration = (sourceFile, exportName) => {
+  for (const statement of sourceFile.statements) {
+    if (!ts7.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts7.isIdentifier(declaration.name) && declaration.name.text === exportName) {
+        return declaration;
+      }
+    }
+  }
+  return null;
+};
+var inferValueTypeForExport = ({
+  exportName,
+  declaration,
+  rawContent,
+  filePath,
+  availableExports,
+  fileImports,
+  collectors,
+  checker,
+  programSource
+}) => {
+  const resolvedChecker = checker ?? getServerProgram().getTypeChecker();
+  const resolvedSource = programSource ?? getServerProgram().getSourceFile(filePath);
+  if (declaration.type) {
+    const rawType = normalizeInlineType(rawContent.slice(declaration.type.pos, declaration.type.end).trim());
+    const localResolvedType = resolvedSource ? resolveLocalExportedTypes({
+      type: rawType,
+      availableExports,
+      checker: resolvedChecker,
+      programSource: resolvedSource
+    }) : rawType;
+    return sanitizeTypeAndCollectImports({
+      type: localResolvedType,
+      filePath,
+      availableExports,
+      fileImports,
+      collectors
+    });
+  }
+  try {
+    if (!resolvedSource) return "any";
+    const programDeclaration = findProgramVariableDeclaration(resolvedSource, exportName);
+    if (!programDeclaration) return "any";
+    const inferred = resolvedChecker.typeToString(resolvedChecker.getTypeAtLocation(programDeclaration.name));
+    const simplified = simplifyInferredType(normalizeInlineType(inferred));
+    const localResolvedType = resolveLocalExportedTypes({
+      type: simplified,
+      availableExports,
+      checker: resolvedChecker,
+      programSource: resolvedSource
+    });
+    return sanitizeTypeAndCollectImports({
+      type: localResolvedType,
+      filePath,
+      availableExports,
+      fileImports,
+      collectors
+    });
+  } catch {
+    return "any";
+  }
+};
+var extractSignatureFromNode = (node, rawContent, filePath, availableExports, fileImports, collectors, checker, programSource) => {
+  const knownGenerics = /* @__PURE__ */ new Set();
+  if (node.typeParameters) {
+    for (const typeParam of node.typeParameters) {
+      knownGenerics.add(typeParam.name.text);
+    }
+  }
+  const isAsync = node.modifiers?.some((m) => m.kind === ts7.SyntaxKind.AsyncKeyword) ?? false;
+  const genericsClause = node.typeParameters ? `<${normalizeInlineType(rawContent.slice(node.typeParameters.pos, node.typeParameters.end))}>` : "";
+  const rawParams = node.parameters.map((p) => normalizeInlineType(rawContent.slice(p.pos, p.end).trim())).join(", ");
+  const cleanParams = normalizeInlineType(stripDefaultValues(`(${rawParams})`));
+  const localResolvedParams = checker && programSource ? resolveLocalExportedTypes({
+    type: cleanParams,
+    availableExports,
+    checker,
+    programSource
+  }) : cleanParams;
+  const sanitizedParams = sanitizeTypeAndCollectImports({
+    type: localResolvedParams,
+    filePath,
+    availableExports,
+    fileImports,
+    knownGenerics,
+    collectors
+  });
+  let returnTypeStr = isAsync ? "Promise<unknown>" : "unknown";
+  if (node.type) {
+    const rawReturnType = normalizeInlineType(rawContent.slice(node.type.pos, node.type.end).trim());
+    const localResolvedReturnType = checker && programSource ? resolveLocalExportedTypes({
+      type: rawReturnType,
+      availableExports,
+      checker,
+      programSource
+    }) : rawReturnType;
+    returnTypeStr = sanitizeTypeAndCollectImports({
+      type: localResolvedReturnType,
+      filePath,
+      availableExports,
+      fileImports,
+      knownGenerics,
+      collectors
+    });
+    if (isAsync && !returnTypeStr.startsWith("Promise")) {
+      returnTypeStr = `Promise<${returnTypeStr}>`;
+    }
+  }
+  return `${genericsClause}${sanitizedParams} => ${returnTypeStr}`;
+};
+var findSignatureForExport = (name, sourceFile, rawContent, filePath, availableExports, fileImports, collectors, checker, programSource) => {
+  for (const statement of sourceFile.statements) {
+    if (ts7.isVariableStatement(statement)) {
+      for (const decl of statement.declarationList.declarations) {
+        if (!ts7.isIdentifier(decl.name) || decl.name.text !== name || !decl.initializer) continue;
+        if (ts7.isArrowFunction(decl.initializer) || ts7.isFunctionExpression(decl.initializer)) {
+          return extractSignatureFromNode(decl.initializer, rawContent, filePath, availableExports, fileImports, collectors, checker, programSource);
+        }
+      }
+    }
+    if (ts7.isFunctionDeclaration(statement) && statement.name?.text === name) {
+      return extractSignatureFromNode(statement, rawContent, filePath, availableExports, fileImports, collectors, checker, programSource);
+    }
+  }
+  return "any";
+};
+var parseFunctionFile = (fullPath, collectors) => {
+  try {
+    const rawContent = fs4.readFileSync(fullPath, "utf8");
+    const sourceFile = ts7.createSourceFile(fullPath, rawContent, ts7.ScriptTarget.Latest, true);
+    const { availableExports, fileImports } = parseFileTypeContext(rawContent);
+    const program = getServerProgram();
+    const checker = program.getTypeChecker();
+    const programSource = program.getSourceFile(fullPath);
+    const exports = /* @__PURE__ */ new Map();
+    let defaultExportName = null;
+    let wildcardReExport = null;
+    for (const statement of sourceFile.statements) {
+      const hasExport = statement.modifiers?.some((m) => m.kind === ts7.SyntaxKind.ExportKeyword);
+      if (ts7.isVariableStatement(statement) && hasExport) {
+        for (const decl of statement.declarationList.declarations) {
+          if (ts7.isIdentifier(decl.name)) {
+            const exportName = decl.name.text;
+            if (decl.initializer && (ts7.isArrowFunction(decl.initializer) || ts7.isFunctionExpression(decl.initializer))) {
+              exports.set(exportName, findSignatureForExport(exportName, sourceFile, rawContent, fullPath, availableExports, fileImports, collectors, checker, programSource ?? void 0));
+              continue;
+            }
+            exports.set(exportName, inferValueTypeForExport({
+              exportName,
+              declaration: decl,
+              rawContent,
+              filePath: fullPath,
+              availableExports,
+              fileImports,
+              collectors,
+              checker,
+              programSource: programSource ?? void 0
+            }));
+          }
+        }
+      }
+      if (ts7.isFunctionDeclaration(statement) && hasExport && statement.name) {
+        exports.set(statement.name.text, findSignatureForExport(statement.name.text, sourceFile, rawContent, fullPath, availableExports, fileImports, collectors, checker, programSource ?? void 0));
+      }
+      if (ts7.isExportDeclaration(statement) && statement.exportClause && ts7.isNamedExports(statement.exportClause)) {
+        const moduleSpecifier = statement.moduleSpecifier && ts7.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : null;
+        for (const specifier of statement.exportClause.elements) {
+          const exportName = specifier.name.text;
+          const originalName = specifier.propertyName ? specifier.propertyName.text : exportName;
+          if (moduleSpecifier) {
+            const resolvedSpecifier = relativizeModuleSpecifier(moduleSpecifier, fullPath);
+            exports.set(exportName, `typeof import('${resolvedSpecifier}')['${originalName}']`);
+            continue;
+          }
+          const signature = findSignatureForExport(originalName, sourceFile, rawContent, fullPath, availableExports, fileImports, collectors, checker, programSource ?? void 0);
+          if (signature !== "any") {
+            exports.set(exportName, signature);
+            continue;
+          }
+          const exportDeclaration = findSourceVariableDeclaration(sourceFile, originalName);
+          if (exportDeclaration && ts7.isIdentifier(exportDeclaration.name)) {
+            exports.set(exportName, inferValueTypeForExport({
+              exportName: originalName,
+              declaration: exportDeclaration,
+              rawContent,
+              filePath: fullPath,
+              availableExports,
+              fileImports,
+              collectors,
+              checker,
+              programSource: programSource ?? void 0
+            }));
+            continue;
+          }
+          exports.set(exportName, "any");
+        }
+      }
+      if (ts7.isExportAssignment(statement) && !statement.isExportEquals && ts7.isIdentifier(statement.expression)) {
+        defaultExportName = statement.expression.text;
+      }
+      if (ts7.isExportDeclaration(statement) && !statement.exportClause && statement.moduleSpecifier && ts7.isStringLiteral(statement.moduleSpecifier)) {
+        wildcardReExport = relativizeModuleSpecifier(statement.moduleSpecifier.text, fullPath);
+      }
+    }
+    return { kind: "file", exports, defaultExportName, wildcardReExport, sourcePath: fullPath };
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error parsing functions file ${fullPath}:`, error);
+    return null;
+  }
+};
+var walkDirToIR = (dir, collectors) => {
+  if (!fs4.existsSync(dir)) return null;
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  const children = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const fullPath = path7.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const subDir = walkDirToIR(fullPath, collectors);
+      if (subDir && subDir.children.size > 0) {
+        children.set(entry.name, subDir);
+      }
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".ts")) continue;
+    const fileName = entry.name.replace(".ts", "");
+    const parsed = parseFunctionFile(fullPath, collectors);
+    if (parsed && (parsed.exports.size > 0 || parsed.defaultExportName !== null || parsed.wildcardReExport !== null)) {
+      children.set(fileName, parsed);
+    }
+  }
+  return { kind: "dir", children, sourcePath: dir };
+};
+var formatConflict = (keyPath, a, b) => {
+  const dottedKey = keyPath.join(".");
+  return `[function-injection] Conflict at \`functions.${dottedKey}\`: defined in both \`${a.sourcePath}\` and \`${b.sourcePath}\`. Delete one \u2014 \`shared/\` is the canonical location for framework re-exports.`;
+};
+var mergeIR = (target, source, prefix = []) => {
+  for (const [name, sourceChild] of source.children) {
+    const targetChild = target.children.get(name);
+    if (!targetChild) {
+      target.children.set(name, sourceChild);
+      continue;
+    }
+    const keyPath = [...prefix, name];
+    if (targetChild.kind !== sourceChild.kind) {
+      throw new Error(formatConflict(keyPath, targetChild, sourceChild));
+    }
+    if (targetChild.kind === "file" || sourceChild.kind === "file") {
+      throw new Error(formatConflict(keyPath, targetChild, sourceChild));
+    }
+    mergeIR(targetChild, sourceChild, keyPath);
+  }
+};
+var serializeIRDir = (dir, indent) => {
+  let output = "";
+  for (const [name, child] of dir.children) {
+    if (child.kind === "dir") {
+      const subOutput = serializeIRDir(child, `${indent}  `);
+      if (subOutput.trim()) {
+        output += `${indent}${name}: {
+${subOutput}${indent}};
+`;
+      }
+      continue;
+    }
+    const exportsCopy = new Map(child.exports);
+    const defaultExportName = child.defaultExportName;
+    const defaultSig = defaultExportName ? exportsCopy.get(defaultExportName) : void 0;
+    if (defaultSig && defaultExportName) exportsCopy.delete(defaultExportName);
+    if (child.wildcardReExport && exportsCopy.size === 0 && !defaultSig) {
+      output += `${indent}${name}: typeof import('${child.wildcardReExport}');
+`;
+      continue;
+    }
+    if (!defaultSig && exportsCopy.size === 1 && exportsCopy.has("default")) {
+      const reExportSig = exportsCopy.get("default");
+      if (reExportSig) {
+        exportsCopy.delete("default");
+        exportsCopy.set(name, reExportSig);
+      }
+    }
+    let fileOutput = "";
+    for (const [exportName, sig] of exportsCopy) {
+      fileOutput += `${indent}  ${exportName}: ${sig};
+`;
+    }
+    if (defaultSig && !fileOutput.trim()) {
+      fileOutput += `${indent}  ${name}: ${defaultSig};
+`;
+    }
+    if (fileOutput) {
+      output += `${indent}${name}: {
+${fileOutput}${indent}};
+`;
+    }
+  }
+  return output;
+};
+var generateServerFunctions = (collectors) => {
+  const dirs = getServerFunctionDirs();
+  if (dirs.length === 0) return "";
+  const merged = { kind: "dir", children: /* @__PURE__ */ new Map(), sourcePath: "<merged>" };
+  for (const dir of dirs) {
+    const ir = walkDirToIR(dir, collectors);
+    if (!ir) continue;
+    mergeIR(merged, ir);
+  }
+  return serializeIRDir(merged, "	");
+};
+
+// src/typeMapGenerator.ts
+import { getSrcDir } from "@luckystack/core";
+
+// src/routeNamingValidation.ts
+import fs5 from "fs";
+import path8 from "path";
+import { ROOT_DIR as ROOT_DIR4, validatePagePath } from "@luckystack/core";
+var normalizePath = (value) => {
+  return value.replaceAll("\\", "/");
+};
+var toRel = (absolute) => path8.relative(ROOT_DIR4, absolute).replaceAll("\\", "/");
+var walkRouteFiles = (dir, results = []) => {
+  const entries = fs5.readdirSync(dir, { withFileTypes: true });
+  const apiSeg = apiMarkerSegment();
+  const syncSeg = syncMarkerSegment();
+  const { ignore } = getRoutingRules();
+  for (const entry of entries) {
+    const fullPath = path8.join(dir, entry.name);
+    const normalizedFullPath = normalizePath(fullPath);
+    if (ignore(toRel(fullPath))) continue;
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      walkRouteFiles(fullPath, results);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".ts")) {
+      continue;
+    }
+    if (isRouteTestFile(entry.name)) {
+      continue;
+    }
+    if (normalizedFullPath.includes(apiSeg) || normalizedFullPath.includes(syncSeg)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+};
+var getFileRouteToken = ({
+  normalizedFilePath,
+  marker
+}) => {
+  const markerIndex = normalizedFilePath.indexOf(marker);
+  if (markerIndex === -1) {
+    return "";
+  }
+  const tokenStart = markerIndex + marker.length;
+  return normalizedFilePath.slice(tokenStart, normalizedFilePath.length - ".ts".length);
+};
+var validateRouteFilePath = (filePath) => {
+  const issues = [];
+  const normalizedFilePath = normalizePath(path8.resolve(filePath));
+  const fileName = path8.basename(filePath);
+  const apiSeg = apiMarkerSegment();
+  const syncSeg = syncMarkerSegment();
+  if (normalizedFilePath.includes(apiSeg)) {
+    const apiRouteToken = getFileRouteToken({ normalizedFilePath, marker: apiSeg });
+    if (apiRouteToken.includes("/")) {
+      issues.push({
+        kind: "api",
+        filePath: normalizedFilePath,
+        reason: 'API route token cannot contain nested path segments ("/").',
+        expected: ROUTE_NAMING_RULES.api
+      });
+    }
+    if (!isVersionedApiFileName(fileName)) {
+      issues.push({
+        kind: "api",
+        filePath: normalizedFilePath,
+        reason: "API filename does not match versioned naming.",
+        expected: ROUTE_NAMING_RULES.api
+      });
+    }
+  }
+  if (normalizedFilePath.includes(syncSeg)) {
+    const syncRouteToken = getFileRouteToken({ normalizedFilePath, marker: syncSeg });
+    if (syncRouteToken.includes("/")) {
+      issues.push({
+        kind: "sync",
+        filePath: normalizedFilePath,
+        reason: 'Sync route token cannot contain nested path segments ("/").',
+        expected: `${ROUTE_NAMING_RULES.syncServer} or ${ROUTE_NAMING_RULES.syncClient}`
+      });
+    }
+    if (!isVersionedSyncFileName(fileName)) {
+      issues.push({
+        kind: "sync",
+        filePath: normalizedFilePath,
+        reason: "Sync filename does not match versioned naming.",
+        expected: `${ROUTE_NAMING_RULES.syncServer} or ${ROUTE_NAMING_RULES.syncClient}`
+      });
+    }
+  }
+  return issues;
+};
+var resolveApiRouteKey = ({
+  srcDir,
+  filePath
+}) => {
+  const rules2 = getRoutingRules();
+  const relativePath = normalizePath(path8.relative(srcDir, filePath));
+  const segments = relativePath.split("/");
+  const apiIndex = segments.indexOf(rules2.apiMarker);
+  if (apiIndex === -1 || apiIndex === segments.length - 1) {
+    return null;
+  }
+  const pageLocation = segments.slice(0, apiIndex).join("/");
+  const apiFilePath = segments.slice(apiIndex + 1).join("/");
+  const rawApiName = apiFilePath.replace(/\.ts$/, "");
+  const versionMatch = rawApiName.match(rules2.apiVersionRegex);
+  if (!versionMatch) {
+    return null;
+  }
+  const version = `v${versionMatch[1]}`;
+  const apiName = rawApiName.replace(rules2.apiVersionRegex, "");
+  const mappedPageLocation = pageLocation || "system";
+  return `api/${mappedPageLocation}/${apiName}/${version}`;
+};
+var resolveSyncRouteKey = ({
+  srcDir,
+  filePath
+}) => {
+  const rules2 = getRoutingRules();
+  const relativePath = normalizePath(path8.relative(srcDir, filePath));
+  const segments = relativePath.split("/");
+  const syncIndex = segments.indexOf(rules2.syncMarker);
+  if (syncIndex === -1 || syncIndex === segments.length - 1) {
+    return null;
+  }
+  const pageLocation = segments.slice(0, syncIndex).join("/");
+  const syncFilePath = segments.slice(syncIndex + 1).join("/");
+  const rawSyncName = syncFilePath.replace(/\.ts$/, "");
+  const syncMatch = rawSyncName.match(rules2.syncVersionRegex);
+  if (!syncMatch) {
+    return null;
+  }
+  const kind = syncMatch[1];
+  const version = `v${syncMatch[2]}`;
+  const syncName = rawSyncName.replace(rules2.syncVersionRegex, "");
+  const routeBaseKey = pageLocation ? `sync/${pageLocation}/${syncName}/${version}` : `sync/${syncName}/${version}`;
+  return `${routeBaseKey}_${kind}`;
+};
+var collectInvalidRouteNamingIssues = (srcDir) => {
+  const allRouteFiles = walkRouteFiles(srcDir);
+  const issues = [];
+  for (const filePath of allRouteFiles) {
+    issues.push(...validateRouteFilePath(filePath));
+  }
+  return issues.toSorted((a, b) => a.filePath.localeCompare(b.filePath));
+};
+var collectDuplicateNormalizedRouteKeyIssues = (srcDir) => {
+  const allRouteFiles = walkRouteFiles(srcDir);
+  const routeKeyToFilePaths = /* @__PURE__ */ new Map();
+  const routeKeyKinds = /* @__PURE__ */ new Map();
+  const apiSeg = apiMarkerSegment();
+  const syncSeg = syncMarkerSegment();
+  for (const filePath of allRouteFiles) {
+    const normalizedFilePath = normalizePath(path8.resolve(filePath));
+    if (normalizedFilePath.includes(apiSeg)) {
+      const routeKey = resolveApiRouteKey({ srcDir, filePath });
+      if (!routeKey) {
+        continue;
+      }
+      getOrInit(routeKeyToFilePaths, routeKey, () => []).push(normalizedFilePath);
+      routeKeyKinds.set(routeKey, "api");
+      continue;
+    }
+    if (normalizedFilePath.includes(syncSeg)) {
+      const routeKey = resolveSyncRouteKey({ srcDir, filePath });
+      if (!routeKey) {
+        continue;
+      }
+      getOrInit(routeKeyToFilePaths, routeKey, () => []).push(normalizedFilePath);
+      routeKeyKinds.set(routeKey, "sync");
+    }
+  }
+  const issues = [];
+  for (const [routeKey, filePaths] of routeKeyToFilePaths.entries()) {
+    if (filePaths.length < 2) {
+      continue;
+    }
+    issues.push({
+      kind: routeKeyKinds.get(routeKey) ?? "api",
+      routeKey,
+      filePaths: filePaths.toSorted((a, b) => a.localeCompare(b))
+    });
+  }
+  return issues.toSorted((a, b) => a.routeKey.localeCompare(b.routeKey));
+};
+var formatRouteNamingIssues = ({
+  issues,
+  context
+}) => {
+  const plural = issues.length === 1 ? "" : "s";
+  const header = `[RouteNaming] Found ${issues.length} invalid API/sync route file${plural} while ${context}.`;
+  const details = issues.map((issue, index) => {
+    return `${index + 1}. [${issue.kind.toUpperCase()}] ${issue.filePath}
+   reason: ${issue.reason}
+   expected: ${issue.expected}`;
+  }).join("\n");
+  return `${header}
+${details}`;
+};
+var formatDuplicateRouteKeyIssues = ({
+  issues,
+  context
+}) => {
+  const plural = issues.length === 1 ? "" : "s";
+  const header = `[RouteNaming] Found ${issues.length} duplicate normalized route key${plural} while ${context}.`;
+  const details = issues.map((issue, index) => {
+    const fileList = issue.filePaths.map((filePath) => `   - ${filePath}`).join("\n");
+    return `${index + 1}. [${issue.kind.toUpperCase()}] ${issue.routeKey}
+   files:
+${fileList}`;
+  }).join("\n");
+  return `${header}
+${details}`;
+};
+var assertValidRouteNaming = ({
+  srcDir,
+  context
+}) => {
+  const issues = collectInvalidRouteNamingIssues(srcDir);
+  if (issues.length === 0) {
+    return;
+  }
+  throw new Error(formatRouteNamingIssues({ issues, context }));
+};
+var assertNoDuplicateNormalizedRouteKeys = ({
+  srcDir,
+  context
+}) => {
+  const issues = collectDuplicateNormalizedRouteKeyIssues(srcDir);
+  if (issues.length === 0) {
+    return;
+  }
+  throw new Error(formatDuplicateRouteKeyIssues({ issues, context }));
+};
+var walkPageFiles = (dir, results = []) => {
+  let entries;
+  try {
+    entries = fs5.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    const fullPath = path8.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      walkPageFiles(fullPath, results);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (entry.name === "page.tsx" || entry.name === "page.jsx") {
+      results.push(fullPath);
+    }
+  }
+  return results;
+};
+var collectDuplicatePageRoutes = (srcDir) => {
+  const pageFiles = walkPageFiles(srcDir);
+  const routeToFiles = /* @__PURE__ */ new Map();
+  for (const absoluteFilePath of pageFiles) {
+    const relative = normalizePath(path8.relative(srcDir, absoluteFilePath));
+    const result = validatePagePath(relative);
+    if (!result.valid || !result.route) continue;
+    const list = routeToFiles.get(result.route) ?? [];
+    list.push(normalizePath(path8.relative(ROOT_DIR4, absoluteFilePath)));
+    routeToFiles.set(result.route, list);
+  }
+  const issues = [];
+  for (const [route, filePaths] of routeToFiles) {
+    if (filePaths.length > 1) {
+      issues.push({ route, filePaths });
+    }
+  }
+  return issues;
+};
+var formatDuplicatePageRouteIssues = ({
+  issues,
+  context
+}) => {
+  const plural = issues.length === 1 ? "" : "s";
+  const header = `[RouteNaming] Found ${issues.length} duplicate page route${plural} while ${context}.`;
+  const details = issues.map((issue, index) => {
+    const fileList = issue.filePaths.map((filePath) => `   - ${filePath}`).join("\n");
+    return `${index + 1}. ${issue.route}
+   files:
+${fileList}
+   fix: rename or move one of the files so only one page.tsx resolves to "${issue.route}". Remember that "_<folder>" segments are stripped from the URL (invisible-parent rule).`;
+  }).join("\n");
+  return `${header}
+${details}`;
+};
+var assertNoDuplicatePageRoutes = ({
+  srcDir,
+  context
+}) => {
+  const issues = collectDuplicatePageRoutes(srcDir);
+  if (issues.length === 0) return;
+  throw new Error(formatDuplicatePageRouteIssues({ issues, context }));
+};
+
+// 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());
+  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");
+    console.log(`[TypeMapGenerator] Found ${apiFiles.length} API files`, "cyan");
+  }
+  for (const filePath of apiFiles) {
+    const pagePath = extractPagePath(filePath);
+    const apiName = extractApiName(filePath);
+    const apiVersion = extractApiVersion(filePath);
+    if (!pagePath || !apiName) continue;
+    const inputTypeResult = getInputTypeDetailsFromFile(filePath);
+    const outputTypeResult = getOutputTypeDetailsFromFile(filePath);
+    const streamTypeResult = getApiStreamPayloadTypeDetailsFromFile(filePath);
+    const inputType = inputTypeResult.text;
+    const outputType = outputTypeResult.text;
+    const streamType = streamTypeResult.text;
+    const httpMethod = extractHttpMethod(filePath, apiName);
+    const rateLimit = extractRateLimit(filePath);
+    const auth = extractAuth(filePath);
+    const meta = extractDocsMeta(filePath);
+    for (const symbol of [...inputTypeResult.unresolvedSymbols, ...outputTypeResult.unresolvedSymbols, ...streamTypeResult.unresolvedSymbols]) {
+      if (!symbol.importPath) {
+        unresolvedTypeAliases.add(symbol.name);
+        console.error(`[TypeMapGenerator] Unresolved API type (${pagePath}/${apiName}/${apiVersion}): ${symbol.name}`);
+        continue;
+      }
+      getOrInit(namedImports, 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());
+  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");
+    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(`[TypeMapGenerator] Found ${syncServerFiles.length} Sync server files, ${syncClientFiles.length} Sync client files`, "cyan");
+  }
+  const allSyncs = /* @__PURE__ */ new Map();
+  for (const serverFile of syncServerFiles) {
+    const pagePath = extractSyncPagePath(serverFile);
+    const syncName = extractSyncName(serverFile);
+    const syncVersion = extractSyncVersion(serverFile);
+    if (!pagePath || !syncName) continue;
+    const key = `${pagePath}/${syncName}/${syncVersion}`;
+    const existing = allSyncs.get(key) ?? { pagePath, syncName };
+    existing.serverFile = serverFile;
+    allSyncs.set(key, existing);
+  }
+  for (const clientFile of syncClientFiles) {
+    const pagePath = extractSyncPagePath(clientFile);
+    const syncName = extractSyncName(clientFile);
+    const syncVersion = extractSyncVersion(clientFile);
+    if (!pagePath || !syncName) continue;
+    const key = `${pagePath}/${syncName}/${syncVersion}`;
+    const existing = allSyncs.get(key) ?? { pagePath, syncName };
+    existing.clientFile = clientFile;
+    allSyncs.set(key, existing);
+  }
+  for (const [, { pagePath, syncName, serverFile, clientFile }] of allSyncs) {
+    const syncVersion = extractSyncVersion(serverFile ?? clientFile ?? "");
+    const clientInputTypeResult = serverFile ? getSyncClientDataTypeDetailsFromFile(serverFile) : clientFile ? getSyncClientDataTypeDetailsFromFile(clientFile) : { text: "{ }", unresolvedSymbols: [] };
+    const serverOutputTypeResult = serverFile ? getSyncServerOutputTypeDetailsFromFile(serverFile) : { text: "{ }", unresolvedSymbols: [] };
+    const clientOutputTypeResult = clientFile ? getSyncClientOutputTypeDetailsFromFile(clientFile) : { text: "{ }", unresolvedSymbols: [] };
+    const serverStreamTypeResult = serverFile ? getSyncServerStreamPayloadTypeDetailsFromFile(serverFile) : { text: "never", unresolvedSymbols: [] };
+    const clientStreamTypeResult = clientFile ? getSyncClientStreamPayloadTypeDetailsFromFile(clientFile) : { text: "never", unresolvedSymbols: [] };
+    const clientInputType = clientInputTypeResult.text;
+    const serverOutputType = serverOutputTypeResult.text;
+    const clientOutputType = clientOutputTypeResult.text;
+    const serverStreamType = serverStreamTypeResult.text;
+    const clientStreamType = clientStreamTypeResult.text;
+    const allSyncUnresolvedSymbols = [
+      ...clientInputTypeResult.unresolvedSymbols,
+      ...serverOutputTypeResult.unresolvedSymbols,
+      ...clientOutputTypeResult.unresolvedSymbols,
+      ...serverStreamTypeResult.unresolvedSymbols,
+      ...clientStreamTypeResult.unresolvedSymbols
+    ];
+    for (const symbol of allSyncUnresolvedSymbols) {
+      if (!symbol.importPath) {
+        unresolvedTypeAliases.add(symbol.name);
+        console.error(`[TypeMapGenerator] Unresolved Sync type (${pagePath}/${syncName}/${syncVersion}): ${symbol.name}`);
+        continue;
+      }
+      getOrInit(namedImports, symbol.importPath, () => /* @__PURE__ */ new Set()).add(symbol.name);
+    }
+    if (!quiet) {
+      console.log(`[TypeMapGenerator] Sync: ${pagePath}/${syncName}/${syncVersion} (server: ${!!serverFile}, client: ${!!clientFile})`);
+    }
+    const syncMeta = serverFile ? extractDocsMeta(serverFile) : clientFile ? extractDocsMeta(clientFile) : void 0;
+    getOrInit(syncTypesByPage, pagePath, () => /* @__PURE__ */ new Map()).set(`${syncName}@${syncVersion}`, {
+      clientInput: clientInputType,
+      serverOutput: serverOutputType,
+      clientOutput: clientOutputType,
+      serverStream: serverStreamType,
+      clientStream: clientStreamType,
+      version: syncVersion,
+      ...syncMeta ? { meta: syncMeta } : {}
+    });
+  }
+  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({
+    typesByPage,
+    syncTypesByPage,
+    namedImports,
+    defaultImports,
+    functionsInterface
+  });
+  writeTypeMapArtifacts({ content, docsData, schemasContent });
+};
+
+// src/templateRegistry.ts
+var BUILT_IN_TEMPLATE_KINDS = [
+  "api",
+  "sync_server",
+  "sync_client_paired",
+  "sync_client_standalone",
+  "page_plain",
+  "page_dashboard"
+];
+var BUILT_IN_TEMPLATE_FILENAMES = {
+  api: "api.template.ts",
+  sync_server: "sync_server.template.ts",
+  sync_client_paired: "sync_client_paired.template.ts",
+  sync_client_standalone: "sync_client_standalone.template.ts",
+  page_plain: "page_plain.template.tsx",
+  page_dashboard: "page_dashboard.template.tsx"
+};
+var overrides = /* @__PURE__ */ new Map();
+var rules = [];
+var insertionCounter = 0;
+var DEFAULT_DASHBOARD_PATH_PATTERN = /\/(admin|dashboard|settings|billing|account|profile)(\/|$)/;
+var registerTemplate = (kind, content) => {
+  overrides.set(kind, content);
+};
+var getRegisteredTemplate = (kind) => {
+  return overrides.get(kind) ?? null;
+};
+var clearTemplateOverrides = () => {
+  overrides.clear();
+};
+var listRegisteredTemplateKinds = () => {
+  return [...overrides.keys()];
+};
+var registerTemplateRule = (rule) => {
+  rules.push({ ...rule, order: insertionCounter++ });
+};
+var registerTemplateKind = (kind, options) => {
+  registerTemplateRule({ kind, match: options.match, priority: options.priority ?? 100 });
+  if (typeof options.content === "string") {
+    registerTemplate(kind, options.content);
+  }
+};
+var clearTemplateRules = () => {
+  rules.length = 0;
+};
+var getTemplateRules = () => {
+  return rules.toSorted((a, b) => b.priority - a.priority || b.order - a.order).map(({ kind, match, priority }) => ({ kind, match, priority }));
+};
+var resolveTemplateKind = (ctx) => {
+  for (const rule of getTemplateRules()) {
+    if (rule.match(ctx)) return rule.kind;
+  }
+  return null;
+};
+var defaultsRegistered = false;
+var registerDefaultTemplateRules = () => {
+  if (defaultsRegistered) return;
+  defaultsRegistered = true;
+  registerTemplateRule({ kind: "api", priority: 10, match: (c) => c.fileKind === "api" });
+  registerTemplateRule({ kind: "sync_server", priority: 10, match: (c) => c.fileKind === "sync_server" });
+  registerTemplateRule({ kind: "sync_client_paired", priority: 10, match: (c) => c.fileKind === "sync_client" && c.hasPairedServer });
+  registerTemplateRule({ kind: "sync_client_standalone", priority: 10, match: (c) => c.fileKind === "sync_client" && !c.hasPairedServer });
+  registerTemplateRule({
+    kind: "page_dashboard",
+    priority: 10,
+    match: (c) => c.fileKind === "page" && DEFAULT_DASHBOARD_PATH_PATTERN.test(c.filePath.replaceAll("\\", "/").toLowerCase())
+  });
+  registerTemplateRule({ kind: "page_plain", priority: 0, match: (c) => c.fileKind === "page" });
+};
+registerDefaultTemplateRules();
+
+// src/loader.ts
+import fs6 from "fs";
+import path9 from "path";
+import { pathToFileURL } from "url";
+import { tryCatch, getServerFunctionDirs as getServerFunctionDirs2, getSrcDir as getSrcDir2 } from "@luckystack/core";
+
+// src/runtimeTypeResolver.ts
+import * as ts8 from "typescript";
+var MAX_DEPTH = 20;
+var unresolvedPrefix = "__RUNTIME_UNRESOLVED__::";
+var PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "any",
+  "unknown",
+  "void",
+  "never"
+]);
+var SKIP_EXPANSION2 = /* @__PURE__ */ new Set([
+  "Date",
+  "Promise",
+  "Array",
+  "Record",
+  "Partial",
+  "Required",
+  "Pick",
+  "Omit",
+  "Function",
+  "Map",
+  "Set",
+  "Buffer",
+  "Uint8Array",
+  "Object",
+  "WeakMap",
+  "WeakSet"
+]);
+var toUnresolved = (message) => `${unresolvedPrefix}${message}`;
+var isUnresolvedTypeMarker = (value) => value.startsWith(unresolvedPrefix);
+var getUnresolvedTypeMessage = (value) => value.slice(unresolvedPrefix.length).trim();
+var resolvedTypeCache = /* @__PURE__ */ new Map();
+var clearRuntimeTypeResolverCache = () => {
+  resolvedTypeCache.clear();
+};
+var splitTopLevel = (value, splitter) => {
+  const items = [];
+  let depthParen = 0;
+  let depthBrace = 0;
+  let depthBracket = 0;
+  let depthAngle = 0;
+  let token = "";
+  for (const char of value) {
+    if (char === "(") depthParen += 1;
+    if (char === ")") depthParen -= 1;
+    if (char === "{") depthBrace += 1;
+    if (char === "}") depthBrace -= 1;
+    if (char === "[") depthBracket += 1;
+    if (char === "]") depthBracket -= 1;
+    if (char === "<") depthAngle += 1;
+    if (char === ">") depthAngle -= 1;
+    if (char === splitter && depthParen === 0 && depthBrace === 0 && depthBracket === 0 && depthAngle === 0) {
+      if (token.trim()) items.push(token.trim());
+      token = "";
+      continue;
+    }
+    token += char;
+  }
+  if (token.trim()) items.push(token.trim());
+  return items;
+};
+var parseTypeNode = (typeText) => {
+  const synthetic = `type __RT = ${typeText};`;
+  const source = ts8.createSourceFile("__runtime_type.ts", synthetic, ts8.ScriptTarget.Latest, true);
+  const statement = source.statements[0];
+  if (!statement || !ts8.isTypeAliasDeclaration(statement)) return null;
+  return statement.type;
+};
+var parseObjectFields = (typeText) => {
+  const clean = typeText.trim();
+  if (!clean.startsWith("{") || !clean.endsWith("}")) {
+    return { fields: [], indexSignatures: [] };
+  }
+  const typeNode = parseTypeNode(clean);
+  if (!typeNode || !ts8.isTypeLiteralNode(typeNode)) {
+    return { fields: [], indexSignatures: [] };
+  }
+  const fields = [];
+  const indexSignatures = [];
+  for (const member of typeNode.members) {
+    if (ts8.isPropertySignature(member) && member.type) {
+      let key = null;
+      if (ts8.isIdentifier(member.name)) {
+        key = member.name.text;
+      } else if (ts8.isStringLiteral(member.name)) {
+        key = member.name.text;
+      }
+      if (key === null) continue;
+      fields.push({
+        key,
+        optional: Boolean(member.questionToken),
+        type: member.type.getText().trim()
+      });
+      continue;
+    }
+    if (ts8.isIndexSignatureDeclaration(member)) {
+      const param = member.parameters[0];
+      if (!param || !ts8.isIdentifier(param.name) || !param.type) continue;
+      indexSignatures.push({
+        keyName: param.name.text,
+        keyType: param.type.getText().trim(),
+        type: member.type.getText().trim()
+      });
+    }
+  }
+  return { fields, indexSignatures };
+};
+var serializeObjectFields = ({
+  fields,
+  indexSignatures
+}) => {
+  const segments = [];
+  for (const field of fields) {
+    segments.push(`${field.key}${field.optional ? "?" : ""}: ${field.type}`);
+  }
+  for (const indexSignature of indexSignatures) {
+    segments.push(`[${indexSignature.keyName}: ${indexSignature.keyType}]: ${indexSignature.type}`);
+  }
+  if (segments.length === 0) return "{ }";
+  return `{ ${segments.join("; ")} }`;
+};
+var extractStringLiteralKey = (node) => {
+  if (!ts8.isLiteralTypeNode(node)) return null;
+  const literal = node.literal;
+  if (!ts8.isStringLiteral(literal)) return null;
+  return literal.text;
+};
+var parseLiteralUnionKeys = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const typeNode = parseTypeNode(trimmed);
+  if (!typeNode) return null;
+  if (ts8.isUnionTypeNode(typeNode)) {
+    const keys = [];
+    for (const member of typeNode.types) {
+      const key = extractStringLiteralKey(member);
+      if (key === null) return null;
+      keys.push(key);
+    }
+    return keys.length > 0 ? keys : null;
+  }
+  const singleKey = extractStringLiteralKey(typeNode);
+  return singleKey === null ? null : [singleKey];
+};
+var resolveIdentifier = (identifier, filePath) => {
+  if (PRIMITIVE_TYPES.has(identifier.toLowerCase())) return identifier.toLowerCase();
+  if (SKIP_EXPANSION2.has(identifier)) return identifier;
+  try {
+    const program = getServerProgram();
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) return toUnresolved(`unresolved type ${identifier}`);
+    const checker = program.getTypeChecker();
+    for (const stmt of sourceFile.statements) {
+      if ((ts8.isInterfaceDeclaration(stmt) || ts8.isTypeAliasDeclaration(stmt) || ts8.isEnumDeclaration(stmt)) && stmt.name.text === identifier) {
+        const symbol = checker.getSymbolAtLocation(stmt.name);
+        if (symbol) {
+          return expandType(checker.getDeclaredTypeOfSymbol(symbol), checker);
+        }
+      }
+      if (ts8.isImportDeclaration(stmt) && stmt.importClause) {
+        const { namedBindings, name: defaultName } = stmt.importClause;
+        if (namedBindings && ts8.isNamedImports(namedBindings)) {
+          for (const specifier of namedBindings.elements) {
+            if (specifier.name.text === identifier) {
+              const symbol = checker.getSymbolAtLocation(specifier.name);
+              if (symbol) {
+                const target = symbol.flags & ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+                return expandType(checker.getDeclaredTypeOfSymbol(target), checker);
+              }
+            }
+          }
+        }
+        if (defaultName?.text === identifier) {
+          const symbol = checker.getSymbolAtLocation(defaultName);
+          if (symbol) {
+            const target = symbol.flags & ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+            return expandType(checker.getDeclaredTypeOfSymbol(target), checker);
+          }
+        }
+      }
+    }
+    return toUnresolved(`unresolved type ${identifier}`);
+  } catch {
+    return toUnresolved(`unresolved type ${identifier}`);
+  }
+};
+var applyUtilityType = ({
+  utilityName,
+  utilityArgs,
+  filePath,
+  depth,
+  state
+}) => {
+  if (utilityName === "Partial" || utilityName === "Required") {
+    const arg0 = utilityArgs[0];
+    if (utilityArgs.length !== 1 || arg0 === void 0) return toUnresolved(`unresolved utility ${utilityName}<...>`);
+    const target = resolveExpression(arg0, filePath, depth + 1, state);
+    if (isUnresolvedTypeMarker(target)) return target;
+    const parsed = parseObjectFields(target);
+    const fields = parsed.fields;
+    if (fields.length === 0) return toUnresolved(`unresolved utility ${utilityName}<${arg0}>`);
+    return serializeObjectFields({
+      fields: fields.map((f) => ({ ...f, optional: utilityName === "Partial" })),
+      indexSignatures: parsed.indexSignatures
+    });
+  }
+  if (utilityName === "Pick" || utilityName === "Omit") {
+    const arg0 = utilityArgs[0];
+    const arg1 = utilityArgs[1];
+    if (utilityArgs.length !== 2 || arg0 === void 0 || arg1 === void 0) return toUnresolved(`unresolved utility ${utilityName}<...>`);
+    const target = resolveExpression(arg0, filePath, depth + 1, state);
+    if (isUnresolvedTypeMarker(target)) return target;
+    const keys = parseLiteralUnionKeys(arg1);
+    if (!keys) return toUnresolved(`unresolved utility ${utilityName}<${utilityArgs.join(", ")}>`);
+    const parsed = parseObjectFields(target);
+    const fields = parsed.fields;
+    if (fields.length === 0) return toUnresolved(`unresolved utility ${utilityName}<${utilityArgs.join(", ")}>`);
+    const keySet = new Set(keys);
+    const filtered = fields.filter((f) => utilityName === "Pick" ? keySet.has(f.key) : !keySet.has(f.key));
+    return serializeObjectFields({ fields: filtered, indexSignatures: parsed.indexSignatures });
+  }
+  if (utilityName === "Record") {
+    const arg0 = utilityArgs[0];
+    const arg1 = utilityArgs[1];
+    if (utilityArgs.length !== 2 || arg0 === void 0 || arg1 === void 0) return toUnresolved("unresolved utility Record<...>");
+    const resolvedKey = resolveExpression(arg0, filePath, depth + 1, state);
+    const resolvedValue = resolveExpression(arg1, filePath, depth + 1, state);
+    if (isUnresolvedTypeMarker(resolvedKey)) return resolvedKey;
+    if (isUnresolvedTypeMarker(resolvedValue)) return resolvedValue;
+    const keys = parseLiteralUnionKeys(resolvedKey);
+    if (!keys) return `Record<${resolvedKey}, ${resolvedValue}>`;
+    return serializeObjectFields({
+      fields: keys.map((key) => ({ key, optional: false, type: resolvedValue })),
+      indexSignatures: []
+    });
+  }
+  return toUnresolved(`unresolved utility ${utilityName}<${utilityArgs.join(", ")}>`);
+};
+var resolveExpression = (typeText, filePath, depth, state) => {
+  const type = typeText.trim();
+  if (!type) return type;
+  const visitKey = `${filePath}::${type}`;
+  if (state.stack.has(visitKey)) return toUnresolved(`cyclic type reference ${type}`);
+  if (depth > MAX_DEPTH) return toUnresolved(`resolution depth exceeded for ${type}`);
+  state.stack.add(visitKey);
+  let result;
+  if (isUnresolvedTypeMarker(type)) {
+    result = type;
+  } else if (type.startsWith("(") && type.endsWith(")")) {
+    const inner = resolveExpression(type.slice(1, -1), filePath, depth + 1, state);
+    result = isUnresolvedTypeMarker(inner) ? inner : `(${inner})`;
+  } else {
+    const unionParts = splitTopLevel(type, "|");
+    if (unionParts.length > 1) {
+      const resolved = unionParts.map((p) => resolveExpression(p, filePath, depth + 1, state));
+      const unresolved = resolved.find((item) => isUnresolvedTypeMarker(item));
+      result = unresolved ?? resolved.join(" | ");
+    } else {
+      const intersectionParts = splitTopLevel(type, "&");
+      if (intersectionParts.length > 1) {
+        const resolved = intersectionParts.map((p) => resolveExpression(p, filePath, depth + 1, state));
+        const unresolved = resolved.find((item) => isUnresolvedTypeMarker(item));
+        result = unresolved ?? resolved.join(" & ");
+      } else if (type.endsWith("[]")) {
+        const inner = resolveExpression(type.slice(0, -2), filePath, depth + 1, state);
+        result = isUnresolvedTypeMarker(inner) ? inner : `${inner}[]`;
+      } else if (type.startsWith("{") && type.endsWith("}")) {
+        const parsed = parseObjectFields(type);
+        const fields = parsed.fields;
+        const indexSignatures = parsed.indexSignatures;
+        const resolvedFields = [];
+        const resolvedIndexSignatures = [];
+        let hadError;
+        if (fields.length === 0 && indexSignatures.length === 0) {
+          result = type;
+          state.stack.delete(visitKey);
+          return result;
+        }
+        for (const field of fields) {
+          const resolvedType = resolveExpression(field.type, filePath, depth + 1, state);
+          if (isUnresolvedTypeMarker(resolvedType)) {
+            hadError = resolvedType;
+            break;
+          }
+          resolvedFields.push({ ...field, type: resolvedType });
+        }
+        for (const indexSignature of indexSignatures) {
+          const resolvedKeyType = resolveExpression(indexSignature.keyType, filePath, depth + 1, state);
+          if (isUnresolvedTypeMarker(resolvedKeyType)) {
+            hadError = resolvedKeyType;
+            break;
+          }
+          const resolvedValueType = resolveExpression(indexSignature.type, filePath, depth + 1, state);
+          if (isUnresolvedTypeMarker(resolvedValueType)) {
+            hadError = resolvedValueType;
+            break;
+          }
+          resolvedIndexSignatures.push({
+            ...indexSignature,
+            keyType: resolvedKeyType,
+            type: resolvedValueType
+          });
+        }
+        result = hadError ?? serializeObjectFields({
+          fields: resolvedFields,
+          indexSignatures: resolvedIndexSignatures
+        });
+      } else {
+        const typeNode = parseTypeNode(type);
+        const referenceInfo = typeNode && ts8.isTypeReferenceNode(typeNode) && ts8.isIdentifier(typeNode.typeName) ? { name: typeNode.typeName.text, args: typeNode.typeArguments } : null;
+        if (referenceInfo?.args && referenceInfo.args.length > 0) {
+          const { name: genericName, args: argNodes } = referenceInfo;
+          const args = argNodes.map((arg) => arg.getText().trim());
+          const firstArg = args[0];
+          if (genericName === "Array" && args.length === 1 && firstArg !== void 0) {
+            const inner = resolveExpression(firstArg, filePath, depth + 1, state);
+            result = isUnresolvedTypeMarker(inner) ? inner : `${inner}[]`;
+          } else if (["Partial", "Required", "Pick", "Omit", "Record"].includes(genericName)) {
+            result = applyUtilityType({ utilityName: genericName, utilityArgs: args, filePath, depth, state });
+          } else {
+            const resolvedArgs = args.map((a) => resolveExpression(a, filePath, depth + 1, state));
+            const unresolved = resolvedArgs.find((item) => isUnresolvedTypeMarker(item));
+            result = unresolved ?? `${genericName}<${resolvedArgs.join(", ")}>`;
+          }
+        } else if (referenceInfo && (!referenceInfo.args || referenceInfo.args.length === 0)) {
+          result = resolveIdentifier(referenceInfo.name, filePath);
+        } else {
+          result = type;
+        }
+      }
+    }
+  }
+  state.stack.delete(visitKey);
+  return result;
+};
+var resolveRuntimeTypeText = ({
+  typeText,
+  filePath
+}) => {
+  const cleanType = typeText.trim();
+  if (!cleanType || !filePath) {
+    return { status: "success", typeText: cleanType };
+  }
+  const cacheKey = `${filePath}::${cleanType}`;
+  const cached = resolvedTypeCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const resolved = resolveExpression(cleanType, filePath, 0, { stack: /* @__PURE__ */ new Set() });
+  const result = isUnresolvedTypeMarker(resolved) ? { status: "error", message: getUnresolvedTypeMessage(resolved) } : { status: "success", typeText: resolved };
+  resolvedTypeCache.set(cacheKey, result);
+  return result;
+};
+
+// src/loader.ts
+var devApis = {};
+var devSyncs = {};
+var devFunctions = {};
+var normalizePath2 = (value) => value.replaceAll("\\", "/");
+var mapApiPageLocation = (pageLocation) => {
+  return pageLocation ? pageLocation : "system";
+};
+var resolveApiRouteMetaFromPath = (filePath) => {
+  const absolutePath = path9.resolve(filePath);
+  const normalizedAbsolutePath = normalizePath2(absolutePath);
+  const normalizedSrcDir = normalizePath2(getSrcDir2());
+  if (!normalizedAbsolutePath.startsWith(normalizedSrcDir) || !normalizedAbsolutePath.endsWith(".ts")) {
+    return null;
+  }
+  const rules2 = getRoutingRules();
+  const relativePath = normalizePath2(path9.relative(getSrcDir2(), absolutePath));
+  const segments = relativePath.split("/");
+  const apiIndex = segments.indexOf(rules2.apiMarker);
+  if (apiIndex === -1 || apiIndex === segments.length - 1) {
+    return null;
+  }
+  const pageLocation = segments.slice(0, apiIndex).join("/");
+  const apiFilePath = segments.slice(apiIndex + 1).join("/");
+  const rawApiName = apiFilePath.replace(/\.ts$/, "");
+  const versionMatch = rawApiName.match(rules2.apiVersionRegex);
+  if (!versionMatch) {
+    return null;
+  }
+  const version = `v${versionMatch[1]}`;
+  const apiName = rawApiName.replace(rules2.apiVersionRegex, "");
+  const mappedPageLocation = mapApiPageLocation(pageLocation);
+  const routeKey = `api/${mappedPageLocation}/${apiName}/${version}`;
+  return { routeKey, absolutePath };
+};
+var resolveSyncRouteMetaFromPath = (filePath) => {
+  const absolutePath = path9.resolve(filePath);
+  const normalizedAbsolutePath = normalizePath2(absolutePath);
+  const normalizedSrcDir = normalizePath2(getSrcDir2());
+  if (!normalizedAbsolutePath.startsWith(normalizedSrcDir) || !normalizedAbsolutePath.endsWith(".ts")) {
+    return null;
+  }
+  const rules2 = getRoutingRules();
+  const relativePath = normalizePath2(path9.relative(getSrcDir2(), absolutePath));
+  const segments = relativePath.split("/");
+  const syncIndex = segments.indexOf(rules2.syncMarker);
+  if (syncIndex === -1 || syncIndex === segments.length - 1) {
+    return null;
+  }
+  const pageLocation = segments.slice(0, syncIndex).join("/");
+  const syncFilePath = segments.slice(syncIndex + 1).join("/");
+  const rawSyncName = syncFilePath.replace(/\.ts$/, "");
+  const match = rawSyncName.match(rules2.syncVersionRegex);
+  if (!match) {
+    return null;
+  }
+  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}`;
+  return {
+    routeKey: `${routeBaseKey}_${kind}`,
+    kind,
+    absolutePath
+  };
+};
+var initializeAll = async () => {
+  assertValidRouteNaming({
+    srcDir: getSrcDir2(),
+    context: "starting dev server (npm run server)"
+  });
+  const pageRouteIssues = collectDuplicatePageRoutes(getSrcDir2());
+  if (pageRouteIssues.length > 0) {
+    console.warn(formatDuplicatePageRouteIssues({
+      issues: pageRouteIssues,
+      context: "starting dev server (npm run server)"
+    }));
+  }
+  await Promise.all([initializeApis(), initializeSyncs(), initializeFunctions()]);
+};
+var importFile = async (absolutePath) => {
+  const url = `${pathToFileURL(absolutePath).href}?v=${Date.now()}`;
+  return import(url);
+};
+var collectTsFiles = (dir, relativeTo = "") => {
+  const results = [];
+  const entries = fs6.readdirSync(dir);
+  for (const entry of entries) {
+    const entryPath = path9.join(dir, entry);
+    const relPath = relativeTo ? `${relativeTo}/${entry}` : entry;
+    if (fs6.statSync(entryPath).isDirectory()) {
+      results.push(...collectTsFiles(entryPath, relPath));
+    } else if (entry.endsWith(".ts") && !isRouteTestFile(entry)) {
+      results.push(relPath);
+    }
+  }
+  return results;
+};
+var isMergeable = (value) => {
+  return typeof value === "object" && value !== null || typeof value === "function";
+};
+var resolveFunctionModule = (loadedModule, fileName) => {
+  if (!loadedModule || typeof loadedModule !== "object" || !("default" in loadedModule)) {
+    return isMergeable(loadedModule) ? loadedModule : {};
+  }
+  const moduleRecord = loadedModule;
+  const { default: defaultExport, ...namedExports } = moduleRecord;
+  const filteredNamedExports = Object.fromEntries(
+    Object.entries(namedExports).filter(([key]) => key !== "__esModule")
+  );
+  if (Object.keys(filteredNamedExports).length > 0) {
+    return filteredNamedExports;
+  }
+  if (defaultExport !== void 0) {
+    return { [fileName]: defaultExport };
+  }
+  return {};
+};
+var initializeApis = async () => {
+  for (const key of Object.keys(devApis)) delete devApis[key];
+  clearRuntimeTypeResolverCache();
+  const srcFolder = fs6.readdirSync(getSrcDir2());
+  for (const file of srcFolder) {
+    await scanApiFolder(file);
+  }
+};
+var upsertApiFromFile = async (filePath) => {
+  const routeMeta = resolveApiRouteMetaFromPath(filePath);
+  if (!routeMeta) {
+    const normalized = normalizePath2(path9.resolve(filePath));
+    if (normalized.includes("/_api/") && normalized.endsWith(".ts") && !isRouteTestFile(normalized)) {
+      console.log(
+        `[loader][api] invalid filename: ${normalized}. Expected <name>_v<number>.ts. File will not be loaded.`,
+        "red"
+      );
+    }
+    return;
+  }
+  invalidateProgramCache();
+  clearRuntimeTypeResolverCache();
+  const [err, module] = await tryCatch(async () => importFile(routeMeta.absolutePath));
+  if (err) {
+    console.log(`[loader][api] failed to import ${routeMeta.routeKey} from ${routeMeta.absolutePath}:`, err, "red");
+    return;
+  }
+  const resolvedModule = module?.default ? { ...module.default, ...module } : module;
+  const { auth = {}, main, rateLimit, httpMethod, schema, validation, errorFormatter } = resolvedModule;
+  if (!main || typeof main !== "function") {
+    delete devApis[routeMeta.routeKey];
+    return;
+  }
+  const inputType = getInputTypeFromFile(routeMeta.absolutePath);
+  devApis[routeMeta.routeKey] = {
+    main,
+    auth: {
+      login: auth.login || false,
+      additional: auth.additional || []
+    },
+    rateLimit,
+    httpMethod,
+    schema,
+    inputType,
+    inputTypeFilePath: routeMeta.absolutePath,
+    validation,
+    errorFormatter
+  };
+};
+var removeApiFromFile = (filePath) => {
+  const routeMeta = resolveApiRouteMetaFromPath(filePath);
+  if (!routeMeta) {
+    return;
+  }
+  invalidateProgramCache();
+  clearRuntimeTypeResolverCache();
+  delete devApis[routeMeta.routeKey];
+};
+var scanApiFolder = async (file, basePath = "") => {
+  const fullPath = path9.join(getSrcDir2(), basePath, file);
+  if (!fs6.statSync(fullPath).isDirectory()) return;
+  if (!file.toLowerCase().endsWith("api")) {
+    const subFolders = fs6.readdirSync(fullPath);
+    for (const sub of subFolders) {
+      await scanApiFolder(sub, path9.join(basePath, file));
+    }
+    return;
+  }
+  const pageLocation = basePath.replaceAll("\\", "/");
+  const mappedPageLocation = mapApiPageLocation(pageLocation);
+  const tsFiles = collectTsFiles(fullPath);
+  const apiRules = getRoutingRules();
+  for (const relFile of tsFiles) {
+    const rawApiName = relFile.replace(/\.ts$/, "").replaceAll("\\", "/");
+    const versionMatch = rawApiName.match(apiRules.apiVersionRegex);
+    if (!versionMatch) {
+      console.log(
+        `[loader][api] invalid filename: ${path9.join(fullPath, relFile)}. Expected <name>_v<number>.ts. File will not be loaded.`,
+        "red"
+      );
+      continue;
+    }
+    const version = `v${versionMatch[1]}`;
+    const apiName = rawApiName.replace(apiRules.apiVersionRegex, "");
+    const routeKey = `api/${mappedPageLocation}/${apiName}/${version}`;
+    const modulePath = path9.resolve(path9.join(fullPath, relFile));
+    const [err, module] = await tryCatch(async () => importFile(modulePath));
+    if (err) {
+      console.log(`[loader][api] failed to import ${routeKey} from ${modulePath}:`, err, "red");
+      continue;
+    }
+    const resolvedModule = module?.default ? { ...module.default, ...module } : module;
+    const { auth = {}, main, rateLimit, httpMethod, schema, validation, errorFormatter } = resolvedModule;
+    if (!main || typeof main !== "function") continue;
+    const inputType = getInputTypeFromFile(modulePath);
+    devApis[routeKey] = {
+      main,
+      auth: {
+        login: auth.login || false,
+        additional: auth.additional || []
+      },
+      rateLimit,
+      httpMethod,
+      schema,
+      inputType,
+      inputTypeFilePath: modulePath,
+      validation,
+      errorFormatter
+    };
+  }
+};
+var initializeSyncs = async () => {
+  for (const key of Object.keys(devSyncs)) delete devSyncs[key];
+  clearRuntimeTypeResolverCache();
+  const srcFolder = fs6.readdirSync(getSrcDir2());
+  for (const file of srcFolder) {
+    await scanSyncFolder(file);
+  }
+};
+var upsertSyncFromFile = async (filePath) => {
+  const routeMeta = resolveSyncRouteMetaFromPath(filePath);
+  if (!routeMeta) {
+    const normalized = normalizePath2(path9.resolve(filePath));
+    if (normalized.includes(`/${getRoutingRules().syncMarker}/`) && normalized.endsWith(".ts") && !isRouteTestFile(normalized)) {
+      console.log(
+        `[loader][sync] invalid filename: ${normalized}. Expected <name>_server_v<number>.ts or <name>_client_v<number>.ts. File will not be loaded.`,
+        "red"
+      );
+    }
+    return;
+  }
+  invalidateProgramCache();
+  clearRuntimeTypeResolverCache();
+  const [err, module] = await tryCatch(async () => importFile(routeMeta.absolutePath));
+  if (err) {
+    console.log(`[loader][sync] failed to import ${routeMeta.absolutePath}:`, err, "red");
+    return;
+  }
+  const resolvedSyncModule = module?.default ? { ...module.default, ...module } : module;
+  if (routeMeta.kind === "server") {
+    if (!resolvedSyncModule.main || typeof resolvedSyncModule.main !== "function") {
+      delete devSyncs[routeMeta.routeKey];
+      return;
+    }
+    const inputType = getSyncClientDataType(routeMeta.absolutePath);
+    devSyncs[routeMeta.routeKey] = {
+      main: resolvedSyncModule.main,
+      auth: resolvedSyncModule.auth || {},
+      inputType,
+      inputTypeFilePath: routeMeta.absolutePath
+    };
+    return;
+  }
+  if (!resolvedSyncModule.main || typeof resolvedSyncModule.main !== "function") {
+    delete devSyncs[routeMeta.routeKey];
+    return;
+  }
+  devSyncs[routeMeta.routeKey] = resolvedSyncModule.main;
+};
+var removeSyncFromFile = (filePath) => {
+  const routeMeta = resolveSyncRouteMetaFromPath(filePath);
+  if (!routeMeta) {
+    return;
+  }
+  invalidateProgramCache();
+  clearRuntimeTypeResolverCache();
+  delete devSyncs[routeMeta.routeKey];
+};
+var scanSyncFolder = async (file, basePath = "") => {
+  const fullPath = path9.join(getSrcDir2(), basePath, file);
+  if (!fs6.statSync(fullPath).isDirectory()) return;
+  if (!file.toLowerCase().endsWith("sync")) {
+    const subFolders = fs6.readdirSync(fullPath);
+    for (const sub of subFolders) {
+      await scanSyncFolder(sub, path9.join(basePath, file));
+    }
+    return;
+  }
+  const pageLocation = basePath.replaceAll("\\", "/");
+  const tsFiles = collectTsFiles(fullPath);
+  const syncRules = getRoutingRules();
+  for (const relFile of tsFiles) {
+    const rawSyncFileName = relFile.replace(/\.ts$/, "").replaceAll("\\", "/");
+    const syncMatch = rawSyncFileName.match(syncRules.syncVersionRegex);
+    if (!syncMatch) {
+      console.log(
+        `[loader][sync] invalid filename: ${path9.join(fullPath, relFile)}. Expected <name>_server_v<number>.ts or <name>_client_v<number>.ts. File will not be loaded.`,
+        "red"
+      );
+      continue;
+    }
+    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 filePath = path9.resolve(path9.join(fullPath, relFile));
+    const [fileError, fileResult] = await tryCatch(async () => importFile(filePath));
+    if (fileError) {
+      console.log(`[loader][sync] failed to import ${filePath}:`, fileError, "red");
+      continue;
+    }
+    const resolvedSyncModule = fileResult?.default ? { ...fileResult.default, ...fileResult } : fileResult;
+    const inputType = getSyncClientDataType(filePath);
+    if (kind === "server") {
+      devSyncs[`${routeBaseKey}_server`] = {
+        main: resolvedSyncModule.main,
+        auth: resolvedSyncModule.auth || {},
+        inputType,
+        inputTypeFilePath: filePath
+      };
+    } else {
+      devSyncs[`${routeBaseKey}_client`] = resolvedSyncModule.main;
+    }
+  }
+};
+var functionClaimMap = /* @__PURE__ */ new Map();
+var initializeFunctions = async () => {
+  for (const key of Object.keys(devFunctions)) delete devFunctions[key];
+  functionClaimMap.clear();
+  const dirs = getServerFunctionDirs2();
+  for (const dir of dirs) {
+    if (fs6.existsSync(dir)) {
+      await scanFunctionsFolder(dir, dir);
+    }
+  }
+};
+var scanFunctionsFolder = async (dir, rootDir, basePath = []) => {
+  const entries = fs6.readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = path9.join(dir, entry);
+    const stat = fs6.statSync(fullPath);
+    if (stat.isDirectory()) {
+      await scanFunctionsFolder(fullPath, rootDir, [...basePath, entry]);
+      continue;
+    }
+    if (!entry.endsWith(".ts")) {
+      continue;
+    }
+    const [err, module] = await tryCatch(async () => importFile(fullPath));
+    if (err) {
+      console.log(`[loader][function] failed to import ${fullPath}:`, err, "red");
+      continue;
+    }
+    const fileName = entry.replace(".ts", "");
+    const resolvedFunctionModule = resolveFunctionModule(module, fileName);
+    if (!isMergeable(resolvedFunctionModule)) continue;
+    const keyPath = [...basePath, fileName].join(".");
+    const previousRoot = functionClaimMap.get(keyPath);
+    if (previousRoot !== void 0 && previousRoot !== rootDir) {
+      console.log(
+        `[loader][function] Conflict at \`functions.${keyPath}\`: defined in both \`${previousRoot}\` and \`${rootDir}\`. Skipping the second copy; fix the duplicate (delete one \u2014 \`shared/\` is the canonical location for framework re-exports).`,
+        "red"
+      );
+      continue;
+    }
+    functionClaimMap.set(keyPath, rootDir);
+    let target = devFunctions;
+    for (const part of basePath) {
+      const existing = target[part];
+      if (!existing || typeof existing !== "object") {
+        target[part] = {};
+      }
+      target = target[part];
+    }
+    const existingAtFileName = target[fileName];
+    if (existingAtFileName !== void 0 && isMergeable(resolvedFunctionModule) && isMergeable(existingAtFileName)) {
+      Object.assign(resolvedFunctionModule, existingAtFileName);
+    }
+    target[fileName] = resolvedFunctionModule;
+  }
+};
+
+// src/hotReload.ts
+import { watch } from "chokidar";
+import fs9 from "fs";
+import path12 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";
+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 templateContentFilenames = (kind) => {
+  const builtIn = BUILT_IN_TEMPLATE_FILENAMES[kind];
+  if (builtIn) return [builtIn];
+  return [`${kind}.template.tsx`, `${kind}.template.ts`];
+};
+var resolveTemplateContent = (kind) => {
+  const consumerDir = getConsumerTemplatesDir();
+  for (const fileName of templateContentFilenames(kind)) {
+    const consumerFile = path10.join(consumerDir, fileName);
+    if (fs7.existsSync(consumerFile)) {
+      try {
+        return fs7.readFileSync(consumerFile, "utf8");
+      } catch (error) {
+        console.error(`[TemplateInjector] Could not read consumer template: ${consumerFile}`, error);
+      }
+    }
+  }
+  const override = getRegisteredTemplate(kind);
+  if (override !== null) return override;
+  const builtInName = BUILT_IN_TEMPLATE_FILENAMES[kind];
+  if (builtInName) {
+    const bundled = path10.join(templatesDir, builtInName);
+    try {
+      return fs7.readFileSync(bundled, "utf8");
+    } catch (error) {
+      console.error(`[TemplateInjector] Could not read bundled template: ${bundled}`, error);
+      return null;
+    }
+  }
+  console.warn(`[TemplateInjector] No content for custom template kind "${kind}" \u2014 add .luckystack/templates/${kind}.template.tsx or call registerTemplate('${kind}', ...).`);
+  return null;
+};
+var consumerTemplateConfig = null;
+var ensureConsumerTemplateConfigLoaded = () => {
+  consumerTemplateConfig ??= (async () => {
+    const dir = getConsumerTemplatesDir();
+    for (const fileName of ["templateRules.ts", "templateRules.mjs", "templateRules.js"]) {
+      const rulesFile = path10.join(dir, fileName);
+      if (!fs7.existsSync(rulesFile)) continue;
+      try {
+        await import(pathToFileURL2(rulesFile).href);
+      } catch (error) {
+        console.error(`[TemplateInjector] Failed to load consumer template rules: ${rulesFile}`, error);
+      }
+      return;
+    }
+  })();
+  return consumerTemplateConfig;
+};
+var isEmptyFile = (filePath) => {
+  try {
+    const content = fs7.readFileSync(filePath, "utf8");
+    return content.trim().length === 0;
+  } catch {
+    return false;
+  }
+};
+var isCommentOnlyFile = (filePath) => {
+  try {
+    const content = fs7.readFileSync(filePath, "utf8");
+    const withoutBlockComments = content.replaceAll(/\/\*[\s\S]*?\*\//g, "");
+    const withoutLineComments = withoutBlockComments.replaceAll(/(^|\s)\/\/.*$/gm, "$1");
+    return withoutLineComments.trim().length === 0;
+  } catch {
+    return false;
+  }
+};
+var isInApiFolder = (filePath) => {
+  const normalized = filePath.replaceAll("\\", "/");
+  return normalized.includes("/_api/") && filePath.endsWith(".ts") && !isRouteTestFile(filePath);
+};
+var isInSyncFolder = (filePath) => {
+  const normalized = filePath.replaceAll("\\", "/");
+  return normalized.includes("/_sync/") && filePath.endsWith(".ts") && !isRouteTestFile(filePath);
+};
+var isPageFile = (filePath) => {
+  const normalized = filePath.replaceAll("\\", "/");
+  const filename = normalized.split("/").pop() ?? "";
+  return filename === "page.tsx" || filename === "page.jsx";
+};
+var isSyncServerFile = (filePath) => {
+  return isVersionedSyncServerFileName(filePath);
+};
+var isSyncClientFile = (filePath) => {
+  return isVersionedSyncClientFileName(filePath);
+};
+var isVersionedApiFile = (filePath) => {
+  return isVersionedApiFileName(filePath);
+};
+var isVersionedSyncFile = (filePath) => {
+  return isVersionedSyncFileName(filePath);
+};
+var getFileName = (filePath) => {
+  return path10.basename(filePath.replace(/\\/g, "/"));
+};
+var stripTsExtension = (fileName) => {
+  return fileName.replace(/\.ts$/, "");
+};
+var toApiBaseName = (fileName) => {
+  const withoutExtension = stripTsExtension(fileName);
+  const withoutVersion = withoutExtension.replace(/_v\d+$/, "");
+  return withoutVersion || "myApi";
+};
+var toSyncBaseName = (fileName) => {
+  const withoutExtension = stripTsExtension(fileName);
+  const withoutVersionedKind = withoutExtension.replace(/_(?:server|client)_v\d+$/, "");
+  const withoutKindOnly = withoutVersionedKind.replace(/_(?:server|client)$/, "");
+  const withoutVersionOnly = withoutKindOnly.replace(/_v\d+$/, "");
+  return withoutVersionOnly || "mySync";
+};
+var getApiFilenameReason = (fileName) => {
+  const withoutExtension = stripTsExtension(fileName);
+  if (/_v\d+$/.test(withoutExtension)) {
+    return "The filename already looks versioned.";
+  }
+  if (/_v\d+/.test(withoutExtension)) {
+    return "The version token must be at the end of the filename.";
+  }
+  if (/_server|_client/.test(withoutExtension)) {
+    return "API files do not use _server/_client suffixes.";
+  }
+  return "Missing required version suffix.";
+};
+var getSyncFilenameReason = (fileName) => {
+  const withoutExtension = stripTsExtension(fileName);
+  if (/_(?:server|client)_v\d+$/.test(withoutExtension)) {
+    return "The filename already looks versioned.";
+  }
+  if (/_(?:server|client)$/.test(withoutExtension)) {
+    return "Sync files with _server/_client must include a version suffix like _v1.";
+  }
+  if (/_v\d+$/.test(withoutExtension)) {
+    return "Sync files with versions must also include _server or _client.";
+  }
+  return "Missing required sync kind and version suffix.";
+};
+var getRouteFilenameValidationMessage = (filePath) => {
+  const normalized = filePath.replace(/\\/g, "/");
+  const fileName = getFileName(normalized);
+  if (isInApiFolder(normalized) && !isVersionedApiFile(normalized)) {
+    const base = toApiBaseName(fileName);
+    return [
+      `Invalid API filename: ${fileName}`,
+      `Reason: ${getApiFilenameReason(fileName)}`,
+      `Expected: ${ROUTE_NAMING_RULES.api}`,
+      `Example: ${base}_v1.ts (for example ${ROUTE_NAMING_EXAMPLES.api})`,
+      "This file is ignored by route loading and type generation until it is renamed."
+    ].join(" ");
+  }
+  if (isInSyncFolder(normalized) && !isVersionedSyncFile(normalized)) {
+    const base = toSyncBaseName(fileName);
+    return [
+      `Invalid sync filename: ${fileName}`,
+      `Reason: ${getSyncFilenameReason(fileName)}`,
+      `Expected: ${ROUTE_NAMING_RULES.syncServer} or ${ROUTE_NAMING_RULES.syncClient}`,
+      `Examples: ${base}_server_v1.ts, ${base}_client_v1.ts (for example ${ROUTE_NAMING_EXAMPLES.syncServer})`,
+      "This file is ignored by route loading and type generation until it is renamed."
+    ].join(" ");
+  }
+  return null;
+};
+var getInvalidVersionMessage = (filePath) => {
+  const validationMessage = getRouteFilenameValidationMessage(filePath) || "Invalid route filename.";
+  return `// ${validationMessage}
+`;
+};
+var computeSrcRelativePath = (filePath) => {
+  try {
+    const srcDir = getSrcDir3();
+    const absolute = path10.resolve(filePath);
+    const normalizedSrc = srcDir.replaceAll("\\", "/");
+    const normalizedAbs = absolute.replaceAll("\\", "/");
+    if (!normalizedAbs.startsWith(`${normalizedSrc}/`)) return null;
+    return normalizedAbs.slice(normalizedSrc.length + 1);
+  } catch {
+    return null;
+  }
+};
+var getInvalidPagePlacementMessage = (_filePath, reason, srcRelative) => {
+  const lines = [
+    "//? --- LUCKYSTACK PLACEMENT WARNING ---",
+    "//? This page.tsx is in a location the file-based router will not route.",
+    `//? Reason: ${reason}`,
+    `//? Path:   ${srcRelative}`,
+    "//?",
+    "//? Common fixes:",
+    "//?   - Move the file up so a visible (non-underscore) folder segment remains:",
+    "//?     e.g. src/_marketing/page.tsx  ->  src/_marketing/landing/page.tsx",
+    "//?         (the new file routes at /landing \u2014 `_marketing` stays invisible).",
+    "//?   - Or move the file OUT of a reserved framework folder (_api, _sync,",
+    "//?     _components, _functions, _shared, _providers, _locales, _sockets, _server).",
+    "//?",
+    "//? Delete the file or move it to fix; the dev server will re-inject a",
+    "//? real page template once the placement is valid.",
+    "",
+    //? Named export instead of `export {};` so the file satisfies
+    //? `unicorn/require-module-specifiers` (and stays a valid ES module
+    //? without dragging in side-effect-only semantics). Reads back as a
+    //? cheap runtime tag for tooling that wants to detect the warning.
+    "export const __luckystackPlacementWarning = true;",
+    ""
+  ];
+  return lines.join("\n");
+};
+var getPairedSyncFile = (filePath) => {
+  const normalized = filePath.replaceAll("\\", "/");
+  if (isSyncServerFile(normalized)) {
+    return normalized.replace(/_server_v(\d+)\.ts$/, "_client_v$1.ts");
+  }
+  if (isSyncClientFile(normalized)) {
+    return normalized.replace(/_client_v(\d+)\.ts$/, "_server_v$1.ts");
+  }
+  return null;
+};
+var hasPairedFile = (filePath) => {
+  const pairedPath = getPairedSyncFile(filePath);
+  if (!pairedPath) return false;
+  return fs7.existsSync(pairedPath);
+};
+var extractSyncPagePath2 = (filePath) => {
+  const normalized = filePath.replaceAll("\\", "/");
+  const match = /src\/(.+?)\/_sync\//.exec(normalized);
+  return match?.[1] ?? "";
+};
+var extractSyncName2 = (filePath) => {
+  const normalized = filePath.replaceAll("\\", "/");
+  const match = /_sync\/(.+)\.ts$/.exec(normalized);
+  if (!match) {
+    const basename = path10.basename(filePath, ".ts");
+    return basename.replace(/_server_v\d+$/, "").replace(/_client_v\d+$/, "");
+  }
+  return (match[1] ?? "").replace(/_server_v\d+$/, "").replace(/_client_v\d+$/, "");
+};
+var extractClientInputFromFile = (filePath) => {
+  try {
+    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);
+    if (!clientInputMatch) return null;
+    const startIndex = content.indexOf("{", clientInputMatch.index);
+    let depth = 0;
+    let endIndex = startIndex;
+    for (let i = startIndex; i < content.length; i++) {
+      if (content[i] === "{") depth++;
+      else if (content[i] === "}") depth--;
+      if (depth === 0) {
+        endIndex = i;
+        break;
+      }
+    }
+    return content.substring(startIndex, endIndex + 1);
+  } catch (error) {
+    console.error(`[TemplateInjector] Error extracting clientInput from ${filePath}:`, error);
+    return null;
+  }
+};
+var extractClientInputFromGeneratedTypes = (pagePath, syncName) => {
+  try {
+    const generatedTypesPath = getGeneratedSocketTypesPath4();
+    const content = fs7.readFileSync(generatedTypesPath, "utf8");
+    const escapeRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+    const escapedPagePath = escapeRegex(pagePath);
+    const escapedSyncName = escapeRegex(syncName);
+    const pageBlockRegex = new RegExp(String.raw`'${escapedPagePath}'\s*:\s*\{([\s\S]*?)\n\s{2}\};`, "m");
+    const pageBlockMatch = content.match(pageBlockRegex);
+    if (!pageBlockMatch?.[1]) {
+      console.log(`[TemplateInjector] Could not find page block for ${pagePath}`);
+      return null;
+    }
+    const pageBlock = pageBlockMatch[1];
+    const syncEntryPattern = new RegExp(String.raw`'${escapedSyncName}':\s*\{\s*clientInput:\s*`);
+    const match = pageBlock.match(syncEntryPattern);
+    if (!match || typeof match.index !== "number") {
+      console.log(`[TemplateInjector] Could not find sync entry for ${pagePath}/${syncName}`);
+      return null;
+    }
+    const pageStart = content.indexOf(pageBlock);
+    const globalMatchIndex = pageStart + match.index;
+    const searchStart = globalMatchIndex + match[0].length;
+    const braceStart = content.indexOf("{", searchStart - 1);
+    if (braceStart === -1) return null;
+    let depth = 0;
+    let endIndex = braceStart;
+    for (let i = braceStart; i < content.length; i++) {
+      if (content[i] === "{") depth++;
+      else if (content[i] === "}") depth--;
+      if (depth === 0) {
+        endIndex = i;
+        break;
+      }
+    }
+    const extracted = content.substring(braceStart, endIndex + 1);
+    console.log(`[TemplateInjector] Extracted clientInput types: ${extracted}`);
+    return extracted;
+  } catch (error) {
+    console.error(`[TemplateInjector] Error extracting clientInput from generated types:`, error);
+    return null;
+  }
+};
+var calculateRelativePath = (filePath) => {
+  const normalized = filePath.replaceAll("\\", "/");
+  const srcIndex = normalized.indexOf("src/");
+  if (srcIndex === -1) {
+    console.warn(`[TemplateInjector] Could not find /src/ in path: ${filePath}`);
+    return "../../../";
+  }
+  const relativePath = normalized.slice(Math.max(0, srcIndex + 4));
+  const segments = relativePath.split("/").filter((s) => s.length > 0).length;
+  return "../".repeat(segments);
+};
+var getTemplate = (filePath) => {
+  let fileKind;
+  let hasPairedServer = false;
+  let srcRelativePath = null;
+  if (isInApiFolder(filePath)) {
+    fileKind = "api";
+  } else 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;
+    }
+  } 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);
+      }
+    }
+  } else {
+    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;
+  }
+  let content = resolveTemplateContent(templateKind);
+  if (content === null) return null;
+  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);
+  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);
+  }
+  return content;
+};
+var injectTemplate = async (filePath) => {
+  await ensureConsumerTemplateConfigLoaded();
+  if (getRouteFilenameValidationMessage(filePath)) {
+    fs7.writeFileSync(filePath, getInvalidVersionMessage(filePath), "utf-8");
+    console.log(`[TemplateInjector] Invalid route filename, injected guidance: ${filePath}`);
+    return true;
+  }
+  const template = getTemplate(filePath);
+  if (!template) {
+    return false;
+  }
+  try {
+    fs7.writeFileSync(filePath, template, "utf-8");
+    console.log(`[TemplateInjector] Injected template into: ${filePath}`);
+    return true;
+  } catch (error) {
+    console.error(`[TemplateInjector] Failed to inject template: ${filePath}`, error);
+    return false;
+  }
+};
+var shouldInjectTemplate = (filePath) => {
+  const { disableTemplateInjection } = getRoutingRules();
+  if (disableTemplateInjection && disableTemplateInjection(filePath)) {
+    return false;
+  }
+  if (!(isInApiFolder(filePath) || isInSyncFolder(filePath) || isPageFile(filePath))) {
+    return false;
+  }
+  return isEmptyFile(filePath) || isCommentOnlyFile(filePath);
+};
+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}'`;
+        }
+      );
+    }
+    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 = `
+// 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);
+      }
+    }
+    content = content.replace(
+      /^(\s*)clientInput:\s*\{[^}]*\}/m,
+      "$1clientInput: SyncClientInput<PagePath, SyncName>"
+    );
+    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"
+      );
+    }
+    fs7.writeFileSync(clientFilePath, content, "utf-8");
+    console.log(`[TemplateInjector] Updated client file to use paired types (preserved code): ${clientFilePath}`);
+    return true;
+  } catch (error) {
+    console.error(`[TemplateInjector] Failed to update client file: ${clientFilePath}`, error);
+    return false;
+  }
+};
+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 = content.replaceAll(/\n{3,}/g, "\n\n");
+    fs7.writeFileSync(clientFilePath, content, "utf-8");
+    console.log(`[TemplateInjector] Updated client file for deleted server (preserved code): ${clientFilePath}`);
+    return true;
+  } catch (error) {
+    console.error(`[TemplateInjector] Failed to update client file: ${clientFilePath}`, error);
+    return false;
+  }
+};
+var injectServerTemplateWithClientInput = async (serverFilePath, clientInputTypes) => {
+  try {
+    await ensureConsumerTemplateConfigLoaded();
+    const relPath = calculateRelativePath(serverFilePath);
+    let content = resolveTemplateContent("sync_server");
+    if (content === null) {
+      console.error(`[TemplateInjector] No sync_server template content available for: ${serverFilePath}`);
+      return false;
+    }
+    const pragmaPattern = /\/\/\s*@ts-(?:ignore|expect-error).*\r?\n(.*)\{\{REL_PATH\}\}/g;
+    content = content.replaceAll(pragmaPattern, (_, prefix) => {
+      return `${prefix}${relPath}`;
+    });
+    content = content.replaceAll("{{REL_PATH}}", relPath);
+    content = content.replace(
+      /clientInput:\s*\{[^}]*\}/s,
+      `clientInput: ${clientInputTypes}`
+    );
+    fs7.writeFileSync(serverFilePath, content, "utf-8");
+    console.log(`[TemplateInjector] Injected server template with clientInput: ${serverFilePath}`);
+    return true;
+  } catch (error) {
+    console.error(`[TemplateInjector] Failed to inject server template: ${serverFilePath}`, error);
+    return false;
+  }
+};
+
+// 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";
+var SUPPORTED_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"];
+var normalizePath3 = (value) => path11.resolve(value).replaceAll("\\", "/");
+var isSupportedScriptFile = (value) => {
+  return SUPPORTED_EXTENSIONS.some((extension) => value.endsWith(extension));
+};
+var existsFile = (value) => {
+  try {
+    return fs8.existsSync(value) && fs8.statSync(value).isFile();
+  } catch {
+    return false;
+  }
+};
+var existsDirectory = (value) => {
+  try {
+    return fs8.existsSync(value) && fs8.statSync(value).isDirectory();
+  } catch {
+    return false;
+  }
+};
+var collectScriptFiles = (dir, output) => {
+  if (!existsDirectory(dir)) {
+    return;
+  }
+  const entries = fs8.readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = path11.join(dir, entry);
+    if (existsDirectory(fullPath)) {
+      collectScriptFiles(fullPath, output);
+      continue;
+    }
+    const normalizedPath = normalizePath3(fullPath);
+    if (isSupportedScriptFile(normalizedPath)) {
+      output.add(normalizedPath);
+    }
+  }
+};
+var specifiersCache = /* @__PURE__ */ new Map();
+var scopedFilesCache = null;
+var SCOPED_FILES_TTL_MS = 1e3;
+var extractImportSpecifiers = (filePath) => {
+  let mtimeMs = 0;
+  try {
+    mtimeMs = fs8.statSync(filePath).mtimeMs;
+  } catch {
+    specifiersCache.delete(filePath);
+    return [];
+  }
+  const cached = specifiersCache.get(filePath);
+  if (cached?.mtimeMs === mtimeMs) {
+    return cached.specifiers;
+  }
+  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;
+    let match = null;
+    while ((match = importExportRegex.exec(source)) !== null) {
+      if (match[1]) specifiers.add(match[1]);
+    }
+    while ((match = dynamicImportRegex.exec(source)) !== null) {
+      if (match[1]) specifiers.add(match[1]);
+    }
+    const result = [...specifiers];
+    specifiersCache.set(filePath, { mtimeMs, specifiers: result });
+    return result;
+  } catch {
+    specifiersCache.delete(filePath);
+    return [];
+  }
+};
+var invalidateGraphForFile = (absolutePath) => {
+  specifiersCache.delete(normalizePath3(absolutePath));
+  scopedFilesCache = null;
+};
+var tryResolveWithExtensions = (basePath) => {
+  if (existsFile(basePath)) {
+    return normalizePath3(basePath);
+  }
+  for (const extension of SUPPORTED_EXTENSIONS) {
+    const withExtension = `${basePath}${extension}`;
+    if (existsFile(withExtension)) {
+      return normalizePath3(withExtension);
+    }
+  }
+  if (existsDirectory(basePath)) {
+    for (const extension of SUPPORTED_EXTENSIONS) {
+      const indexFile = path11.join(basePath, `index${extension}`);
+      if (existsFile(indexFile)) {
+        return normalizePath3(indexFile);
+      }
+    }
+  }
+  return null;
+};
+var resolveImportToFile = (importerPath, specifier) => {
+  if (!specifier || specifier.startsWith("node:")) {
+    return null;
+  }
+  if (specifier === "config") {
+    return tryResolveWithExtensions(path11.join(ROOT_DIR6, "config"));
+  }
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    const relativeBase = path11.resolve(path11.dirname(importerPath), specifier);
+    return tryResolveWithExtensions(relativeBase);
+  }
+  if (specifier.startsWith("src/") || specifier.startsWith("@/")) {
+    const sourcePath = specifier.startsWith("@/") ? specifier.slice(2) : specifier.slice(4);
+    return tryResolveWithExtensions(path11.join(getSrcDir4(), sourcePath));
+  }
+  if (specifier.startsWith("shared/")) {
+    return tryResolveWithExtensions(path11.join(getSharedDir(), specifier.slice(7)));
+  }
+  return null;
+};
+var isRouteFile = (filePath) => {
+  return filePath.includes("/src/") && (filePath.includes("/_api/") || filePath.includes("/_sync/"));
+};
+var collectScopedFiles = () => {
+  const now = Date.now();
+  if (scopedFilesCache && scopedFilesCache.expiresAt > now) {
+    return scopedFilesCache.files;
+  }
+  const files = /* @__PURE__ */ new Set();
+  collectScriptFiles(getSrcDir4(), files);
+  collectScriptFiles(getSharedDir(), files);
+  for (const dir of getServerFunctionDirs3()) {
+    collectScriptFiles(dir, files);
+  }
+  const configFile = tryResolveWithExtensions(path11.join(ROOT_DIR6, "config"));
+  if (configFile) {
+    files.add(configFile);
+  }
+  scopedFilesCache = { files, expiresAt: now + SCOPED_FILES_TTL_MS };
+  return files;
+};
+var findDependentRouteFiles = (changedFilePath) => {
+  const scopedFiles = collectScopedFiles();
+  const changedAbsolutePath = normalizePath3(changedFilePath);
+  const reverseDependencies = /* @__PURE__ */ new Map();
+  for (const filePath of scopedFiles) {
+    const specifiers = extractImportSpecifiers(filePath);
+    for (const specifier of specifiers) {
+      const resolvedImport = resolveImportToFile(filePath, specifier);
+      if (!resolvedImport || !scopedFiles.has(resolvedImport)) {
+        continue;
+      }
+      getOrInit(reverseDependencies, resolvedImport, () => /* @__PURE__ */ new Set()).add(filePath);
+    }
+  }
+  const affectedRoutes = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [changedAbsolutePath];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0) break;
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    const importers = reverseDependencies.get(current);
+    if (!importers) {
+      continue;
+    }
+    for (const importer of importers) {
+      if (isRouteFile(importer)) {
+        affectedRoutes.add(importer);
+      }
+      if (!visited.has(importer)) {
+        queue.push(importer);
+      }
+    }
+  }
+  return affectedRoutes;
+};
+
+// 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;
+    const startedAt = Date.now();
+    setImmediate(() => {
+      void (async () => {
+        const [err] = await tryCatch2(() => {
+          generateTypeMapFile({ quiet: true });
+        });
+        if (err) {
+          console.log(`[HotReload] type map regeneration failed: ${String(err)}`, "red");
+        } else {
+          console.log(`[HotReload] type map ready in ${Date.now() - startedAt}ms`, "green");
+        }
+        typeMapQueue.running = false;
+        if (typeMapQueue.pending) {
+          runTypeMapRegeneration();
+        }
+      })();
+    });
+  };
+  const requestTypeMapRegeneration = () => {
+    if (typeMapQueue.running) {
+      typeMapQueue.pending = true;
+      return;
+    }
+    runTypeMapRegeneration();
+  };
+  const isRouteDependencyFile = (normalizedPath) => {
+    if (!normalizedPath.endsWith(".ts") && !normalizedPath.endsWith(".tsx")) {
+      return false;
+    }
+    if (!normalizedPath.includes(srcSegment)) {
+      return false;
+    }
+    if (normalizedPath.includes(apiMarkerSlash) || normalizedPath.includes(syncMarkerSlash)) {
+      return false;
+    }
+    if (isGeneratedPath(normalizedPath)) {
+      return false;
+    }
+    return true;
+  };
+  const isSharedDependencyFile = (normalizedPath) => {
+    if (!(normalizedPath.endsWith(".ts") || normalizedPath.endsWith(".tsx"))) return false;
+    if (normalizedPath.includes(sharedSegment)) return true;
+    return isInServerFunctionsDir(normalizedPath);
+  };
+  const enqueueAffectedRoutesFromDependency = (changedPath) => {
+    const affectedRoutes = findDependentRouteFiles(changedPath);
+    if (affectedRoutes.size === 0) {
+      console.log(`[HotReload] No API/Sync routes depend on: ${changedPath}`, "yellow");
+      return;
+    }
+    let queuedApiCount = 0;
+    let queuedSyncCount = 0;
+    for (const routePath of affectedRoutes) {
+      if (routePath.includes(apiMarkerSlash)) {
+        pendingApiDeletes.delete(routePath);
+        pendingApiUpserts.add(routePath);
+        queuedApiCount += 1;
+      } else if (routePath.includes(syncMarkerSlash)) {
+        pendingSyncDeletes.delete(routePath);
+        pendingSyncUpserts.add(routePath);
+        queuedSyncCount += 1;
+      }
+    }
+    console.log(
+      `[HotReload] Dependency changed: ${changedPath} -> queued ${queuedApiCount} API and ${queuedSyncCount} Sync route reloads`,
+      "blue"
+    );
+    if (queuedApiCount > 0) {
+      scheduleReload("api", async () => {
+        await processPendingApiChanges();
+      });
+    }
+    if (queuedSyncCount > 0) {
+      scheduleReload("sync", async () => {
+        await processPendingSyncChanges();
+      });
+    }
+  };
+  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);
+    invalidateGraphForFile(normalizedPath);
+    const routeValidationMessage = getRouteFilenameValidationMessage(normalizedPath);
+    if (routeValidationMessage) {
+      if (shouldInjectTemplate(path13)) {
+        const injected = await injectTemplate(path13);
+        if (injected) {
+          return;
+        }
+      }
+      console.log(`[HotReload] ${routeValidationMessage}`, "yellow");
+      return;
+    }
+    if (shouldInjectTemplate(path13)) {
+      if (isSyncServerFile(normalizedPath)) {
+        const clientPath = getPairedSyncFile(normalizedPath);
+        if (clientPath && fs9.existsSync(clientPath) && !isEmptyFile(clientPath)) {
+          const clientInputTypes = extractClientInputFromFile(clientPath);
+          if (clientInputTypes) {
+            await injectServerTemplateWithClientInput(path13, clientInputTypes);
+            requestTypeMapRegeneration();
+            await updateClientFileForPairedServer(clientPath);
+            await upsertSyncFromFile(path13);
+            await upsertSyncFromFile(clientPath);
+            return;
+          }
+        }
+      }
+      const injected = await injectTemplate(path13);
+      if (injected) {
+        return;
+      }
+    }
+    if (normalizedPath.includes(apiMarkerNoLead)) {
+      pendingApiDeletes.delete(normalizedPath);
+      pendingApiUpserts.add(normalizedPath);
+      scheduleReload("api", async () => {
+        await processPendingApiChanges({ regenerateTypeMap: true });
+      });
+      return;
+    }
+    if (normalizedPath.includes(syncMarkerNoLead)) {
+      pendingSyncDeletes.delete(normalizedPath);
+      pendingSyncUpserts.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");
+    }
+  };
+  const handleChange = async (path13) => {
+    const normalizedPath = normalizeFsPath(path13);
+    invalidateGraphForFile(normalizedPath);
+    const routeValidationMessage = getRouteFilenameValidationMessage(normalizedPath);
+    if (routeValidationMessage) {
+      if (shouldInjectTemplate(path13)) {
+        const injected = await injectTemplate(path13);
+        if (injected) {
+          return;
+        }
+      }
+      console.log(`[HotReload] ${routeValidationMessage}`, "yellow");
+      return;
+    }
+    if (shouldInjectTemplate(path13)) {
+      const injected = await injectTemplate(path13);
+      if (injected) {
+        return;
+      }
+    }
+    if (isGeneratedPath(normalizedPath)) {
+      return;
+    }
+    if (isLocaleFile(normalizedPath)) {
+      scheduleReload("locales", async () => {
+        await getLocaleReloader()?.();
+      });
+      return;
+    }
+    if (isRouteDependencyFile(normalizedPath)) {
+      scheduleReload("typemap", () => {
+        console.log(`[HotReload] Route dependency changed, scheduling type map regeneration`, "blue");
+        requestTypeMapRegeneration();
+      });
+      enqueueAffectedRoutesFromDependency(normalizedPath);
+      return;
+    }
+    if (isTypeMapRelevantFile(normalizedPath)) {
+      scheduleReload("typemap", () => {
+        console.log(`[HotReload] Route dependency changed, scheduling type map regeneration`, "blue");
+        requestTypeMapRegeneration();
+      });
+    }
+    if (normalizedPath.includes(apiMarkerNoLead)) {
+      scheduleReload("typemap", () => {
+        console.log(`[HotReload] API changed, scheduling type map regeneration`, "blue");
+        requestTypeMapRegeneration();
+      });
+      pendingApiDeletes.delete(normalizedPath);
+      pendingApiUpserts.add(normalizedPath);
+      scheduleReload("api", async () => {
+        await processPendingApiChanges();
+      });
+    } else if (normalizedPath.includes(syncMarkerNoLead)) {
+      scheduleReload("typemap", () => {
+        console.log(`[HotReload] Sync changed, scheduling type map regeneration`, "blue");
+        requestTypeMapRegeneration();
+      });
+      pendingSyncDeletes.delete(normalizedPath);
+      pendingSyncUpserts.add(normalizedPath);
+      scheduleReload("sync", async () => {
+        await processPendingSyncChanges();
+      });
+    }
+  };
+  const handleFunctionChange = (changedPath) => {
+    const normalizedPath = normalizeFsPath(changedPath);
+    invalidateGraphForFile(normalizedPath);
+    scheduleReload("functions", async () => {
+      requestTypeMapRegeneration();
+      await initializeFunctions();
+    });
+    if (isSharedDependencyFile(normalizedPath)) {
+      enqueueAffectedRoutesFromDependency(normalizedPath);
+    }
+  };
+  const handleDelete = async (path13) => {
+    const normalizedPath = normalizeFsPath(path13);
+    invalidateGraphForFile(normalizedPath);
+    if (isGeneratedPath(normalizedPath)) {
+      return;
+    }
+    if (isLocaleFile(normalizedPath)) {
+      scheduleReload("locales", async () => {
+        await getLocaleReloader()?.();
+      });
+      return;
+    }
+    if (isRouteDependencyFile(normalizedPath)) {
+      scheduleReload("typemap", () => {
+        console.log(`[HotReload] Route dependency deleted, scheduling type map regeneration`, "blue");
+        requestTypeMapRegeneration();
+      });
+      enqueueAffectedRoutesFromDependency(normalizedPath);
+      return;
+    }
+    if (isTypeMapRelevantFile(normalizedPath)) {
+      scheduleReload("typemap", () => {
+        console.log(`[HotReload] Route dependency deleted, scheduling type map regeneration`, "blue");
+        requestTypeMapRegeneration();
+      });
+    }
+    if (normalizedPath.includes(apiMarkerNoLead)) {
+      scheduleReload("typemap", () => {
+        console.log(`[HotReload] API deleted, scheduling type map regeneration`, "blue");
+        requestTypeMapRegeneration();
+      });
+      pendingApiUpserts.delete(normalizedPath);
+      pendingApiDeletes.add(normalizedPath);
+      scheduleReload("api", async () => {
+        await processPendingApiChanges();
+      });
+    } else if (normalizedPath.includes(syncMarkerNoLead)) {
+      scheduleReload("typemap", () => {
+        console.log(`[HotReload] Sync deleted, scheduling type map regeneration`, "blue");
+        requestTypeMapRegeneration();
+      });
+      pendingSyncUpserts.delete(normalizedPath);
+      pendingSyncDeletes.add(normalizedPath);
+      scheduleReload("sync", async () => {
+        if (isSyncServerFile(normalizedPath)) {
+          const clientPath = getPairedSyncFile(normalizedPath);
+          if (clientPath && fs9.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 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);
+  setImmediate(() => {
+    void (async () => {
+      const [err] = await tryCatch2(() => {
+        generateTypeMapFile({ quiet: true });
+      });
+      if (err) {
+        console.log(`[HotReload] initial type map generation failed: ${String(err)}`, "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,
+  BUILT_IN_TEMPLATE_KINDS,
+  DEFAULT_DASHBOARD_PATH_PATTERN,
+  SYNC_VERSION_TOKEN_REGEX,
+  apiMarkerSegment,
+  assertNoDuplicateNormalizedRouteKeys,
+  assertValidRouteNaming,
+  clearRuntimeTypeResolverCache,
+  clearTemplateOverrides,
+  clearTemplateRules,
+  devApis,
+  devFunctions,
+  devSyncs,
+  generateTypeMapFile,
+  getInputTypeFromFile,
+  getRegisteredTemplate,
+  getRoutingRules,
+  getSyncClientDataType,
+  getTemplateRules,
+  initializeAll,
+  initializeApis,
+  initializeFunctions,
+  initializeSyncs,
+  isApiFileName,
+  isSyncClientFileName,
+  isSyncFileName,
+  isSyncServerFileName,
+  listRegisteredTemplateKinds,
+  registerDefaultTemplateRules,
+  registerRoutingRules,
+  registerTemplate,
+  registerTemplateKind,
+  registerTemplateRule,
+  removeApiFromFile,
+  removeSyncFromFile,
+  resolveRuntimeTypeText,
+  resolveTemplateKind,
+  setupWatchers,
+  syncMarkerSegment,
+  upsertApiFromFile,
+  upsertSyncFromFile,
+  validateDeploy
+};
+//# sourceMappingURL=index.js.map