@luckystack/devkit 0.10.1 → 0.11.0

package/dist/index.js

@@ -567,34 +567,98 @@ var extractSyncVersion = (filePath) => {
 };
 
 // src/typeMap/apiMeta.ts
-import * as ts from "typescript";
-import fs3 from "fs";
+import fs4 from "fs";
+import {
+  getJSDocTags,
+  SyntaxKind
+} from "typescript-7-api/ast";
+import {
+  isArrayLiteralExpression,
+  isAsExpression,
+  isIdentifier,
+  isNumericLiteral,
+  isObjectLiteralExpression,
+  isParenthesizedExpression,
+  isPropertyAssignment,
+  isSatisfiesExpression,
+  isStringLiteral,
+  isVariableStatement
+} from "typescript-7-api/ast/is";
 import { inferHttpMethod, tryCatchSync } from "@luckystack/core";
+
+// src/typeMap/tsApi.ts
+import fs3 from "fs";
+import path4 from "path";
+import { API } from "typescript-7-api/sync";
+import { ROOT_DIR as ROOT_DIR3 } from "@luckystack/core";
+var api = null;
+var serverSnapshot = null;
+var serverProject = null;
+var getTsApi = () => {
+  api ??= new API({ cwd: ROOT_DIR3 });
+  return api;
+};
+var openTsconfigProject = (tsconfigPath) => {
+  const tsApi = getTsApi();
+  const { fileNames, options } = tsApi.parseConfigFile(tsconfigPath);
+  const snapshot = tsApi.createSnapshot({ createPrograms: [{ rootFiles: fileNames, compilerOptions: options }] });
+  const [program] = snapshot.operation.createdPrograms;
+  return { project: program.getProject(), snapshot };
+};
+var getServerProgram = () => {
+  if (serverProject) return serverProject;
+  const tsconfigPath = path4.join(ROOT_DIR3, "tsconfig.server.json");
+  if (!fs3.existsSync(tsconfigPath)) throw new Error("[TypeProgram] tsconfig.server.json not found");
+  const { project, snapshot } = openTsconfigProject(tsconfigPath);
+  serverSnapshot = snapshot;
+  serverProject = project;
+  return project;
+};
+var invalidateProgramCache = () => {
+  serverSnapshot?.dispose();
+  serverSnapshot = null;
+  serverProject = null;
+};
+var disposeTsApi = () => {
+  invalidateProgramCache();
+  api?.close();
+  api = null;
+};
+var parseSourceText = (fileName, text, scriptKind) => {
+  const retained = getTsApi().createSourceFile(fileName, text, scriptKind === void 0 ? void 0 : { scriptKind });
+  retained.dispose();
+  return retained.sourceFile;
+};
+var transpileSourceText = (fileName, text) => {
+  return getTsApi().transpileModule(text, { fileName, reportDiagnostics: true });
+};
+
+// src/typeMap/apiMeta.ts
 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 (!isVariableStatement(statement)) continue;
+    const hasExport = statement.modifiers?.some((m) => m.kind === SyntaxKind.ExportKeyword);
     if (!hasExport) continue;
     for (const decl of statement.declarationList.declarations) {
-      if (ts.isIdentifier(decl.name) && decl.name.text === name) return decl;
+      if (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)) {
+  while (isAsExpression(current) || isSatisfiesExpression(current) || isParenthesizedExpression(current)) {
     current = current.expression;
   }
   return current;
 };
 var extractHttpMethod = (filePath, apiName) => {
   const [error, method] = tryCatchSync(() => {
-    const content = fs3.readFileSync(filePath, "utf8");
-    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const content = fs4.readFileSync(filePath, "utf8");
+    const sourceFile = parseSourceText(filePath, content);
     const decl = findExportedConst(sourceFile, "httpMethod");
     const initializer = decl?.initializer ? unwrapExpression(decl.initializer) : void 0;
-    if (initializer && ts.isStringLiteral(initializer)) {
+    if (initializer && isStringLiteral(initializer)) {
       const candidate = initializer.text.toUpperCase();
       if (["GET", "POST", "PUT", "DELETE"].includes(candidate)) return candidate;
     }
@@ -607,13 +671,13 @@ var extractHttpMethod = (filePath, apiName) => {
 };
 var extractRateLimit = (filePath) => {
   const [error, rateLimit] = tryCatchSync(() => {
-    const content = fs3.readFileSync(filePath, "utf8");
-    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const content = fs4.readFileSync(filePath, "utf8");
+    const sourceFile = parseSourceText(filePath, content);
     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);
+      if (initializer.kind === SyntaxKind.FalseKeyword) return false;
+      if (isNumericLiteral(initializer)) return Number(initializer.text);
     }
     return void 0;
   });
@@ -624,16 +688,16 @@ var extractRateLimit = (filePath) => {
 };
 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;
+  if (isStringLiteral(node)) return node.text;
+  if (isNumericLiteral(node)) return Number(node.text);
+  if (node.kind === SyntaxKind.TrueKeyword) return true;
+  if (node.kind === 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;
+    if (!isPropertyAssignment(prop) || !isIdentifier(prop.name)) continue;
     const value = readPrimitive(prop.initializer);
     if (value !== void 0) item[prop.name.text] = value;
   }
@@ -653,8 +717,8 @@ var commentToString = (commentValue) => {
 };
 var extractDocsMeta = (filePath) => {
   const [error, docsMeta] = tryCatchSync(() => {
-    const content = fs3.readFileSync(filePath, "utf8");
-    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const content = fs4.readFileSync(filePath, "utf8");
+    const sourceFile = parseSourceText(filePath, content);
     const result = {};
     const consumeTag = (tag) => {
       if (tag.tagName.text !== "docs") return;
@@ -673,7 +737,7 @@ var extractDocsMeta = (filePath) => {
       }
     };
     for (const statement of sourceFile.statements) {
-      for (const tag of ts.getJSDocTags(statement)) {
+      for (const tag of getJSDocTags(statement)) {
         consumeTag(tag);
       }
     }
@@ -690,25 +754,25 @@ var extractDocsMeta = (filePath) => {
 };
 var extractAuth = (filePath) => {
   const [, auth] = tryCatchSync(() => {
-    const content = fs3.readFileSync(filePath, "utf8");
-    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const content = fs4.readFileSync(filePath, "utf8");
+    const sourceFile = parseSourceText(filePath, content);
     const decl = findExportedConst(sourceFile, "auth");
     const authInitializer = decl?.initializer ? unwrapExpression(decl.initializer) : void 0;
-    if (!authInitializer || !ts.isObjectLiteralExpression(authInitializer)) return { login: false, hasAdditional: false };
+    if (!authInitializer || !isObjectLiteralExpression(authInitializer)) return { login: false, hasAdditional: false };
     let login = false;
     let additional;
     let hasAdditional = false;
     for (const prop of authInitializer.properties) {
-      if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+      if (!isPropertyAssignment(prop) || !isIdentifier(prop.name)) continue;
       const propInit = unwrapExpression(prop.initializer);
       if (prop.name.text === "login") {
-        login = propInit.kind === ts.SyntaxKind.TrueKeyword;
+        login = propInit.kind === SyntaxKind.TrueKeyword;
       }
-      if (prop.name.text === "additional" && ts.isArrayLiteralExpression(propInit)) {
+      if (prop.name.text === "additional" && isArrayLiteralExpression(propInit)) {
         hasAdditional = propInit.elements.length > 0;
         additional = [];
         for (const element of propInit.elements) {
-          if (!ts.isObjectLiteralExpression(element)) continue;
+          if (!isObjectLiteralExpression(element)) continue;
           const item = parseAdditionalItem(element);
           if (item) additional.push(item);
         }
@@ -720,46 +784,78 @@ var extractAuth = (filePath) => {
 };
 
 // src/typeMap/emitterArtifacts.ts
-import fs4 from "fs";
-import path4 from "path";
-import * as ts3 from "typescript";
+import fs5 from "fs";
+import path5 from "path";
+import {
+  ScriptKind
+} from "typescript-7-api/ast";
+import {
+  isClassDeclaration,
+  isEnumDeclaration,
+  isFunctionDeclaration,
+  isIdentifier as isIdentifier3,
+  isImportDeclaration,
+  isInferTypeNode,
+  isInterfaceDeclaration,
+  isMappedTypeNode,
+  isNamedImports,
+  isNamespaceImport,
+  isQualifiedName,
+  isTypeAliasDeclaration as isTypeAliasDeclaration2,
+  isTypeReferenceNode as isTypeReferenceNode2
+} from "typescript-7-api/ast/is";
 import { getGeneratedApiDocsPath, getGeneratedApiSchemasPath, getGeneratedSocketTypesPath } from "@luckystack/core";
 
 // src/typeMap/zodEmitter.ts
-import * as ts2 from "typescript";
+import { SyntaxKind as SyntaxKind2 } from "typescript-7-api/ast";
+import {
+  isArrayTypeNode,
+  isIdentifier as isIdentifier2,
+  isIndexSignatureDeclaration,
+  isIntersectionTypeNode,
+  isLiteralTypeNode,
+  isNumericLiteral as isNumericLiteral2,
+  isParenthesizedTypeNode,
+  isPropertySignatureDeclaration,
+  isStringLiteral as isStringLiteral2,
+  isTypeAliasDeclaration,
+  isTypeLiteralNode,
+  isTypeReferenceNode,
+  isUnionTypeNode
+} from "typescript-7-api/ast/is";
 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)) {
+  if (node.kind === SyntaxKind2.StringKeyword) return "z.string()";
+  if (node.kind === SyntaxKind2.NumberKeyword) return "z.number()";
+  if (node.kind === SyntaxKind2.BooleanKeyword) return "z.boolean()";
+  if (node.kind === SyntaxKind2.NullKeyword) return "z.null()";
+  if (node.kind === SyntaxKind2.UndefinedKeyword) return "z.undefined()";
+  if (node.kind === SyntaxKind2.AnyKeyword) return "z.any()";
+  if (node.kind === SyntaxKind2.UnknownKeyword) return "z.unknown()";
+  if (node.kind === SyntaxKind2.NeverKeyword) return "z.never()";
+  if (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()";
+    if (isStringLiteral2(literal)) return `z.literal(${JSON.stringify(literal.text)})`;
+    if (isNumericLiteral2(literal)) return `z.literal(${literal.text})`;
+    if (literal.kind === SyntaxKind2.TrueKeyword) return "z.literal(true)";
+    if (literal.kind === SyntaxKind2.FalseKeyword) return "z.literal(false)";
+    if (literal.kind === SyntaxKind2.NullKeyword) return "z.null()";
     return anyFallback("unknown literal");
   }
-  if (ts2.isArrayTypeNode(node)) {
+  if (isArrayTypeNode(node)) {
     return `z.array(${convertTypeNode(node.elementType)})`;
   }
-  if (ts2.isUnionTypeNode(node)) {
+  if (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);
+    const hasUndefined = members.some((m) => m.kind === SyntaxKind2.UndefinedKeyword);
+    const nonUndef = members.filter((m) => m.kind !== SyntaxKind2.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)) {
+  if (isTypeReferenceNode(node)) {
     const name = node.typeName.getText();
     const args = node.typeArguments ?? [];
     switch (name) {
@@ -787,10 +883,10 @@ var convertTypeNode = (node) => {
       }
     }
   }
-  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) {
+  if (isTypeLiteralNode(node)) {
+    const indexSignatures = node.members.filter((m) => isIndexSignatureDeclaration(m));
+    const propertySignatures = node.members.filter((m) => isPropertySignatureDeclaration(m));
+    if (indexSignatures.length === 1 && propertySignatures.length === 0 && indexSignatures[0]?.type.kind === SyntaxKind2.NeverKeyword) {
       return "z.object({}).strict()";
     }
     if (indexSignatures.length > 0 && propertySignatures.length === 0) {
@@ -802,21 +898,21 @@ var convertTypeNode = (node) => {
       }
     }
     const entries = propertySignatures.map((prop) => {
-      if (!ts2.isIdentifier(prop.name)) return null;
+      if (!isIdentifier2(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()")) {
+      if (prop.postfixToken?.kind === SyntaxKind2.QuestionToken && !schema.endsWith(".optional()")) {
         schema = wrapOptional(schema);
       }
       return `${JSON.stringify(name)}: ${schema}`;
     }).filter((entry) => entry !== null);
     return `z.object({ ${entries.join(", ")} }).strict()`;
   }
-  if (ts2.isParenthesizedTypeNode(node)) {
+  if (isParenthesizedTypeNode(node)) {
     return convertTypeNode(node.type);
   }
-  if (ts2.isIntersectionTypeNode(node)) {
+  if (isIntersectionTypeNode(node)) {
     return anyFallback("intersection not yet supported");
   }
   return anyFallback(`unsupported TypeNode kind=${String(node.kind)}`);
@@ -825,9 +921,9 @@ 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 source = parseSourceText("__zod.ts", synthetic);
   const statement = source.statements[0];
-  if (!statement || !ts2.isTypeAliasDeclaration(statement)) return null;
+  if (!statement || !isTypeAliasDeclaration(statement)) return null;
   return convertTypeNode(statement.type);
 };
 
@@ -867,6 +963,75 @@ var findExtractionFailure = (route, kind, field) => {
 };
 
 // src/typeMap/emitterArtifacts.ts
+var compareVersions = (a, b) => a.version.localeCompare(b.version, void 0, { numeric: true });
+var renderRouteMetaFields = (authValue, rateLimit) => {
+  const auth = authValue && typeof authValue === "object" ? authValue : { login: false, hasAdditional: false };
+  const rateLimitPart = rateLimit === void 0 ? "" : `, rateLimit: ${rateLimit === false ? "false" : String(rateLimit)}`;
+  const additionalPart = auth.additional && auth.additional.length > 0 ? `, additional: ${JSON.stringify(auth.additional)}` : "";
+  return `auth: { login: ${auth.login ? "true" : "false"}${additionalPart}${auth.hasAdditional ? ", hasAdditional: true" : ""} }${rateLimitPart}`;
+};
+var inputSchemaSource = (typeText) => typeTextToZodSource(typeText) ?? "z.any() /* unparseable input type */";
+var groupServerSyncRoutes = (syncTypesByPage) => {
+  const pages = [];
+  for (const pagePath of [...syncTypesByPage.keys()].toSorted()) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const [syncKey, entry] of mustGet(syncTypesByPage, pagePath, "syncTypesByPage")) {
+      if (!entry.serverMeta) continue;
+      const { name, version } = splitVersionedKey(syncKey);
+      getOrInit(grouped, name, () => []).push({ version, clientInput: entry.clientInput, serverMeta: entry.serverMeta });
+    }
+    if (grouped.size === 0) continue;
+    pages.push([
+      pagePath,
+      [...grouped.keys()].toSorted().map((name) => [name, mustGet(grouped, name, "grouped").toSorted(compareVersions)])
+    ]);
+  }
+  return pages;
+};
+var renderServerSyncRouteMap = (syncTypesByPage, renderValue) => {
+  let body = "";
+  for (const [pagePath, syncs] of groupServerSyncRoutes(syncTypesByPage)) {
+    body += `  '${pagePath}': {
+`;
+    for (const [syncName, routes] of syncs) {
+      body += `    '${syncName}': {
+`;
+      for (const route of routes) {
+        body += `      '${route.version}': ${renderValue(route)},
+`;
+      }
+      body += `    },
+`;
+    }
+    body += `  },
+`;
+  }
+  return body;
+};
+var buildSyncMetaMapSource = (syncTypesByPage) => `export interface SyncMetaEntry {
+	auth: { login: boolean; additional?: Record<string, unknown>[]; hasAdditional?: boolean };
+	rateLimit?: number | false;
+}
+
+export const syncMetaMap: Record<string, Record<string, Record<string, SyncMetaEntry>>> = {
+${renderServerSyncRouteMap(syncTypesByPage, (route) => `{ ${renderRouteMetaFields(route.serverMeta.auth, route.serverMeta.rateLimit)} }`)}};
+
+export const getSyncMeta = (pagePath: string, syncName: string, version: string): SyncMetaEntry | undefined => {
+	return syncMetaMap[pagePath]?.[syncName]?.[version];
+};
+`;
+var buildSyncInputSchemasSource = (syncTypesByPage) => `
+export const syncInputSchemas: Record<string, Record<string, Record<string, z.ZodTypeAny>>> = {
+${renderServerSyncRouteMap(syncTypesByPage, (route) => inputSchemaSource(route.clientInput))}};
+
+export const getSyncInputSchema = (
+	pagePath: string,
+	syncName: string,
+	version: string,
+): z.ZodTypeAny | undefined => {
+	return syncInputSchemas[pagePath]?.[syncName]?.[version];
+};
+`;
 var buildImportStatements = ({
   namedImports,
   defaultImports
@@ -887,13 +1052,13 @@ var splitVersionedKey = (value) => {
   return { name: name ?? "", version: version ?? "v1" };
 };
 var writeFileIfChanged = (filePath, content) => {
-  if (fs4.existsSync(filePath)) {
-    const currentContent = fs4.readFileSync(filePath, "utf8");
+  if (fs5.existsSync(filePath)) {
+    const currentContent = fs5.readFileSync(filePath, "utf8");
     if (currentContent === content) {
       return false;
     }
   }
-  fs4.writeFileSync(filePath, content, "utf8");
+  fs5.writeFileSync(filePath, content, "utf8");
   return true;
 };
 var indentStr = (str, indentText) => {
@@ -932,7 +1097,7 @@ var stripSymbolKeyedMembers = (text) => {
   return result;
 };
 var validateGeneratedTypeIdentifiers = (content) => {
-  const sourceFile = ts3.createSourceFile("apiTypes.generated.ts", content, ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
+  const sourceFile = parseSourceText("apiTypes.generated.ts", content, ScriptKind.TS);
   const knownSymbols = /* @__PURE__ */ new Set();
   const referencedSymbols = /* @__PURE__ */ new Set();
   const builtIns = /* @__PURE__ */ new Set([
@@ -989,38 +1154,38 @@ var validateGeneratedTypeIdentifiers = (content) => {
     }
   };
   const collectKnownSymbols = (node) => {
-    if (ts3.isInferTypeNode(node)) {
+    if (isInferTypeNode(node)) {
       knownSymbols.add(node.typeParameter.name.text);
     }
-    if (ts3.isMappedTypeNode(node)) {
+    if (isMappedTypeNode(node)) {
       knownSymbols.add(node.typeParameter.name.text);
     }
-    if (ts3.isImportDeclaration(node)) {
+    if (isImportDeclaration(node)) {
       const importClause = node.importClause;
       if (importClause?.name) knownSymbols.add(importClause.name.text);
-      if (importClause?.namedBindings && ts3.isNamedImports(importClause.namedBindings)) {
+      if (importClause?.namedBindings && isNamedImports(importClause.namedBindings)) {
         for (const importElement of importClause.namedBindings.elements) {
           knownSymbols.add((importElement.propertyName ?? importElement.name).text);
         }
       }
-      if (importClause?.namedBindings && ts3.isNamespaceImport(importClause.namedBindings)) {
+      if (importClause?.namedBindings && 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)) {
+    if (isInterfaceDeclaration(node) || isTypeAliasDeclaration2(node) || isClassDeclaration(node) || isEnumDeclaration(node) || isFunctionDeclaration(node)) {
       addDeclaredName(node.name);
       collectTypeParams(node);
     }
-    if (ts3.isTypeReferenceNode(node)) {
+    if (isTypeReferenceNode2(node)) {
       const typeName = node.typeName;
-      if (ts3.isIdentifier(typeName)) {
+      if (isIdentifier3(typeName)) {
         referencedSymbols.add(typeName.text);
       }
-      if (ts3.isQualifiedName(typeName) && ts3.isIdentifier(typeName.left)) {
+      if (isQualifiedName(typeName) && isIdentifier3(typeName.left)) {
         referencedSymbols.add(typeName.left.text);
       }
     }
-    ts3.forEachChild(node, collectKnownSymbols);
+    node.forEachChild(collectKnownSymbols);
   };
   collectKnownSymbols(sourceFile);
   const unknown = [...referencedSymbols].filter((name) => !knownSymbols.has(name) && !builtIns.has(name)).toSorted();
@@ -1060,7 +1225,7 @@ var collectFallbacks = (typesByPage, syncTypesByPage) => {
     for (const [syncKey, entry] of syncs) {
       const { name, version } = splitVersionedKey(syncKey);
       const route = `${pagePath}/${name}@${version}`;
-      flagField(route, "sync", "clientInput", entry.clientInput);
+      flagField(route, "sync", "clientInput", entry.clientInput, entry.serverMeta !== void 0);
       flagField(route, "sync", "serverOutput", entry.serverOutput, false, !entry.hasServer);
       flagField(route, "sync", "clientOutput", entry.clientOutput, false, !entry.hasClient);
       flagField(route, "sync", "serverStream", entry.serverStream);
@@ -1254,10 +1419,7 @@ export const apiMetaMap: Record<string, Record<string, Record<string, ApiMetaEnt
       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: false, hasAdditional: false };
-        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}${auth.hasAdditional ? ", hasAdditional: true" : ""} }${rateLimitPart} },
+        content += `      '${version}': { method: '${entry.method}', ${renderRouteMetaFields(entry.auth, entry.rateLimit)} },
 `;
       }
       content += `    },
@@ -1272,6 +1434,7 @@ export const getApiMeta = (pagePath: string, apiName: string, version: string):
 	return apiMetaMap[pagePath]?.[apiName]?.[version];
 };
 
+${buildSyncMetaMapSource(syncTypesByPage)}
 // Sync Type Definitions
 // 
 
@@ -1371,7 +1534,7 @@ declare module '@luckystack/core/typemap' {
 `;
   content = stripSymbolKeyedMembers(content);
   validateGeneratedTypeIdentifiers(content);
-  const schemasContent = buildSchemasContent({ typesByPage });
+  const schemasContent = buildSchemasContent({ typesByPage, syncTypesByPage });
   const fallbacks = collectFallbacks(typesByPage, syncTypesByPage);
   const totalRoutes = [...typesByPage.values()].reduce((n, m) => n + m.size, 0) + [...syncTypesByPage.values()].reduce((n, m) => n + m.size, 0);
   const diagnosticsData = {
@@ -1383,11 +1546,13 @@ declare module '@luckystack/core/typemap' {
   return { content, docsData, schemasContent, diagnosticsData };
 };
 var buildSchemasContent = ({
-  typesByPage
+  typesByPage,
+  syncTypesByPage
 }) => {
   const sortedPages = [...typesByPage.keys()].toSorted();
   let body = `/* eslint-disable */
-//? Auto-generated Zod schemas for every API input. Driven by the same walk
+//? Auto-generated Zod schemas for every API input and every sync-server
+//? clientInput. 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.
@@ -1412,8 +1577,7 @@ export const apiInputSchemas: Record<string, Record<string, Record<string, z.Zod
       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 += `      '${version}': ${inputSchemaSource(entry.input)},
 `;
       }
       body += `    },
@@ -1432,6 +1596,7 @@ export const getApiInputSchema = (
 	return apiInputSchemas[pagePath]?.[apiName]?.[version];
 };
 `;
+  body += buildSyncInputSchemasSource(syncTypesByPage);
   return body;
 };
 var writeTypeMapArtifacts = ({
@@ -1453,9 +1618,9 @@ var writeTypeMapArtifacts = ({
       }
     }
     const docsPath = getGeneratedApiDocsPath();
-    const docsDir = path4.dirname(docsPath);
-    if (!fs4.existsSync(docsDir)) {
-      fs4.mkdirSync(docsDir, { recursive: true });
+    const docsDir = path5.dirname(docsPath);
+    if (!fs5.existsSync(docsDir)) {
+      fs5.mkdirSync(docsDir, { recursive: true });
     }
     const docsContent = JSON.stringify(docsData, null, 2);
     const hasUpdatedDocs = writeFileIfChanged(docsPath, docsContent);
@@ -1463,7 +1628,7 @@ var writeTypeMapArtifacts = ({
       console.log("[TypeMapGenerator] Generated apiDocs.generated.json");
     }
     if (diagnosticsData !== void 0) {
-      const diagnosticsPath = path4.join(path4.dirname(docsPath), "apiTypeDiagnostics.generated.json");
+      const diagnosticsPath = path5.join(path5.dirname(docsPath), "apiTypeDiagnostics.generated.json");
       const diagnosticsContent = JSON.stringify(diagnosticsData, null, 2);
       const hasUpdatedDiagnostics = writeFileIfChanged(diagnosticsPath, diagnosticsContent);
       if (hasUpdatedDiagnostics) {
@@ -1479,30 +1644,46 @@ var writeTypeMapArtifacts = ({
 };
 
 // src/typeMap/extractors.ts
-import * as ts5 from "typescript";
-import path6 from "path";
+import path7 from "path";
+import { SymbolFlags as SymbolFlags2 } from "typescript-7-api/sync";
+import {
+  ScriptKind as ScriptKind2
+} from "typescript-7-api/ast";
+import {
+  isArrowFunction,
+  isCallExpression,
+  isFunctionDeclaration as isFunctionDeclaration2,
+  isFunctionExpression,
+  isIdentifier as isIdentifier5,
+  isInterfaceDeclaration as isInterfaceDeclaration2,
+  isObjectLiteralExpression as isObjectLiteralExpression2,
+  isPropertySignatureDeclaration as isPropertySignatureDeclaration2,
+  isReturnStatement,
+  isTypeReferenceNode as isTypeReferenceNode3,
+  isVariableStatement as isVariableStatement2
+} from "typescript-7-api/ast/is";
 
 // src/typeMap/tsProgram.ts
-import * as ts4 from "typescript";
-import path5 from "path";
-import { ROOT_DIR as ROOT_DIR3, getGeneratedSocketTypesPath as getGeneratedSocketTypesPath2 } from "@luckystack/core";
-var cachedProgram = null;
-var getServerProgram = () => {
-  if (cachedProgram) return cachedProgram;
-  const tsconfigPath = ts4.findConfigFile(ROOT_DIR3, ts4.sys.fileExists.bind(ts4.sys), "tsconfig.server.json");
-  if (!tsconfigPath) throw new Error("[TypeProgram] tsconfig.server.json not found");
-  const { config } = ts4.readConfigFile(tsconfigPath, ts4.sys.readFile.bind(ts4.sys));
-  const { options, fileNames } = ts4.parseJsonConfigFileContent(
-    config,
-    ts4.sys,
-    path5.dirname(tsconfigPath)
-  );
-  cachedProgram = ts4.createProgram(fileNames, options);
-  return cachedProgram;
-};
-var invalidateProgramCache = () => {
-  cachedProgram = null;
-};
+import path6 from "path";
+import {
+  ObjectFlags,
+  SymbolFlags,
+  TypeFlags
+} from "typescript-7-api/sync";
+import { SyntaxKind as SyntaxKind3 } from "typescript-7-api/ast";
+import {
+  isAsExpression as isAsExpression2,
+  isIdentifier as isIdentifier4,
+  isNoSubstitutionTemplateLiteral,
+  isNumericLiteral as isNumericLiteral3,
+  isParenthesizedExpression as isParenthesizedExpression2,
+  isPrefixUnaryExpression,
+  isPropertyAssignment as isPropertyAssignment2,
+  isShorthandPropertyAssignment,
+  isStringLiteral as isStringLiteral3,
+  isTypeAssertion
+} from "typescript-7-api/ast/is";
+import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath2 } from "@luckystack/core";
 var DEPTH_LIMIT = 14;
 var JSON_TYPE_NAMES = /* @__PURE__ */ new Set([
   "Json",
@@ -1552,35 +1733,35 @@ var UnsupportedWireTypeError = class extends Error {
   }
 };
 var isJsonLikeType = (type, checker) => {
-  const symbolName = type.symbol?.name ?? "";
-  const aliasName = type.aliasSymbol?.name ?? "";
+  const symbolName = type.getSymbol()?.name ?? "";
+  const aliasName = type.getAliasSymbol()?.name ?? "";
   if (JSON_TYPE_NAMES.has(symbolName) || JSON_TYPE_NAMES.has(aliasName)) return true;
   const rendered = checker.typeToString(type).trim();
   return /^(?:Prisma\.)?(?:Input)?Json(?:Value|Object|Array)$/.test(rendered);
 };
 var getLiteralTypeFromExpression = (expression, checker, depth) => {
-  if (ts4.isParenthesizedExpression(expression)) {
+  if (isParenthesizedExpression2(expression)) {
     return getLiteralTypeFromExpression(expression.expression, checker, depth);
   }
-  if (ts4.isAsExpression(expression) || ts4.isTypeAssertionExpression(expression)) {
+  if (isAsExpression2(expression) || isTypeAssertion(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)) {
+  if (expression.kind === SyntaxKind3.TrueKeyword) return "true";
+  if (expression.kind === SyntaxKind3.FalseKeyword) return "false";
+  if (expression.kind === SyntaxKind3.NullKeyword) return "null";
+  if (isStringLiteral3(expression) || isNoSubstitutionTemplateLiteral(expression)) {
     return `'${expression.text.replaceAll("\\", "\\\\").replaceAll("'", String.raw`\'`)}'`;
   }
-  if (ts4.isNumericLiteral(expression)) {
+  if (isNumericLiteral3(expression)) {
     return expression.text;
   }
-  if (ts4.isPrefixUnaryExpression(expression) && expression.operator === ts4.SyntaxKind.MinusToken && ts4.isNumericLiteral(expression.operand)) {
+  if (isPrefixUnaryExpression(expression) && expression.operator === SyntaxKind3.MinusToken && isNumericLiteral3(expression.operand)) {
     return `-${expression.operand.text}`;
   }
-  if (ts4.isIdentifier(expression)) {
+  if (isIdentifier4(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 isLiteralType = (identifierType.flags & (TypeFlags.StringLiteral | TypeFlags.NumberLiteral | TypeFlags.BooleanLiteral | TypeFlags.Null | TypeFlags.Undefined)) !== 0;
+    if (isLiteralType || identifierType.isUnionType()) {
       const expanded = expandTypeDetailed(identifierType, checker, depth).text;
       if (expanded.includes("'") || /\btrue\b|\bfalse\b|\bnull\b|\bundefined\b/.test(expanded)) {
         return expanded;
@@ -1590,13 +1771,15 @@ var getLiteralTypeFromExpression = (expression, checker, depth) => {
   return null;
 };
 var getLiteralTypeFromPropertySymbol = (symbol, checker, depth) => {
-  const declarations = symbol.declarations ?? [];
-  for (const declaration of declarations) {
-    if (ts4.isPropertyAssignment(declaration)) {
+  for (const handle of symbol.declarations) {
+    if (handle.kind !== SyntaxKind3.PropertyAssignment && handle.kind !== SyntaxKind3.ShorthandPropertyAssignment) continue;
+    const declaration = handle.resolve();
+    if (!declaration) continue;
+    if (isPropertyAssignment2(declaration)) {
       const literal = getLiteralTypeFromExpression(declaration.initializer, checker, depth);
       if (literal) return literal;
     }
-    if (ts4.isShorthandPropertyAssignment(declaration)) {
+    if (isShorthandPropertyAssignment(declaration) && isIdentifier4(declaration.name)) {
       const literal = getLiteralTypeFromExpression(declaration.name, checker, depth);
       if (literal) return literal;
     }
@@ -1604,10 +1787,10 @@ var getLiteralTypeFromPropertySymbol = (symbol, checker, depth) => {
   return null;
 };
 var normalizeImportPath = (targetFilePath) => {
-  const fromDir = path5.dirname(getGeneratedSocketTypesPath2());
+  const fromDir = path6.dirname(getGeneratedSocketTypesPath2());
   const from = fromDir.replaceAll("\\", "/");
   const to = targetFilePath.replaceAll("\\", "/");
-  const normalized = path5.posix.relative(from, to).replaceAll("\\", "/");
+  const normalized = path6.posix.relative(from, to).replaceAll("\\", "/");
   const withoutExtension = normalized.replace(/(\.d)?\.(ts|tsx|js|jsx)$/i, "");
   if (withoutExtension.startsWith(".")) return withoutExtension;
   return `./${withoutExtension}`;
@@ -1623,17 +1806,20 @@ var mergeUnresolvedSymbols = (left, right) => {
   }
   return merged;
 };
+var isNodeModulesPath = (filePath) => filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\");
+var getDeclarationFileName = (symbol) => {
+  const handle = symbol.declarations[0];
+  if (!handle || isNodeModulesPath(handle.path)) return void 0;
+  const fileName = handle.resolve()?.getSourceFile().fileName;
+  return fileName && !isNodeModulesPath(fileName) ? fileName : void 0;
+};
 var collectTypeSymbolFallback = (type) => {
-  const symbol = type.aliasSymbol ?? type.getSymbol();
+  const symbol = type.getAliasSymbol() ?? type.getSymbol();
   if (!symbol) return [];
-  const name = symbol.getName();
+  const name = symbol.name;
   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 }];
-  }
+  const sourceFile = getDeclarationFileName(symbol);
+  if (!sourceFile) return [{ name }];
   return [{
     name,
     sourceFile,
@@ -1644,16 +1830,14 @@ var WIRE_PROJECTED_TYPES = /* @__PURE__ */ new Map([["Date", "string"]]);
 var resolveToJsonReturnType = (type, checker) => {
   const toJson = type.getProperty("toJSON");
   if (!toJson) return null;
-  const declaration = toJson.valueDeclaration ?? toJson.declarations?.[0];
-  if (!declaration) return null;
-  const signature = checker.getTypeOfSymbolAtLocation(toJson, declaration).getCallSignatures()[0];
+  if (!toJson.valueDeclaration && toJson.declarations.length === 0) return null;
+  const signature = checker.getNonMissingTypeOfSymbol(toJson).getCallSignatures()[0];
   return signature ? signature.getReturnType() : null;
 };
 var isFunctionValueType = (type) => type.getCallSignatures().length > 0;
 var typeNameOf = (type, checker) => {
-  const objectType = type;
-  if (type.flags & ts4.TypeFlags.Object && objectType.objectFlags & ts4.ObjectFlags.Reference) {
-    const targetName = objectType.target.getSymbol()?.name;
+  if (type.isTypeReference()) {
+    const targetName = type.getTarget().getSymbol()?.name;
     if (targetName) return targetName;
   }
   return type.getSymbol()?.name ?? checker.typeToString(type);
@@ -1663,13 +1847,13 @@ var assertSupportedWireType = (type, checker) => {
   if (TRANSPORT_DEPENDENT_BINARY_TYPES.has(typeName)) {
     throw new UnsupportedWireTypeError(typeName);
   }
-  if ((type.flags & (ts4.TypeFlags.BigInt | ts4.TypeFlags.BigIntLiteral)) !== 0) {
+  if ((type.flags & (TypeFlags.BigInt | TypeFlags.BigIntLiteral)) !== 0) {
     throw new UnsupportedWireTypeError("bigint");
   }
 };
-var isJsonOmittedValueType = (type) => (type.flags & (ts4.TypeFlags.Undefined | ts4.TypeFlags.Void | ts4.TypeFlags.ESSymbol | ts4.TypeFlags.UniqueESSymbol)) !== 0 || isFunctionValueType(type);
+var isJsonOmittedValueType = (type) => (type.flags & (TypeFlags.Undefined | TypeFlags.Void | TypeFlags.ESSymbol | TypeFlags.UniqueESSymbol)) !== 0 || isFunctionValueType(type);
 var resolveWireConstituents = (type, checker) => {
-  const queue = type.isUnion() ? [...type.types] : [type];
+  const queue = type.isUnionType() ? [...type.getTypes()] : [type];
   const serializable = [];
   let omitted = false;
   let changed = false;
@@ -1681,9 +1865,9 @@ var resolveWireConstituents = (type, checker) => {
       continue;
     }
     const jsonType = resolveToJsonReturnType(candidate, checker);
-    const effective = jsonType && jsonType !== candidate ? jsonType : candidate;
+    const effective = jsonType && jsonType.id !== candidate.id ? jsonType : candidate;
     if (effective !== candidate) changed = true;
-    const effectiveTypes = effective.isUnion() ? effective.types : [effective];
+    const effectiveTypes = effective.isUnionType() ? effective.getTypes() : [effective];
     for (const effectiveType of effectiveTypes) {
       assertSupportedWireType(effectiveType, checker);
       if (isJsonOmittedValueType(effectiveType)) {
@@ -1699,15 +1883,13 @@ var resolveWireConstituents = (type, checker) => {
 var expandTypeDetailed = (type, checker, depth = 0, state, options) => {
   const expandState = state ?? { stackTypeIds: /* @__PURE__ */ new Set(), wireProjection: options?.wireProjection ?? false };
   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);
+  if (expandState.stackTypeIds.has(typeId)) {
+    return {
+      text: checker.typeToString(type),
+      unresolvedSymbols: collectTypeSymbolFallback(type)
+    };
   }
+  expandState.stackTypeIds.add(typeId);
   try {
     if (expandState.wireProjection) {
       assertSupportedWireType(type, checker);
@@ -1722,14 +1904,14 @@ var expandTypeDetailed = (type, checker, depth = 0, state, options) => {
       };
     }
     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)) {
+    if (type.isStringLiteralType()) return { text: `'${type.value.replaceAll("\\", "\\\\").replaceAll("'", String.raw`\'`)}'`, unresolvedSymbols: [] };
+    if (type.isNumberLiteralType()) return { text: String(type.value), unresolvedSymbols: [] };
+    if (type.flags & (TypeFlags.String | TypeFlags.Number | TypeFlags.Boolean | TypeFlags.BooleanLiteral | TypeFlags.Undefined | TypeFlags.Null | TypeFlags.Any | TypeFlags.Unknown | TypeFlags.Never | TypeFlags.Void)) {
       return { text: checker.typeToString(type), unresolvedSymbols: [] };
     }
-    if (type.isUnion()) {
+    if (type.isUnionType()) {
       let unresolvedSymbols = [];
-      const expandedTypes = type.types.map((innerType) => {
+      const expandedTypes = type.getTypes().map((innerType) => {
         const expanded = expandTypeDetailed(innerType, checker, depth + 1, expandState);
         unresolvedSymbols = mergeUnresolvedSymbols(unresolvedSymbols, expanded.unresolvedSymbols);
         return expanded.text;
@@ -1737,20 +1919,19 @@ var expandTypeDetailed = (type, checker, depth = 0, state, options) => {
       const uniqueTypes = [...new Set(expandedTypes)];
       return { text: uniqueTypes.join(" | "), unresolvedSymbols };
     }
-    if (type.isIntersection()) {
+    if (type.isIntersectionType()) {
       let unresolvedSymbols = [];
-      const expandedTypes = type.types.map((innerType) => {
+      const expandedTypes = type.getTypes().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;
-      const tupleTarget = objectType.objectFlags & ts4.ObjectFlags.Reference ? objectType.target : objectType;
-      if (tupleTarget.objectFlags & ts4.ObjectFlags.Tuple) {
-        const typeArgs = checker.getTypeArguments(objectType);
+    if (type.isObjectType()) {
+      const tupleTarget = type.isTypeReference() ? type.getTarget() : type;
+      if (tupleTarget.objectFlags & ObjectFlags.Tuple) {
+        const typeArgs = type.isTypeReference() ? checker.getTypeArguments(type) : [];
         let unresolvedSymbols = [];
         const tupleTypes = typeArgs.map((innerType) => {
           const wire = expandState.wireProjection ? resolveWireConstituents(innerType, checker) : { serializable: [innerType], omitted: false };
@@ -1767,15 +1948,14 @@ var expandTypeDetailed = (type, checker, depth = 0, state, options) => {
       }
       if (expandState.wireProjection) {
         const jsonType = resolveToJsonReturnType(type, checker);
-        if (jsonType && jsonType !== type) {
+        if (jsonType && jsonType.id !== type.id) {
           return expandTypeDetailed(jsonType, checker, depth + 1, expandState);
         }
       }
-      if (objectType.objectFlags & ts4.ObjectFlags.Reference) {
-        const refType = objectType;
-        const targetName = refType.target.symbol?.name ?? "";
+      if (type.isTypeReference()) {
+        const targetName = type.getTarget().getSymbol()?.name ?? "";
         if (targetName === "Array" || targetName === "ReadonlyArray") {
-          const typeArgs = checker.getTypeArguments(refType);
+          const typeArgs = checker.getTypeArguments(type);
           const firstArg = typeArgs[0];
           if (firstArg) {
             const wire = expandState.wireProjection ? resolveWireConstituents(firstArg, checker) : { serializable: [firstArg], omitted: false };
@@ -1797,7 +1977,7 @@ var expandTypeDetailed = (type, checker, depth = 0, state, options) => {
           return { text: projected ?? checker.typeToString(type), unresolvedSymbols: [] };
         }
       }
-      const symbolName = type.symbol?.name || (type.aliasSymbol?.name ?? "");
+      const symbolName = (type.getSymbol()?.name ?? "") || (type.getAliasSymbol()?.name ?? "");
       if (SKIP_EXPANSION.has(symbolName)) {
         const projected = expandState.wireProjection ? WIRE_PROJECTED_TYPES.get(symbolName) : void 0;
         return { text: projected ?? checker.typeToString(type), unresolvedSymbols: [] };
@@ -1808,12 +1988,12 @@ var expandTypeDetailed = (type, checker, depth = 0, state, options) => {
         const fields = [];
         let unresolvedSymbols = [];
         for (const prop of props) {
-          if (prop.getName().startsWith("__@")) continue;
+          if (prop.name.startsWith("__@")) continue;
           const propType = checker.getTypeOfSymbol(prop);
           const wire = expandState.wireProjection ? resolveWireConstituents(propType, checker) : { serializable: [propType], omitted: false };
           if (wire.serializable.length === 0) continue;
           const literalType = getLiteralTypeFromPropertySymbol(prop, checker, depth + 1);
-          const isOptional = (prop.flags & ts4.SymbolFlags.Optional) !== 0 || wire.omitted;
+          const isOptional = (prop.flags & SymbolFlags.Optional) !== 0 || wire.omitted;
           if (literalType && !wire.omitted) {
             fields.push(`${prop.name}${isOptional ? "?" : ""}: ${literalType}`);
             continue;
@@ -1828,7 +2008,7 @@ var expandTypeDetailed = (type, checker, depth = 0, state, options) => {
         }
         for (const indexInfo of indexInfos) {
           const keyType = expandTypeDetailed(indexInfo.keyType, checker, depth + 1, expandState);
-          const wire = expandState.wireProjection ? resolveWireConstituents(indexInfo.type, checker) : { serializable: [indexInfo.type], omitted: false };
+          const wire = expandState.wireProjection ? resolveWireConstituents(indexInfo.valueType, checker) : { serializable: [indexInfo.valueType], omitted: false };
           if (wire.serializable.length === 0) continue;
           const valueTexts = [];
           for (const serializableType of wire.serializable) {
@@ -1856,9 +2036,7 @@ ${outerIndent}}`,
       unresolvedSymbols: collectTypeSymbolFallback(type)
     };
   } finally {
-    if (typeId !== void 0) {
-      expandState.stackTypeIds.delete(typeId);
-    }
+    expandState.stackTypeIds.delete(typeId);
   }
 };
 var expandType = (type, checker, depth = 0) => {
@@ -1900,10 +2078,10 @@ var KNOWN_GLOBAL_TYPE_NAMES = /* @__PURE__ */ new Set([
   "JsonPrimitive"
 ]);
 var normalizeImportPath2 = (targetFilePath) => {
-  const fromDir = path6.dirname(getGeneratedSocketTypesPath3());
+  const fromDir = path7.dirname(getGeneratedSocketTypesPath3());
   const from = fromDir.replaceAll("\\", "/");
   const to = targetFilePath.replaceAll("\\", "/");
-  const normalized = path6.posix.relative(from, to).replaceAll("\\", "/");
+  const normalized = path7.posix.relative(from, to).replaceAll("\\", "/");
   const withoutExtension = normalized.replace(/(\.d)?\.(ts|tsx|js|jsx)$/i, "");
   if (withoutExtension.startsWith(".")) return withoutExtension;
   return `./${withoutExtension}`;
@@ -1923,22 +2101,19 @@ 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
+    SymbolFlags2.TypeAlias | SymbolFlags2.Interface | SymbolFlags2.Class | SymbolFlags2.Enum | SymbolFlags2.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) {
+    const targetSymbol = (localSymbol.flags & SymbolFlags2.Alias) === 0 ? localSymbol : checker.getAliasedSymbol(localSymbol);
+    if (targetSymbol.declarations.length === 0) {
       unresolvedSymbols.push({ name });
       continue;
     }
-    const sourceFile = declaration.getSourceFile().fileName;
-    if (!sourceFile || sourceFile.includes("/node_modules/") || sourceFile.includes("\\node_modules\\")) {
-      continue;
-    }
+    const sourceFile = getDeclarationFileName(targetSymbol);
+    if (!sourceFile) continue;
     unresolvedSymbols.push({
       name,
       sourceFile,
@@ -1949,13 +2124,13 @@ var collectFallbackSymbolsFromTypeText = (typeText, scopeNode, checker) => {
 };
 var findInterface = (sourceFile, name) => {
   for (const stmt of sourceFile.statements) {
-    if (ts5.isInterfaceDeclaration(stmt) && stmt.name.text === name) return stmt;
+    if (isInterfaceDeclaration2(stmt) && stmt.name.text === name) return stmt;
   }
   return null;
 };
 var getInterfacePropertyType = (iface, propertyName, checker) => {
   for (const member of iface.members) {
-    if (ts5.isPropertySignature(member) && ts5.isIdentifier(member.name) && member.name.text === propertyName && member.type) {
+    if (isPropertySignatureDeclaration2(member) && isIdentifier5(member.name) && member.name.text === propertyName && member.type) {
       return checker.getTypeFromTypeNode(member.type);
     }
   }
@@ -1963,14 +2138,14 @@ var getInterfacePropertyType = (iface, propertyName, checker) => {
 };
 var findMainFunction = (sourceFile) => {
   for (const stmt of sourceFile.statements) {
-    if (ts5.isVariableStatement(stmt)) {
+    if (isVariableStatement2(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))) {
+        if (isIdentifier5(decl.name) && decl.name.text === "main" && decl.initializer && (isArrowFunction(decl.initializer) || isFunctionExpression(decl.initializer))) {
           return decl.initializer;
         }
       }
     }
-    if (ts5.isFunctionDeclaration(stmt) && stmt.name?.text === "main") {
+    if (isFunctionDeclaration2(stmt) && stmt.name?.text === "main") {
       return stmt;
     }
   }
@@ -1980,7 +2155,7 @@ var collectReturnObjectTypeDetails = (funcNode, checker) => {
   const types = [];
   let unresolvedSymbols = [];
   const visit = (node) => {
-    if (ts5.isReturnStatement(node) && node.expression && ts5.isObjectLiteralExpression(node.expression)) {
+    if (isReturnStatement(node) && node.expression && isObjectLiteralExpression2(node.expression)) {
       const type = checker.getTypeAtLocation(node.expression);
       const expanded = expandTypeDetailed(type, checker, 0, void 0, { wireProjection: true });
       types.push(expanded.text);
@@ -1990,11 +2165,11 @@ var collectReturnObjectTypeDetails = (funcNode, checker) => {
         collectFallbackSymbolsFromTypeText(expanded.text, node.expression, checker)
       );
     }
-    if (!ts5.isArrowFunction(node) && !ts5.isFunctionExpression(node) && !ts5.isFunctionDeclaration(node)) {
-      ts5.forEachChild(node, visit);
+    if (!isArrowFunction(node) && !isFunctionExpression(node) && !isFunctionDeclaration2(node)) {
+      node.forEachChild(visit);
     }
   };
-  ts5.forEachChild(funcNode, visit);
+  funcNode.forEachChild(visit);
   return { text: unionTypes(types), unresolvedSymbols };
 };
 var STREAM_EMIT_NAMES = /* @__PURE__ */ new Set(["stream", "broadcastStream", "streamTo"]);
@@ -2002,7 +2177,7 @@ 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)) {
+    if (isCallExpression(node) && isIdentifier5(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];
@@ -2020,11 +2195,11 @@ var collectStreamCallPayloadTypeDetails = (funcNode, checker) => {
         );
       }
     }
-    if (!ts5.isArrowFunction(node) && !ts5.isFunctionExpression(node) && !ts5.isFunctionDeclaration(node)) {
-      ts5.forEachChild(node, visit);
+    if (!isArrowFunction(node) && !isFunctionExpression(node) && !isFunctionDeclaration2(node)) {
+      node.forEachChild(visit);
     }
   };
-  ts5.forEachChild(funcNode, visit);
+  funcNode.forEachChild(visit);
   return { text: unionTypes(types), unresolvedSymbols };
 };
 var unionTypes = (types) => {
@@ -2038,15 +2213,13 @@ var UnsupportedTransportInputError = class extends Error {
   }
 };
 var assertTransportInputIsWireSafe = (typeText, filePath) => {
-  const sourceFile = ts5.createSourceFile(
+  const sourceFile = parseSourceText(
     "__luckystack_input_check.ts",
     `type __LuckyStackInput = ${typeText};`,
-    ts5.ScriptTarget.Latest,
-    true,
-    ts5.ScriptKind.TS
+    ScriptKind2.TS
   );
   const containsDate = (node) => {
-    if (ts5.isTypeReferenceNode(node) && ts5.isIdentifier(node.typeName) && node.typeName.text === "Date") {
+    if (isTypeReferenceNode3(node) && isIdentifier5(node.typeName) && node.typeName.text === "Date") {
       return true;
     }
     return node.getChildren(sourceFile).some((child) => containsDate(child));
@@ -2060,13 +2233,12 @@ var getInputTypeDetailsFromFile = (filePath) => {
   const DEFAULT = "{ }";
   recordExtractionOutcome({ filePath, kind: "api", field: "input", error: null });
   try {
-    const program = getServerProgram();
+    const { program, checker } = getServerProgram();
     const sourceFile = program.getSourceFile(filePath);
     if (!sourceFile) {
       console.warn(`[TypeMapGenerator] getSourceFile miss for ${filePath} \u2014 input types will default to { }`);
       return { text: DEFAULT, unresolvedSymbols: [] };
     }
-    const checker = program.getTypeChecker();
     const iface = findInterface(sourceFile, "ApiParams");
     if (!iface) return { text: DEFAULT, unresolvedSymbols: [] };
     const dataType = getInterfacePropertyType(iface, "data", checker);
@@ -2092,9 +2264,9 @@ var extractDeclaredStreamTypeFromApiParams = (sourceFile, checker) => {
   let result = null;
   const visit = (node) => {
     if (result) return;
-    if (ts5.isInterfaceDeclaration(node) && node.name.text.endsWith("Params")) {
+    if (isInterfaceDeclaration2(node) && node.name.text.endsWith("Params")) {
       for (const member of node.members) {
-        if (ts5.isPropertySignature(member) && ts5.isIdentifier(member.name) && member.name.text === "stream" && member.type && ts5.isTypeReferenceNode(member.type) && ts5.isIdentifier(member.type.typeName) && STREAM_EMITTER_TYPE_NAMES.has(member.type.typeName.text)) {
+        if (isPropertySignatureDeclaration2(member) && isIdentifier5(member.name) && member.name.text === "stream" && member.type && isTypeReferenceNode3(member.type) && isIdentifier5(member.type.typeName) && STREAM_EMITTER_TYPE_NAMES.has(member.type.typeName.text)) {
           const typeArg = member.type.typeArguments?.[0];
           if (typeArg) {
             const argType = checker.getNonNullableType(checker.getTypeFromTypeNode(typeArg));
@@ -2107,7 +2279,7 @@ var extractDeclaredStreamTypeFromApiParams = (sourceFile, checker) => {
         }
       }
     }
-    ts5.forEachChild(node, visit);
+    node.forEachChild(visit);
   };
   visit(sourceFile);
   return result;
@@ -2116,10 +2288,9 @@ var getApiStreamPayloadTypeDetailsFromFile = (filePath) => {
   const DEFAULT = "never";
   recordExtractionOutcome({ filePath, kind: "api", field: "stream", error: null });
   try {
-    const program = getServerProgram();
+    const { program, checker } = 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);
@@ -2138,10 +2309,9 @@ var getOutputTypeDetailsFromFile = (filePath) => {
   const DEFAULT = "{ status: string }";
   recordExtractionOutcome({ filePath, kind: "api", field: "output", error: null });
   try {
-    const program = getServerProgram();
+    const { program, checker } = 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);
@@ -2160,10 +2330,9 @@ var getSyncClientDataTypeDetailsFromFile = (filePath) => {
   const DEFAULT = "{ }";
   recordExtractionOutcome({ filePath, kind: "sync", field: "clientInput", error: null });
   try {
-    const program = getServerProgram();
+    const { program, checker } = 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);
@@ -2182,10 +2351,9 @@ var getSyncServerStreamPayloadTypeDetailsFromFile = (filePath) => {
   const DEFAULT = "never";
   recordExtractionOutcome({ filePath, kind: "sync", field: "serverStream", error: null });
   try {
-    const program = getServerProgram();
+    const { program, checker } = 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);
@@ -2201,10 +2369,9 @@ var getSyncServerOutputTypeDetailsFromFile = (filePath) => {
   const DEFAULT = "{ status: string }";
   recordExtractionOutcome({ filePath, kind: "sync", field: "serverOutput", error: null });
   try {
-    const program = getServerProgram();
+    const { program, checker } = 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);
@@ -2220,10 +2387,9 @@ var getSyncClientStreamPayloadTypeDetailsFromFile = (filePath) => {
   const DEFAULT = "never";
   recordExtractionOutcome({ filePath, kind: "sync", field: "clientStream", error: null });
   try {
-    const program = getServerProgram();
+    const { program, checker } = 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);
@@ -2239,10 +2405,9 @@ var getSyncClientOutputTypeDetailsFromFile = (filePath) => {
   const DEFAULT = "{ }";
   recordExtractionOutcome({ filePath, kind: "sync", field: "clientOutput", error: null });
   try {
-    const program = getServerProgram();
+    const { program, checker } = 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);
@@ -2256,19 +2421,48 @@ var getSyncClientOutputTypeDetailsFromFile = (filePath) => {
 };
 
 // src/typeMap/functionsMeta.ts
-import * as ts7 from "typescript";
-import fs6 from "fs";
-import path9 from "path";
+import fs7 from "fs";
+import path10 from "path";
+import {
+  createScanner,
+  LanguageVariant,
+  SyntaxKind as SyntaxKind5
+} from "typescript-7-api/ast";
+import {
+  isArrowFunction as isArrowFunction2,
+  isClassDeclaration as isClassDeclaration3,
+  isEnumDeclaration as isEnumDeclaration3,
+  isExportAssignment,
+  isExportDeclaration,
+  isFunctionDeclaration as isFunctionDeclaration3,
+  isFunctionExpression as isFunctionExpression2,
+  isIdentifier as isIdentifier6,
+  isInterfaceDeclaration as isInterfaceDeclaration4,
+  isNamedExports,
+  isStringLiteral as isStringLiteral5,
+  isTypeAliasDeclaration as isTypeAliasDeclaration4,
+  isVariableStatement as isVariableStatement3
+} from "typescript-7-api/ast/is";
 
 // src/typeMap/typeContext.ts
-import * as ts6 from "typescript";
-import path7 from "path";
+import path8 from "path";
+import { SyntaxKind as SyntaxKind4 } from "typescript-7-api/ast";
+import {
+  isClassDeclaration as isClassDeclaration2,
+  isEnumDeclaration as isEnumDeclaration2,
+  isImportDeclaration as isImportDeclaration2,
+  isInterfaceDeclaration as isInterfaceDeclaration3,
+  isNamedImports as isNamedImports2,
+  isNamespaceImport as isNamespaceImport2,
+  isStringLiteral as isStringLiteral4,
+  isTypeAliasDeclaration as isTypeAliasDeclaration3
+} from "typescript-7-api/ast/is";
 import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath4 } from "@luckystack/core";
 var toGeneratedImportPath = (source, filePath) => {
   if (!source.startsWith(".")) return source;
-  const outputDir = path7.dirname(getGeneratedSocketTypesPath4());
-  const absoluteSource = path7.resolve(path7.dirname(filePath), source);
-  let relPath = path7.relative(outputDir, absoluteSource).replaceAll("\\", "/");
+  const outputDir = path8.dirname(getGeneratedSocketTypesPath4());
+  const absoluteSource = path8.resolve(path8.dirname(filePath), source);
+  let relPath = path8.relative(outputDir, absoluteSource).replaceAll("\\", "/");
   relPath = relPath.replace(/\.tsx?$/, "");
   if (!relPath.startsWith(".")) relPath = `./${relPath}`;
   return relPath;
@@ -2276,23 +2470,18 @@ var toGeneratedImportPath = (source, filePath) => {
 var parseFileTypeContext = (content) => {
   const availableExports = /* @__PURE__ */ new Set();
   const fileImports = /* @__PURE__ */ new Map();
-  const sourceFile = ts6.createSourceFile(
-    "__temp__.ts",
-    content,
-    ts6.ScriptTarget.Latest,
-    true
-  );
+  const sourceFile = parseSourceText("__temp__.ts", content);
   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 (isInterfaceDeclaration3(statement) || isTypeAliasDeclaration3(statement) || isClassDeclaration2(statement) || isEnumDeclaration2(statement)) {
+      const hasExport = statement.modifiers?.some((m) => m.kind === SyntaxKind4.ExportKeyword);
       if (hasExport && statement.name) {
         availableExports.add(statement.name.text);
       }
       continue;
     }
-    if (!ts6.isImportDeclaration(statement)) continue;
+    if (!isImportDeclaration2(statement)) continue;
     const moduleSpecifier = statement.moduleSpecifier;
-    if (!ts6.isStringLiteral(moduleSpecifier)) continue;
+    if (!isStringLiteral4(moduleSpecifier)) continue;
     const source = moduleSpecifier.text;
     const importClause = statement.importClause;
     if (!importClause) continue;
@@ -2301,11 +2490,11 @@ var parseFileTypeContext = (content) => {
     }
     const namedBindings = importClause.namedBindings;
     if (!namedBindings) continue;
-    if (ts6.isNamespaceImport(namedBindings)) {
+    if (isNamespaceImport2(namedBindings)) {
       fileImports.set(namedBindings.name.text, { source, isDefault: true });
       continue;
     }
-    if (ts6.isNamedImports(namedBindings)) {
+    if (isNamedImports2(namedBindings)) {
       for (const specifier of namedBindings.elements) {
         const localName = specifier.name.text;
         const originalName = specifier.propertyName?.text ?? localName;
@@ -2355,11 +2544,11 @@ var sanitizeTypeAndCollectImports = ({
 import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath5, ROOT_DIR as ROOT_DIR5 } from "@luckystack/core";
 
 // src/functionRegistry.ts
-import fs5 from "fs";
-import path8 from "path";
+import fs6 from "fs";
+import path9 from "path";
 import { ROOT_DIR as ROOT_DIR4, getServerFunctionDirs, isTestFile as isTestFile2, isTestDirectory as isTestDirectory2 } from "@luckystack/core";
 var normalizePath2 = (value) => value.replaceAll("\\", "/");
-var toWorkspaceRelative = (absolutePath) => normalizePath2(path8.relative(ROOT_DIR4, absolutePath));
+var toWorkspaceRelative = (absolutePath) => normalizePath2(path9.relative(ROOT_DIR4, absolutePath));
 var formatFunctionKeyPath = (keyPath) => keyPath.join(".");
 var functionModuleFileName = (keyPath) => {
   const fileName = keyPath.at(-1);
@@ -2371,12 +2560,12 @@ var functionModuleFileName = (keyPath) => {
 var formatFunctionKeyConflict = (keyPath, firstSourcePath, secondSourcePath) => `[function-injection] Conflict at \`functions.${formatFunctionKeyPath(keyPath)}\`: defined in both \`${firstSourcePath}\` and \`${secondSourcePath}\`. Delete one \u2014 \`shared/\` is the canonical location for framework re-exports.`;
 var formatFunctionNamespaceConflict = (moduleKeyPath, moduleSourcePath, nestedKeyPath, nestedSourcePath) => `[function-injection] Conflict at \`functions.${formatFunctionKeyPath(moduleKeyPath)}\`: \`${moduleSourcePath}\` defines it as a module, but \`${nestedSourcePath}\` nests \`functions.${formatFunctionKeyPath(nestedKeyPath)}\` underneath it. Rename one \u2014 a key cannot be both a module and a namespace.`;
 var walkFunctionRoot = (dir, rootDir, basePath, collected) => {
-  const entries = fs5.readdirSync(dir).toSorted();
+  const entries = fs6.readdirSync(dir).toSorted();
   for (const entry of entries) {
     if (entry === "node_modules") continue;
-    const fullPath = path8.join(dir, entry);
+    const fullPath = path9.join(dir, entry);
     if (getRoutingRules().ignore(toWorkspaceRelative(fullPath))) continue;
-    if (fs5.statSync(fullPath).isDirectory()) {
+    if (fs6.statSync(fullPath).isDirectory()) {
       if (isTestDirectory2(entry)) continue;
       walkFunctionRoot(fullPath, rootDir, [...basePath, entry], collected);
       continue;
@@ -2419,7 +2608,7 @@ var collectFunctionModules = (options = {}) => {
     onConflict(message);
   };
   for (const root of functionRoots) {
-    if (!fs5.existsSync(root)) continue;
+    if (!fs6.existsSync(root)) continue;
     const fromThisRoot = [];
     walkFunctionRoot(root, root, [], fromThisRoot);
     for (const module of fromThisRoot) {
@@ -2493,17 +2682,16 @@ var stripDefaultValues = (params) => {
   return params.replaceAll(/\s*=(?!>)[^,)]+/g, "");
 };
 var stripLineComments = (value) => {
-  const scanner = ts7.createScanner(
-    ts7.ScriptTarget.Latest,
+  const scanner = createScanner(
     /* skipTrivia */
     false,
-    ts7.LanguageVariant.Standard,
+    LanguageVariant.Standard,
     value
   );
   let result = "";
   let token = scanner.scan();
-  while (token !== ts7.SyntaxKind.EndOfFileToken) {
-    result += token === ts7.SyntaxKind.SingleLineCommentTrivia ? " " : scanner.getTokenText();
+  while (token !== SyntaxKind5.EndOfFile) {
+    result += token === SyntaxKind5.SingleLineCommentTrivia ? " " : scanner.getTokenText();
     token = scanner.scan();
   }
   return result;
@@ -2516,9 +2704,9 @@ var simplifyInferredType = (value) => {
   if (/\bRedis\b/.test(value)) return "Redis";
   return value;
 };
-var getGeneratedFileDir = () => path9.dirname(getGeneratedSocketTypesPath5());
+var getGeneratedFileDir = () => path10.dirname(getGeneratedSocketTypesPath5());
 var sourceModuleSpecifier = (sourceFilePath) => {
-  const relative = path9.relative(getGeneratedFileDir(), sourceFilePath).replaceAll("\\", "/").replace(/\.tsx?$/i, "");
+  const relative = path10.relative(getGeneratedFileDir(), sourceFilePath).replaceAll("\\", "/").replace(/\.tsx?$/i, "");
   return relative.startsWith(".") ? relative : `./${relative}`;
 };
 var portableInferredValueType = (inferred, sourceFilePath, exportName) => {
@@ -2529,16 +2717,16 @@ var relativizeModuleSpecifier = (specifier, sourceFilePath) => {
   if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
     return specifier;
   }
-  const absolute = path9.resolve(path9.dirname(sourceFilePath), specifier);
-  const rel = path9.relative(getGeneratedFileDir(), absolute);
-  const normalized = rel.split(path9.sep).join("/");
+  const absolute = path10.resolve(path10.dirname(sourceFilePath), specifier);
+  const rel = path10.relative(getGeneratedFileDir(), absolute);
+  const normalized = rel.split(path10.sep).join("/");
   return normalized.startsWith(".") ? normalized : `./${normalized}`;
 };
 var findProgramVariableDeclaration = (sourceFile, exportName) => {
   for (const statement of sourceFile.statements) {
-    if (!ts7.isVariableStatement(statement)) continue;
+    if (!isVariableStatement3(statement)) continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (ts7.isIdentifier(declaration.name) && declaration.name.text === exportName) {
+      if (isIdentifier6(declaration.name) && declaration.name.text === exportName) {
         return declaration;
       }
     }
@@ -2547,10 +2735,10 @@ var findProgramVariableDeclaration = (sourceFile, exportName) => {
 };
 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;
+    if (isInterfaceDeclaration4(statement) && statement.name.text === typeName) return statement;
+    if (isTypeAliasDeclaration4(statement) && statement.name.text === typeName) return statement;
+    if (isClassDeclaration3(statement) && statement.name?.text === typeName) return statement;
+    if (isEnumDeclaration3(statement) && statement.name.text === typeName) return statement;
   }
   return null;
 };
@@ -2567,7 +2755,7 @@ var resolveLocalExportedTypes = ({
     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 declarationNode = isClassDeclaration3(declaration) ? declaration.name ?? declaration : isTypeAliasDeclaration4(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);
@@ -2576,9 +2764,9 @@ var resolveLocalExportedTypes = ({
 };
 var findSourceVariableDeclaration = (sourceFile, exportName) => {
   for (const statement of sourceFile.statements) {
-    if (!ts7.isVariableStatement(statement)) continue;
+    if (!isVariableStatement3(statement)) continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (ts7.isIdentifier(declaration.name) && declaration.name.text === exportName) {
+      if (isIdentifier6(declaration.name) && declaration.name.text === exportName) {
         return declaration;
       }
     }
@@ -2596,8 +2784,8 @@ var inferValueTypeForExport = ({
   checker,
   programSource
 }) => {
-  const resolvedChecker = checker ?? getServerProgram().getTypeChecker();
-  const resolvedSource = programSource ?? getServerProgram().getSourceFile(filePath);
+  const resolvedChecker = checker ?? getServerProgram().checker;
+  const resolvedSource = programSource ?? getServerProgram().program.getSourceFile(filePath);
   if (declaration.type) {
     const rawType = normalizeInlineType(rawContent.slice(declaration.type.pos, declaration.type.end).trim());
     const localResolvedType = resolvedSource ? resolveLocalExportedTypes({
@@ -2646,7 +2834,7 @@ var extractSignatureFromNode = (node, rawContent, filePath, availableExports, fi
       knownGenerics.add(typeParam.name.text);
     }
   }
-  const isAsync = node.modifiers?.some((m) => m.kind === ts7.SyntaxKind.AsyncKeyword) ?? false;
+  const isAsync = node.modifiers?.some((m) => m.kind === SyntaxKind5.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})`));
@@ -2689,38 +2877,38 @@ var extractSignatureFromNode = (node, rawContent, filePath, availableExports, fi
 };
 var findSignatureForExport = (name, sourceFile, rawContent, filePath, availableExports, fileImports, collectors, checker, programSource) => {
   for (const statement of sourceFile.statements) {
-    if (ts7.isVariableStatement(statement)) {
+    if (isVariableStatement3(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)) {
+        if (!isIdentifier6(decl.name) || decl.name.text !== name || !decl.initializer) continue;
+        if (isArrowFunction2(decl.initializer) || isFunctionExpression2(decl.initializer)) {
           return extractSignatureFromNode(decl.initializer, rawContent, filePath, availableExports, fileImports, collectors, checker, programSource);
         }
       }
     }
-    if (ts7.isFunctionDeclaration(statement) && statement.name?.text === name) {
+    if (isFunctionDeclaration3(statement) && statement.name?.text === name) {
       return extractSignatureFromNode(statement, rawContent, filePath, availableExports, fileImports, collectors, checker, programSource);
     }
   }
   return "any";
 };
+var hasExportModifier = (statement) => (isVariableStatement3(statement) || isFunctionDeclaration3(statement)) && (statement.modifiers?.some((m) => m.kind === SyntaxKind5.ExportKeyword) ?? false);
 var parseFunctionFile = (fullPath, collectors) => {
   try {
-    const rawContent = fs6.readFileSync(fullPath, "utf8");
-    const sourceFile = ts7.createSourceFile(fullPath, rawContent, ts7.ScriptTarget.Latest, true);
+    const rawContent = fs7.readFileSync(fullPath, "utf8");
+    const sourceFile = parseSourceText(fullPath, rawContent);
     const { availableExports, fileImports } = parseFileTypeContext(rawContent);
-    const program = getServerProgram();
-    const checker = program.getTypeChecker();
+    const { program, checker } = getServerProgram();
     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) {
+      const hasExport = hasExportModifier(statement);
+      if (isVariableStatement3(statement) && hasExport) {
         for (const decl of statement.declarationList.declarations) {
-          if (ts7.isIdentifier(decl.name)) {
+          if (isIdentifier6(decl.name)) {
             const exportName = decl.name.text;
-            if (decl.initializer && (ts7.isArrowFunction(decl.initializer) || ts7.isFunctionExpression(decl.initializer))) {
+            if (decl.initializer && (isArrowFunction2(decl.initializer) || isFunctionExpression2(decl.initializer))) {
               exports.set(exportName, findSignatureForExport(exportName, sourceFile, rawContent, fullPath, availableExports, fileImports, collectors, checker, programSource ?? void 0));
               continue;
             }
@@ -2738,11 +2926,11 @@ var parseFunctionFile = (fullPath, collectors) => {
           }
         }
       }
-      if (ts7.isFunctionDeclaration(statement) && hasExport && statement.name) {
+      if (isFunctionDeclaration3(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;
+      if (isExportDeclaration(statement) && statement.exportClause && isNamedExports(statement.exportClause)) {
+        const moduleSpecifier = statement.moduleSpecifier && isStringLiteral5(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;
@@ -2757,7 +2945,7 @@ var parseFunctionFile = (fullPath, collectors) => {
             continue;
           }
           const exportDeclaration = findSourceVariableDeclaration(sourceFile, originalName);
-          if (exportDeclaration && ts7.isIdentifier(exportDeclaration.name)) {
+          if (exportDeclaration && isIdentifier6(exportDeclaration.name)) {
             exports.set(exportName, inferValueTypeForExport({
               exportName: originalName,
               declaration: exportDeclaration,
@@ -2774,10 +2962,10 @@ var parseFunctionFile = (fullPath, collectors) => {
           exports.set(exportName, "any");
         }
       }
-      if (ts7.isExportAssignment(statement) && !statement.isExportEquals && ts7.isIdentifier(statement.expression)) {
+      if (isExportAssignment(statement) && !statement.isExportEquals && isIdentifier6(statement.expression)) {
         defaultExportName = statement.expression.text;
       }
-      if (ts7.isExportDeclaration(statement) && !statement.exportClause && statement.moduleSpecifier && ts7.isStringLiteral(statement.moduleSpecifier)) {
+      if (isExportDeclaration(statement) && !statement.exportClause && statement.moduleSpecifier && isStringLiteral5(statement.moduleSpecifier)) {
         wildcardReExport = relativizeModuleSpecifier(statement.moduleSpecifier.text, fullPath);
       }
     }
@@ -2851,7 +3039,7 @@ var generateServerFunctions = (collectors) => {
   if (modules.length === 0) return "";
   const merged = { kind: "dir", children: /* @__PURE__ */ new Map(), sourcePath: "<merged>" };
   for (const module of modules) {
-    const absolutePath = path9.resolve(ROOT_DIR5, module.sourcePath);
+    const absolutePath = path10.resolve(ROOT_DIR5, module.sourcePath);
     const parsed = parseFunctionFile(absolutePath, collectors);
     if (!parsed) continue;
     if (parsed.exports.size === 0 && parsed.defaultExportName === null && parsed.wildcardReExport === null) {
@@ -2971,12 +3159,14 @@ var collectSyncTypes = (syncServerFiles, syncClientFiles, collectors) => {
       version: syncVersion,
       hasServer: serverFile !== void 0,
       hasClient: clientFile !== void 0,
-      ...syncMeta ? { meta: syncMeta } : {}
+      ...syncMeta ? { meta: syncMeta } : {},
+      //? Same extractors as the API side, so `syncMetaMap` and `apiMetaMap` agree.
+      ...serverFile ? { serverMeta: { auth: extractAuth(serverFile), rateLimit: extractRateLimit(serverFile) } } : {}
     });
   }
   return syncTypesByPage;
 };
-var generateTypeMapFile = (options = {}) => {
+var runTypeMapGeneration = (options) => {
   const { quiet = false } = options;
   assertValidRouteNaming({
     srcDir: getSrcDir2(),
@@ -3014,6 +3204,13 @@ var generateTypeMapFile = (options = {}) => {
   });
   writeTypeMapArtifacts({ content, docsData, schemasContent, diagnosticsData });
 };
+var generateTypeMapFile = (options = {}) => {
+  try {
+    runTypeMapGeneration(options);
+  } finally {
+    disposeTsApi();
+  }
+};
 
 // src/templateRegistry.ts
 var BUILT_IN_TEMPLATE_KINDS = [
@@ -3087,13 +3284,29 @@ var registerDefaultTemplateRules = () => {
 registerDefaultTemplateRules();
 
 // src/loader.ts
-import fs7 from "fs";
-import path10 from "path";
+import fs8 from "fs";
+import path11 from "path";
 import { pathToFileURL } from "url";
 import { tryCatch, getSrcDir as getSrcDir3, ROOT_DIR as ROOT_DIR6, isTestFile as isTestFile3 } from "@luckystack/core";
 
 // src/runtimeTypeResolver.ts
-import * as ts8 from "typescript";
+import { SymbolFlags as SymbolFlags3 } from "typescript-7-api/sync";
+import { SyntaxKind as SyntaxKind6 } from "typescript-7-api/ast";
+import {
+  isEnumDeclaration as isEnumDeclaration4,
+  isIdentifier as isIdentifier7,
+  isImportDeclaration as isImportDeclaration3,
+  isIndexSignatureDeclaration as isIndexSignatureDeclaration2,
+  isInterfaceDeclaration as isInterfaceDeclaration5,
+  isLiteralTypeNode as isLiteralTypeNode2,
+  isNamedImports as isNamedImports3,
+  isPropertySignatureDeclaration as isPropertySignatureDeclaration3,
+  isStringLiteral as isStringLiteral6,
+  isTypeAliasDeclaration as isTypeAliasDeclaration5,
+  isTypeLiteralNode as isTypeLiteralNode2,
+  isTypeReferenceNode as isTypeReferenceNode4,
+  isUnionTypeNode as isUnionTypeNode2
+} from "typescript-7-api/ast/is";
 var MAX_DEPTH = 20;
 var unresolvedPrefix = "__RUNTIME_UNRESOLVED__::";
 var PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
@@ -3173,9 +3386,9 @@ var splitTopLevel = (value, splitter) => {
 };
 var parseTypeNode = (typeText) => {
   const synthetic = `type __RT = ${typeText};`;
-  const source = ts8.createSourceFile("__runtime_type.ts", synthetic, ts8.ScriptTarget.Latest, true);
+  const source = parseSourceText("__runtime_type.ts", synthetic);
   const statement = source.statements[0];
-  if (!statement || !ts8.isTypeAliasDeclaration(statement)) return null;
+  if (!statement || !isTypeAliasDeclaration5(statement)) return null;
   return statement.type;
 };
 var parseObjectFields = (typeText) => {
@@ -3184,30 +3397,30 @@ var parseObjectFields = (typeText) => {
     return { fields: [], indexSignatures: [] };
   }
   const typeNode = parseTypeNode(clean);
-  if (!typeNode || !ts8.isTypeLiteralNode(typeNode)) {
+  if (!typeNode || !isTypeLiteralNode2(typeNode)) {
     return { fields: [], indexSignatures: [] };
   }
   const fields = [];
   const indexSignatures = [];
   for (const member of typeNode.members) {
-    if (ts8.isPropertySignature(member) && member.type) {
+    if (isPropertySignatureDeclaration3(member) && member.type) {
       let key = null;
-      if (ts8.isIdentifier(member.name)) {
+      if (isIdentifier7(member.name)) {
         key = member.name.text;
-      } else if (ts8.isStringLiteral(member.name)) {
+      } else if (isStringLiteral6(member.name)) {
         key = member.name.text;
       }
       if (key === null) continue;
       fields.push({
         key,
-        optional: Boolean(member.questionToken),
+        optional: member.postfixToken?.kind === SyntaxKind6.QuestionToken,
         type: member.type.getText().trim()
       });
       continue;
     }
-    if (ts8.isIndexSignatureDeclaration(member)) {
+    if (isIndexSignatureDeclaration2(member)) {
       const param = member.parameters[0];
-      if (!param || !ts8.isIdentifier(param.name) || !param.type) continue;
+      if (!param || !isIdentifier7(param.name) || !param.type) continue;
       indexSignatures.push({
         keyName: param.name.text,
         keyType: param.type.getText().trim(),
@@ -3232,9 +3445,9 @@ var serializeObjectFields = ({
   return `{ ${segments.join("; ")} }`;
 };
 var extractStringLiteralKey = (node) => {
-  if (!ts8.isLiteralTypeNode(node)) return null;
+  if (!isLiteralTypeNode2(node)) return null;
   const literal = node.literal;
-  if (!ts8.isStringLiteral(literal)) return null;
+  if (!isStringLiteral6(literal)) return null;
   return literal.text;
 };
 var parseLiteralUnionKeys = (value) => {
@@ -3242,7 +3455,7 @@ var parseLiteralUnionKeys = (value) => {
   if (!trimmed) return null;
   const typeNode = parseTypeNode(trimmed);
   if (!typeNode) return null;
-  if (ts8.isUnionTypeNode(typeNode)) {
+  if (isUnionTypeNode2(typeNode)) {
     const keys = [];
     for (const member of typeNode.types) {
       const key = extractStringLiteralKey(member);
@@ -3258,25 +3471,24 @@ 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 { program, checker } = 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) {
+      if ((isInterfaceDeclaration5(stmt) || isTypeAliasDeclaration5(stmt) || isEnumDeclaration4(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) {
+      if (isImportDeclaration3(stmt) && stmt.importClause) {
         const { namedBindings, name: defaultName } = stmt.importClause;
-        if (namedBindings && ts8.isNamedImports(namedBindings)) {
+        if (namedBindings && isNamedImports3(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;
+                const target = symbol.flags & SymbolFlags3.Alias ? checker.getAliasedSymbol(symbol) : symbol;
                 return expandType(checker.getDeclaredTypeOfSymbol(target), checker);
               }
             }
@@ -3285,7 +3497,7 @@ var resolveIdentifier = (identifier, filePath) => {
         if (defaultName?.text === identifier) {
           const symbol = checker.getSymbolAtLocation(defaultName);
           if (symbol) {
-            const target = symbol.flags & ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+            const target = symbol.flags & SymbolFlags3.Alias ? checker.getAliasedSymbol(symbol) : symbol;
             return expandType(checker.getDeclaredTypeOfSymbol(target), checker);
           }
         }
@@ -3419,7 +3631,7 @@ var resolveExpression = (typeText, filePath, depth, state) => {
         });
       } else {
         const typeNode = parseTypeNode(type);
-        const referenceInfo = typeNode && ts8.isTypeReferenceNode(typeNode) && ts8.isIdentifier(typeNode.typeName) ? { name: typeNode.typeName.text, args: typeNode.typeArguments } : null;
+        const referenceInfo = typeNode && isTypeReferenceNode4(typeNode) && isIdentifier7(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());
@@ -3470,7 +3682,7 @@ var devSyncs = {};
 var devFunctions = {};
 var normalizePath3 = (value) => value.replaceAll("\\", "/");
 var isIgnoredPath = (absolutePath) => {
-  const relativeFromRoot = normalizePath3(path10.relative(ROOT_DIR6, absolutePath));
+  const relativeFromRoot = normalizePath3(path11.relative(ROOT_DIR6, absolutePath));
   return getRoutingRules().ignore(relativeFromRoot);
 };
 var mapApiPageLocation = (pageLocation) => {
@@ -3480,7 +3692,7 @@ var mapSyncPageLocation = (pageLocation) => {
   return pageLocation || "system";
 };
 var resolveApiRouteMetaFromPath = (filePath) => {
-  const absolutePath = path10.resolve(filePath);
+  const absolutePath = path11.resolve(filePath);
   const normalizedAbsolutePath = normalizePath3(absolutePath);
   const normalizedSrcDir = normalizePath3(getSrcDir3());
   if (!normalizedAbsolutePath.startsWith(normalizedSrcDir) || !normalizedAbsolutePath.endsWith(".ts")) {
@@ -3490,7 +3702,7 @@ var resolveApiRouteMetaFromPath = (filePath) => {
     return null;
   }
   const rules2 = getRoutingRules();
-  const relativePath = normalizePath3(path10.relative(getSrcDir3(), absolutePath));
+  const relativePath = normalizePath3(path11.relative(getSrcDir3(), absolutePath));
   const segments = relativePath.split("/");
   const apiIndex = segments.indexOf(rules2.apiMarker);
   if (apiIndex === -1 || apiIndex === segments.length - 1) {
@@ -3510,7 +3722,7 @@ var resolveApiRouteMetaFromPath = (filePath) => {
   return { routeKey, absolutePath };
 };
 var resolveSyncRouteMetaFromPath = (filePath) => {
-  const absolutePath = path10.resolve(filePath);
+  const absolutePath = path11.resolve(filePath);
   const normalizedAbsolutePath = normalizePath3(absolutePath);
   const normalizedSrcDir = normalizePath3(getSrcDir3());
   if (!normalizedAbsolutePath.startsWith(normalizedSrcDir) || !normalizedAbsolutePath.endsWith(".ts")) {
@@ -3520,7 +3732,7 @@ var resolveSyncRouteMetaFromPath = (filePath) => {
     return null;
   }
   const rules2 = getRoutingRules();
-  const relativePath = normalizePath3(path10.relative(getSrcDir3(), absolutePath));
+  const relativePath = normalizePath3(path11.relative(getSrcDir3(), absolutePath));
   const segments = relativePath.split("/");
   const syncIndex = segments.indexOf(rules2.syncMarker);
   if (syncIndex === -1 || syncIndex === segments.length - 1) {
@@ -3564,13 +3776,13 @@ var importFile = async (absolutePath) => {
 };
 var collectTsFiles = (dir, relativeTo = "") => {
   const results = [];
-  const entries = fs7.readdirSync(dir);
+  const entries = fs8.readdirSync(dir);
   for (const entry of entries) {
     if (entry === "node_modules") continue;
-    const entryPath = path10.join(dir, entry);
+    const entryPath = path11.join(dir, entry);
     if (isIgnoredPath(entryPath)) continue;
     const relPath = relativeTo ? `${relativeTo}/${entry}` : entry;
-    if (fs7.statSync(entryPath).isDirectory()) {
+    if (fs8.statSync(entryPath).isDirectory()) {
       if (isNonRouteDirectory(entry)) continue;
       results.push(...collectTsFiles(entryPath, relPath));
     } else if (entry.endsWith(".ts") && !isTestFile3(entry)) {
@@ -3602,16 +3814,16 @@ var resolveFunctionModule = (loadedModule, fileName) => {
 var initializeApis = async () => {
   for (const key of Object.keys(devApis)) delete devApis[key];
   clearRuntimeTypeResolverCache();
-  const srcFolder = fs7.readdirSync(getSrcDir3());
+  const srcFolder = fs8.readdirSync(getSrcDir3());
   for (const file of srcFolder) {
     await scanApiFolder(file);
   }
 };
 var upsertApiFromFile = async (filePath) => {
-  if (isIgnoredPath(path10.resolve(filePath))) return;
+  if (isIgnoredPath(path11.resolve(filePath))) return;
   const routeMeta = resolveApiRouteMetaFromPath(filePath);
   if (!routeMeta) {
-    const normalized = normalizePath3(path10.resolve(filePath));
+    const normalized = normalizePath3(path11.resolve(filePath));
     if (normalized.endsWith(".ts") && normalized.includes(apiMarkerSegment()) && isRouteSurfaceFile(normalized)) {
       console.log(
         `[loader][api] invalid filename: ${normalized}. Expected <name>_v<number>.ts. File will not be loaded.`,
@@ -3659,13 +3871,13 @@ var removeApiFromFile = (filePath) => {
   delete devApis[routeMeta.routeKey];
 };
 var scanApiFolder = async (file, basePath = "") => {
-  const fullPath = path10.join(getSrcDir3(), basePath, file);
+  const fullPath = path11.join(getSrcDir3(), basePath, file);
   if (isIgnoredPath(fullPath)) return;
-  if (!fs7.statSync(fullPath).isDirectory()) return;
+  if (!fs8.statSync(fullPath).isDirectory()) return;
   if (file !== getRoutingRules().apiMarker) {
-    const subFolders = fs7.readdirSync(fullPath);
+    const subFolders = fs8.readdirSync(fullPath);
     for (const sub of subFolders) {
-      await scanApiFolder(sub, path10.join(basePath, file));
+      await scanApiFolder(sub, path11.join(basePath, file));
     }
     return;
   }
@@ -3678,7 +3890,7 @@ var scanApiFolder = async (file, basePath = "") => {
     const versionMatch = rawApiName.match(apiRules.apiVersionRegex);
     if (!versionMatch) {
       console.log(
-        `[loader][api] invalid filename: ${path10.join(fullPath, relFile)}. Expected <name>_v<number>.ts. File will not be loaded.`,
+        `[loader][api] invalid filename: ${path11.join(fullPath, relFile)}. Expected <name>_v<number>.ts. File will not be loaded.`,
         "red"
       );
       continue;
@@ -3686,7 +3898,7 @@ var scanApiFolder = async (file, basePath = "") => {
     const version = `v${versionMatch[1]}`;
     const apiName = rawApiName.replace(apiRules.apiVersionRegex, "");
     const routeKey = `api/${mappedPageLocation}/${apiName}/${version}`;
-    const modulePath = path10.resolve(path10.join(fullPath, relFile));
+    const modulePath = path11.resolve(path11.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");
@@ -3715,16 +3927,16 @@ var scanApiFolder = async (file, basePath = "") => {
 var initializeSyncs = async () => {
   for (const key of Object.keys(devSyncs)) delete devSyncs[key];
   clearRuntimeTypeResolverCache();
-  const srcFolder = fs7.readdirSync(getSrcDir3());
+  const srcFolder = fs8.readdirSync(getSrcDir3());
   for (const file of srcFolder) {
     await scanSyncFolder(file);
   }
 };
 var upsertSyncFromFile = async (filePath) => {
-  if (isIgnoredPath(path10.resolve(filePath))) return;
+  if (isIgnoredPath(path11.resolve(filePath))) return;
   const routeMeta = resolveSyncRouteMetaFromPath(filePath);
   if (!routeMeta) {
-    const normalized = normalizePath3(path10.resolve(filePath));
+    const normalized = normalizePath3(path11.resolve(filePath));
     if (normalized.endsWith(".ts") && normalized.includes(syncMarkerSegment()) && isRouteSurfaceFile(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.`,
@@ -3777,13 +3989,13 @@ var removeSyncFromFile = (filePath) => {
   delete devSyncs[routeMeta.routeKey];
 };
 var scanSyncFolder = async (file, basePath = "") => {
-  const fullPath = path10.join(getSrcDir3(), basePath, file);
+  const fullPath = path11.join(getSrcDir3(), basePath, file);
   if (isIgnoredPath(fullPath)) return;
-  if (!fs7.statSync(fullPath).isDirectory()) return;
+  if (!fs8.statSync(fullPath).isDirectory()) return;
   if (file !== getRoutingRules().syncMarker) {
-    const subFolders = fs7.readdirSync(fullPath);
+    const subFolders = fs8.readdirSync(fullPath);
     for (const sub of subFolders) {
-      await scanSyncFolder(sub, path10.join(basePath, file));
+      await scanSyncFolder(sub, path11.join(basePath, file));
     }
     return;
   }
@@ -3795,7 +4007,7 @@ var scanSyncFolder = async (file, basePath = "") => {
     const syncMatch = rawSyncFileName.match(syncRules.syncVersionRegex);
     if (!syncMatch) {
       console.log(
-        `[loader][sync] invalid filename: ${path10.join(fullPath, relFile)}. Expected <name>_server_v<number>.ts or <name>_client_v<number>.ts. File will not be loaded.`,
+        `[loader][sync] invalid filename: ${path11.join(fullPath, relFile)}. Expected <name>_server_v<number>.ts or <name>_client_v<number>.ts. File will not be loaded.`,
         "red"
       );
       continue;
@@ -3805,7 +4017,7 @@ var scanSyncFolder = async (file, basePath = "") => {
     const syncName = rawSyncFileName.replace(syncRules.syncVersionRegex, "");
     const mappedPageLocation = mapSyncPageLocation(pageLocation);
     const routeBaseKey = `sync/${mappedPageLocation}/${syncName}/${version}`;
-    const filePath = path10.resolve(path10.join(fullPath, relFile));
+    const filePath = path11.resolve(path11.join(fullPath, relFile));
     const [fileError, fileResult] = await tryCatch(async () => importFile(filePath));
     if (fileError) {
       console.log(`[loader][sync] failed to import ${filePath}:`, fileError, "red");
@@ -3837,7 +4049,7 @@ var initializeFunctions = async () => {
     }
   });
   for (const functionModule of modules) {
-    const absolutePath = path10.resolve(ROOT_DIR6, functionModule.sourcePath);
+    const absolutePath = path11.resolve(ROOT_DIR6, functionModule.sourcePath);
     const [err, module] = await tryCatch(async () => importFile(absolutePath));
     if (err) {
       console.log(`[loader][function] failed to import ${absolutePath}:`, err, "red");
@@ -3860,19 +4072,25 @@ var initializeFunctions = async () => {
 
 // src/hotReload.ts
 import { watch } from "chokidar";
-import fs11 from "fs";
-import path14 from "path";
+import fs12 from "fs";
+import path15 from "path";
 
 // src/templateInjector.ts
-import fs8 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path12 from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "url";
-import * as ts9 from "typescript";
+import { ScriptKind as ScriptKind3 } from "typescript-7-api/ast";
+import {
+  isIdentifier as isIdentifier8,
+  isInterfaceDeclaration as isInterfaceDeclaration6,
+  isPropertySignatureDeclaration as isPropertySignatureDeclaration4,
+  isTypeLiteralNode as isTypeLiteralNode3
+} from "typescript-7-api/ast/is";
 import { ROOT_DIR as ROOT_DIR7, getGeneratedSocketTypesPath as getGeneratedSocketTypesPath6, getSrcDir as getSrcDir4 } from "@luckystack/core";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path11.dirname(__filename);
-var templatesDir = path11.join(__dirname, "templates");
-var getConsumerTemplatesDir = () => path11.join(ROOT_DIR7, ".luckystack", "templates");
+var __dirname = path12.dirname(__filename);
+var templatesDir = path12.join(__dirname, "templates");
+var getConsumerTemplatesDir = () => path12.join(ROOT_DIR7, ".luckystack", "templates");
 var templateContentFilenames = (kind) => {
   const builtIn = BUILT_IN_TEMPLATE_FILENAMES[kind];
   if (builtIn) return [builtIn];
@@ -3881,10 +4099,10 @@ var templateContentFilenames = (kind) => {
 var resolveTemplateContent = (kind) => {
   const consumerDir = getConsumerTemplatesDir();
   for (const fileName of templateContentFilenames(kind)) {
-    const consumerFile = path11.join(consumerDir, fileName);
-    if (fs8.existsSync(consumerFile)) {
+    const consumerFile = path12.join(consumerDir, fileName);
+    if (fs9.existsSync(consumerFile)) {
       try {
-        return fs8.readFileSync(consumerFile, "utf8");
+        return fs9.readFileSync(consumerFile, "utf8");
       } catch (error) {
         console.error(`[TemplateInjector] Could not read consumer template: ${consumerFile}`, error);
       }
@@ -3894,9 +4112,9 @@ var resolveTemplateContent = (kind) => {
   if (override !== null) return override;
   const builtInName = BUILT_IN_TEMPLATE_FILENAMES[kind];
   if (builtInName) {
-    const bundled = path11.join(templatesDir, builtInName);
+    const bundled = path12.join(templatesDir, builtInName);
     try {
-      return fs8.readFileSync(bundled, "utf8");
+      return fs9.readFileSync(bundled, "utf8");
     } catch (error) {
       console.error(`[TemplateInjector] Could not read bundled template: ${bundled}`, error);
       return null;
@@ -3910,11 +4128,11 @@ var ensureConsumerTemplateConfigLoaded = () => {
   consumerTemplateConfig ??= (async () => {
     const dir = getConsumerTemplatesDir();
     for (const fileName of ["templateRules.ts", "templateRules.mjs", "templateRules.js"]) {
-      const rulesFile = path11.join(dir, fileName);
-      if (!fs8.existsSync(rulesFile)) continue;
-      const resolvedRulesFile = path11.resolve(rulesFile);
-      const resolvedRoot = path11.resolve(ROOT_DIR7);
-      if (!resolvedRulesFile.startsWith(resolvedRoot + path11.sep) && resolvedRulesFile !== resolvedRoot) {
+      const rulesFile = path12.join(dir, fileName);
+      if (!fs9.existsSync(rulesFile)) continue;
+      const resolvedRulesFile = path12.resolve(rulesFile);
+      const resolvedRoot = path12.resolve(ROOT_DIR7);
+      if (!resolvedRulesFile.startsWith(resolvedRoot + path12.sep) && resolvedRulesFile !== resolvedRoot) {
         console.warn(
           `[TemplateInjector] Template rules file resolves outside project root \u2014 skipping: ${rulesFile}`
         );
@@ -3932,7 +4150,7 @@ var ensureConsumerTemplateConfigLoaded = () => {
 };
 var isEmptyFile = (filePath) => {
   try {
-    const content = fs8.readFileSync(filePath, "utf8");
+    const content = fs9.readFileSync(filePath, "utf8");
     return content.trim().length === 0;
   } catch {
     return false;
@@ -3940,7 +4158,7 @@ var isEmptyFile = (filePath) => {
 };
 var isCommentOnlyFile = (filePath) => {
   try {
-    const content = fs8.readFileSync(filePath, "utf8");
+    const content = fs9.readFileSync(filePath, "utf8");
     const withoutBlockComments = content.replaceAll(/\/\*[\s\S]*?\*\//g, "");
     const withoutLineComments = withoutBlockComments.replaceAll(/(^|\s)\/\/.*$/gm, "$1");
     return withoutLineComments.trim().length === 0;
@@ -3974,7 +4192,7 @@ var isVersionedSyncFile = (filePath) => {
   return isVersionedSyncFileName(filePath);
 };
 var getFileName = (filePath) => {
-  return path11.basename(filePath.replaceAll("\\", "/"));
+  return path12.basename(filePath.replaceAll("\\", "/"));
 };
 var stripTsExtension = (fileName) => {
   return fileName.replace(/\.ts$/, "");
@@ -4050,7 +4268,7 @@ var getInvalidVersionMessage = (filePath) => {
 var computeSrcRelativePath = (filePath) => {
   try {
     const srcDir = getSrcDir4();
-    const absolute = path11.resolve(filePath);
+    const absolute = path12.resolve(filePath);
     const normalizedSrc = srcDir.replaceAll("\\", "/");
     const normalizedAbs = absolute.replaceAll("\\", "/");
     if (!normalizedAbs.startsWith(`${normalizedSrc}/`)) return null;
@@ -4098,7 +4316,7 @@ var getPairedSyncFile = (filePath) => {
 var hasPairedFile = (filePath) => {
   const pairedPath = getPairedSyncFile(filePath);
   if (!pairedPath) return false;
-  return fs8.existsSync(pairedPath);
+  return fs9.existsSync(pairedPath);
 };
 var extractSyncPagePath2 = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
@@ -4111,14 +4329,14 @@ var extractSyncName2 = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
   const match = /_sync\/(.+)\.ts$/.exec(normalized);
   if (!match) {
-    const basename = path11.basename(filePath, ".ts");
+    const basename = path12.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 = fs8.readFileSync(filePath, "utf8");
+    const content = fs9.readFileSync(filePath, "utf8");
     const syncParamsMatch = /interface\s+SyncParams\s*\{/.exec(content);
     if (!syncParamsMatch) return null;
     const searchRegion = content.slice(syncParamsMatch.index + syncParamsMatch[0].length);
@@ -4149,7 +4367,7 @@ var extractClientInputFromFile = (filePath) => {
 var extractClientInputFromGeneratedTypes = (pagePath, syncName) => {
   try {
     const generatedTypesPath = getGeneratedSocketTypesPath6();
-    const content = fs8.readFileSync(generatedTypesPath, "utf8");
+    const content = fs9.readFileSync(generatedTypesPath, "utf8");
     const escapeRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
     const escapedPagePath = escapeRegex(pagePath);
     const escapedSyncName = escapeRegex(syncName);
@@ -4195,7 +4413,7 @@ var calculateRelativePath = (filePath) => {
   const srcRelative = computeSrcRelativePath(filePath);
   if (srcRelative !== null) {
     try {
-      const srcDepthFromRoot = path11.relative(ROOT_DIR7, getSrcDir4()).replaceAll("\\", "/").split("/").filter((segment) => segment.length > 0).length;
+      const srcDepthFromRoot = path12.relative(ROOT_DIR7, getSrcDir4()).replaceAll("\\", "/").split("/").filter((segment) => segment.length > 0).length;
       const dirSegmentsAfterSrc = Math.max(
         0,
         srcRelative.split("/").filter((segment) => segment.length > 0).length - 1
@@ -4274,7 +4492,7 @@ var getTemplate = (filePath) => {
 var injectTemplate = async (filePath) => {
   await ensureConsumerTemplateConfigLoaded();
   if (getRouteFilenameValidationMessage(filePath)) {
-    fs8.writeFileSync(filePath, getInvalidVersionMessage(filePath), "utf8");
+    fs9.writeFileSync(filePath, getInvalidVersionMessage(filePath), "utf8");
     console.log(`[TemplateInjector] Invalid route filename, injected guidance: ${filePath}`);
     return true;
   }
@@ -4283,7 +4501,7 @@ var injectTemplate = async (filePath) => {
     return false;
   }
   try {
-    fs8.writeFileSync(filePath, template, "utf8");
+    fs9.writeFileSync(filePath, template, "utf8");
     console.log(`[TemplateInjector] Injected template into: ${filePath}`);
     return true;
   } catch (error) {
@@ -4339,18 +4557,10 @@ var rewriteClientInputType = (content) => {
   );
 };
 var rewriteClientInputTypeAst = (content, sourceFileName) => {
-  const parseSource = (src) => ts9.createSourceFile(
-    sourceFileName,
-    src,
-    ts9.ScriptTarget.Latest,
-    /* setParentNodes */
-    true,
-    ts9.ScriptKind.TS
-  );
-  const sourceFile = parseSource(content);
+  const sourceFile = parseSourceText(sourceFileName, content, ScriptKind3.TS);
   let syncParamsInterface;
   for (const stmt of sourceFile.statements) {
-    if (ts9.isInterfaceDeclaration(stmt) && stmt.name.text === "SyncParams") {
+    if (isInterfaceDeclaration6(stmt) && stmt.name.text === "SyncParams") {
       syncParamsInterface = stmt;
       break;
     }
@@ -4358,30 +4568,18 @@ var rewriteClientInputTypeAst = (content, sourceFileName) => {
   if (!syncParamsInterface) return null;
   let clientInputMember;
   for (const member of syncParamsInterface.members) {
-    if (ts9.isPropertySignature(member) && ts9.isIdentifier(member.name) && member.name.text === "clientInput") {
+    if (isPropertySignatureDeclaration4(member) && isIdentifier8(member.name) && member.name.text === "clientInput") {
       clientInputMember = member;
       break;
     }
   }
   if (!clientInputMember?.type) return null;
-  if (!ts9.isTypeLiteralNode(clientInputMember.type)) return null;
+  if (!isTypeLiteralNode3(clientInputMember.type)) return null;
   const typeNode = clientInputMember.type;
   const start = typeNode.getStart(sourceFile);
   const end = typeNode.getEnd();
   const rewritten = `${content.slice(0, start)}SyncClientInput<PagePath, SyncName>${content.slice(end)}`;
-  const reparsedFile = parseSource(rewritten);
-  const verifyProgram = ts9.createProgram({
-    rootNames: [sourceFileName],
-    options: { noResolve: true, skipLibCheck: true },
-    // Supply the in-memory source so `ts.createProgram` never touches the disk.
-    host: {
-      ...ts9.createCompilerHost({}),
-      getSourceFile: (name) => name === sourceFileName ? reparsedFile : void 0,
-      fileExists: (name) => name === sourceFileName,
-      readFile: (name) => name === sourceFileName ? rewritten : void 0
-    }
-  });
-  const syntaxErrors = verifyProgram.getSyntacticDiagnostics(reparsedFile);
+  const syntaxErrors = transpileSourceText(sourceFileName, rewritten).diagnostics ?? [];
   if (syntaxErrors.length > 0) {
     console.log(
       `[TemplateInjector] AST rewrite produced invalid TypeScript for ${sourceFileName} \u2014 leaving untouched`,
@@ -4411,10 +4609,10 @@ var updateClientFileForPairedServer = async (clientFilePath) => {
   try {
     const pagePath = extractSyncPagePath2(clientFilePath);
     const syncName = extractSyncName2(clientFilePath);
-    let content = fs8.readFileSync(clientFilePath, "utf8");
+    let content = fs9.readFileSync(clientFilePath, "utf8");
     content = ensureImportedTypes(content, clientFilePath);
     content = insertTypeAliases(content, pagePath, syncName);
-    const astResult = rewriteClientInputTypeAst(content, path11.basename(clientFilePath));
+    const astResult = rewriteClientInputTypeAst(content, path12.basename(clientFilePath));
     if (astResult === null) {
       console.log(
         `[TemplateInjector] AST clientInput rewrite unavailable for ${clientFilePath} \u2014 using regex fallback`,
@@ -4426,7 +4624,7 @@ var updateClientFileForPairedServer = async (clientFilePath) => {
     }
     content = addServerOutputToParams(content);
     content = addServerOutputToDestructuring(content);
-    fs8.writeFileSync(clientFilePath, content, "utf8");
+    fs9.writeFileSync(clientFilePath, content, "utf8");
     console.log(`[TemplateInjector] Updated client file to use paired types (preserved code): ${clientFilePath}`);
     return true;
   } catch (error) {
@@ -4467,7 +4665,7 @@ var splitAtMainBody = (content) => {
 };
 var updateClientFileForDeletedServer = async (clientFilePath, clientInputTypes) => {
   try {
-    let content = fs8.readFileSync(clientFilePath, "utf8");
+    let content = fs9.readFileSync(clientFilePath, "utf8");
     content = inlineClientInputType(content, clientInputTypes);
     const [header, body] = splitAtMainBody(content);
     const cleanedHeader = removeServerOutputFromDestructuring(removeServerOutputFromParams(header));
@@ -4475,7 +4673,7 @@ var updateClientFileForDeletedServer = async (clientFilePath, clientInputTypes)
     content = removeGeneratedTypeImports(content);
     content = removeTypeAliases(content);
     content = content.replaceAll(/\n{3,}/g, "\n\n");
-    fs8.writeFileSync(clientFilePath, content, "utf8");
+    fs9.writeFileSync(clientFilePath, content, "utf8");
     console.log(`[TemplateInjector] Updated client file for deleted server (preserved code): ${clientFilePath}`);
     return true;
   } catch (error) {
@@ -4501,7 +4699,7 @@ var injectServerTemplateWithClientInput = async (serverFilePath, clientInputType
       /clientInput:\s*\{[^}]*\}/s,
       (_match) => `clientInput: ${clientInputTypes}`
     );
-    fs8.writeFileSync(serverFilePath, content, "utf8");
+    fs9.writeFileSync(serverFilePath, content, "utf8");
     console.log(`[TemplateInjector] Injected server template with clientInput: ${serverFilePath}`);
     return true;
   } catch (error) {
@@ -4511,24 +4709,24 @@ var injectServerTemplateWithClientInput = async (serverFilePath, clientInputType
 };
 
 // src/importDependencyGraph.ts
-import fs9 from "fs";
-import path12 from "path";
+import fs10 from "fs";
+import path13 from "path";
 import { ROOT_DIR as ROOT_DIR8, getServerFunctionDirs as getServerFunctionDirs2, getSharedDir, getSrcDir as getSrcDir5 } from "@luckystack/core";
 var SUPPORTED_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"];
-var normalizePath4 = (value) => path12.resolve(value).replaceAll("\\", "/");
+var normalizePath4 = (value) => path13.resolve(value).replaceAll("\\", "/");
 var isSupportedScriptFile = (value) => {
   return SUPPORTED_EXTENSIONS.some((extension) => value.endsWith(extension));
 };
 var existsFile = (value) => {
   try {
-    return fs9.existsSync(value) && fs9.statSync(value).isFile();
+    return fs10.existsSync(value) && fs10.statSync(value).isFile();
   } catch {
     return false;
   }
 };
 var existsDirectory = (value) => {
   try {
-    return fs9.existsSync(value) && fs9.statSync(value).isDirectory();
+    return fs10.existsSync(value) && fs10.statSync(value).isDirectory();
   } catch {
     return false;
   }
@@ -4539,16 +4737,16 @@ var collectScriptFiles = (dir, output, visited = /* @__PURE__ */ new Set()) => {
   }
   let realDir;
   try {
-    realDir = fs9.realpathSync(dir);
+    realDir = fs10.realpathSync(dir);
   } catch {
     return;
   }
   if (visited.has(realDir)) return;
   visited.add(realDir);
-  const entries = fs9.readdirSync(dir, { withFileTypes: true });
+  const entries = fs10.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === "node_modules") continue;
-    const fullPath = path12.join(dir, entry.name);
+    const fullPath = path13.join(dir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       if (existsDirectory(fullPath)) {
         collectScriptFiles(fullPath, output, visited);
@@ -4567,7 +4765,7 @@ var SCOPED_FILES_TTL_MS = 1e3;
 var extractImportSpecifiers = (filePath) => {
   let mtimeMs = 0;
   try {
-    mtimeMs = fs9.statSync(filePath).mtimeMs;
+    mtimeMs = fs10.statSync(filePath).mtimeMs;
   } catch {
     specifiersCache.delete(filePath);
     return [];
@@ -4577,7 +4775,7 @@ var extractImportSpecifiers = (filePath) => {
     return cached.specifiers;
   }
   try {
-    const source = fs9.readFileSync(filePath, "utf8");
+    const source = fs10.readFileSync(filePath, "utf8");
     const specifiers = /* @__PURE__ */ new Set();
     const importExportRegex = /(?:import|export)\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
     const dynamicImportRegex = /import\(\s*['"]([^'"]+)['"]\s*\)/g;
@@ -4612,7 +4810,7 @@ var tryResolveWithExtensions = (basePath) => {
   }
   if (existsDirectory(basePath)) {
     for (const extension of SUPPORTED_EXTENSIONS) {
-      const indexFile = path12.join(basePath, `index${extension}`);
+      const indexFile = path13.join(basePath, `index${extension}`);
       if (existsFile(indexFile)) {
         return normalizePath4(indexFile);
       }
@@ -4625,18 +4823,18 @@ var resolveImportToFile = (importerPath, specifier) => {
     return null;
   }
   if (specifier === "config") {
-    return tryResolveWithExtensions(path12.join(ROOT_DIR8, "config"));
+    return tryResolveWithExtensions(path13.join(ROOT_DIR8, "config"));
   }
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    const relativeBase = path12.resolve(path12.dirname(importerPath), specifier);
+    const relativeBase = path13.resolve(path13.dirname(importerPath), specifier);
     return tryResolveWithExtensions(relativeBase);
   }
   if (specifier.startsWith("src/") || specifier.startsWith("@/")) {
     const sourcePath = specifier.startsWith("@/") ? specifier.slice(2) : specifier.slice(4);
-    return tryResolveWithExtensions(path12.join(getSrcDir5(), sourcePath));
+    return tryResolveWithExtensions(path13.join(getSrcDir5(), sourcePath));
   }
   if (specifier.startsWith("shared/")) {
-    return tryResolveWithExtensions(path12.join(getSharedDir(), specifier.slice(7)));
+    return tryResolveWithExtensions(path13.join(getSharedDir(), specifier.slice(7)));
   }
   return null;
 };
@@ -4654,7 +4852,7 @@ var collectScopedFiles = () => {
   for (const dir of getServerFunctionDirs2()) {
     collectScriptFiles(dir, files);
   }
-  const configFile = tryResolveWithExtensions(path12.join(ROOT_DIR8, "config"));
+  const configFile = tryResolveWithExtensions(path13.join(ROOT_DIR8, "config"));
   if (configFile) {
     files.add(configFile);
   }
@@ -4702,19 +4900,19 @@ var findDependentRouteFiles = (changedFilePath) => {
 };
 
 // src/prismaClientCheck.ts
-import fs10 from "fs";
-import path13 from "path";
+import fs11 from "fs";
+import path14 from "path";
 import { spawn } from "child_process";
 import { ROOT_DIR as ROOT_DIR9, tryCatch as tryCatch2 } from "@luckystack/core";
-var GENERATED_CLIENT_DIR = path13.join(ROOT_DIR9, "node_modules", ".prisma", "client");
-var GENERATED_CLIENT_MARKER = path13.join(GENERATED_CLIENT_DIR, "schema.prisma");
-var DEFAULT_SCHEMA_PATH = path13.join(ROOT_DIR9, "prisma", "schema.prisma");
-var isPrismaClientMissing = () => fs10.existsSync(DEFAULT_SCHEMA_PATH) && !fs10.existsSync(GENERATED_CLIENT_MARKER);
+var GENERATED_CLIENT_DIR = path14.join(ROOT_DIR9, "node_modules", ".prisma", "client");
+var GENERATED_CLIENT_MARKER = path14.join(GENERATED_CLIENT_DIR, "schema.prisma");
+var DEFAULT_SCHEMA_PATH = path14.join(ROOT_DIR9, "prisma", "schema.prisma");
+var isPrismaClientMissing = () => fs11.existsSync(DEFAULT_SCHEMA_PATH) && !fs11.existsSync(GENERATED_CLIENT_MARKER);
 var runPrismaGenerate = async () => tryCatch2(
   () => new Promise((resolve, reject) => {
     const localBinName = process.platform === "win32" ? "prisma.cmd" : "prisma";
-    const localBin = path13.join(ROOT_DIR9, "node_modules", ".bin", localBinName);
-    const useLocal = fs10.existsSync(localBin);
+    const localBin = path14.join(ROOT_DIR9, "node_modules", ".bin", localBinName);
+    const useLocal = fs11.existsSync(localBin);
     const [cmd, args] = useLocal ? [localBin, ["generate"]] : [process.platform === "win32" ? "npx.cmd" : "npx", ["prisma", "generate"]];
     const isWinShim = process.platform === "win32" && /\.(cmd|bat)$/i.test(cmd);
     const child = isWinShim ? spawn(
@@ -4735,7 +4933,7 @@ var runPrismaGenerate = async () => tryCatch2(
 
 // src/hotReload.ts
 import { tryCatch as tryCatch3, getProjectConfig, getLocaleReloader, isProductionRuntime } from "@luckystack/core";
-var normalizeFsPath = (value) => path14.resolve(value).replaceAll("\\", "/");
+var normalizeFsPath = (value) => path15.resolve(value).replaceAll("\\", "/");
 var isGeneratedPath = (normalizedPath) => {
   return normalizedPath.includes("apiTypes.generated.ts") || normalizedPath.includes("apiDocs.generated.json");
 };
@@ -4943,7 +5141,7 @@ var setupWatchers = () => {
     if (shouldInjectTemplate(filePath, { isNewFile: true })) {
       if (isSyncServerFile(normalizedPath)) {
         const clientPath = getPairedSyncFile(normalizedPath);
-        if (clientPath && fs11.existsSync(clientPath) && !isEmptyFile(clientPath)) {
+        if (clientPath && fs12.existsSync(clientPath) && !isEmptyFile(clientPath)) {
           const clientInputTypes = extractClientInputFromFile(clientPath);
           if (clientInputTypes) {
             await injectServerTemplateWithClientInput(filePath, clientInputTypes);
@@ -5106,7 +5304,7 @@ var setupWatchers = () => {
       scheduleReload("sync", async () => {
         if (isSyncServerFile(normalizedPath)) {
           const clientPath = getPairedSyncFile(normalizedPath);
-          if (clientPath && fs11.existsSync(clientPath)) {
+          if (clientPath && fs12.existsSync(clientPath)) {
             const pagePath = extractSyncPagePath2(normalizedPath);
             const syncName = extractSyncName2(normalizedPath);
             const clientInputTypes = extractClientInputFromGeneratedTypes(pagePath, syncName);