@luckystack/devkit 0.8.6 → 0.9.0

package/dist/index.js

@@ -3,11 +3,12 @@ import {
 } from "./chunk-IWGWJU4M.js";
 
 // src/typeMap/discovery.ts
-import fs from "fs";
-import path from "path";
-import { ROOT_DIR } from "@luckystack/core";
+import fs2 from "fs";
+import path2 from "path";
+import { ROOT_DIR as ROOT_DIR2 } from "@luckystack/core";
 
 // src/routingRules.ts
+import { isTestDirectory } from "@luckystack/core";
 import { validatePagePath as corePagePath } from "@luckystack/core";
 var DEFAULT_RULES = {
   apiMarker: "_api",
@@ -66,24 +67,371 @@ var isSyncFileName = (fileName) => {
 var isRouteTestFile = (fileNameOrPath) => {
   return fileNameOrPath.endsWith(".tests.ts");
 };
-var validatePagePath = (srcRelativePath) => {
-  const rules2 = getRoutingRules();
-  const pageRules = {
-    privateFolderPrefix: rules2.privateFolderPrefix,
-    scaffoldIgnoredFolders: rules2.scaffoldIgnoredFolders
-  };
-  return corePagePath(srcRelativePath, pageRules);
+var isNonRouteDirectory = (directoryName) => directoryName.startsWith(getRoutingRules().privateFolderPrefix) || isTestDirectory(directoryName);
+var validatePagePath = (srcRelativePath) => {
+  const rules2 = getRoutingRules();
+  const pageRules = {
+    privateFolderPrefix: rules2.privateFolderPrefix,
+    scaffoldIgnoredFolders: rules2.scaffoldIgnoredFolders
+  };
+  return corePagePath(srcRelativePath, pageRules);
+};
+
+// src/routeNamingValidation.ts
+import fs from "fs";
+import path from "path";
+import { ROOT_DIR, isTestFile } from "@luckystack/core";
+
+// src/routeConventions.ts
+var API_VERSION_TOKEN_REGEX = /_v(\d+)$/;
+var SYNC_VERSION_TOKEN_REGEX = /_(server|client)_v(\d+)$/;
+var ROUTE_NAMING_RULES = {
+  api: "<name>_v<number>.ts",
+  syncServer: "<name>_server_v<number>.ts",
+  syncClient: "<name>_client_v<number>.ts"
+};
+var ROUTE_NAMING_EXAMPLES = {
+  api: "updateUser_v1.ts",
+  syncServer: "updateCounter_server_v1.ts",
+  syncClient: "updateCounter_client_v1.ts"
+};
+var isVersionedApiFileName = (fileName) => isApiFileName(fileName);
+var isVersionedSyncFileName = (fileName) => isSyncFileName(fileName);
+var isVersionedSyncServerFileName = (fileName) => isSyncServerFileName(fileName);
+var isVersionedSyncClientFileName = (fileName) => isSyncClientFileName(fileName);
+
+// src/internal/mapUtils.ts
+var getOrInit = (map, key, factory) => {
+  const existing = map.get(key);
+  if (existing !== void 0) return existing;
+  const fresh = factory();
+  map.set(key, fresh);
+  return fresh;
+};
+var mustGet = (map, key, label) => {
+  const value = map.get(key);
+  if (value === void 0) {
+    throw new Error(`[devkit] invariant violation: '${String(key)}' missing from ${label}`);
+  }
+  return value;
+};
+
+// src/routeNamingValidation.ts
+var normalizePath = (value) => {
+  return value.replaceAll("\\", "/");
+};
+var toRel = (absolute) => path.relative(ROOT_DIR, absolute).replaceAll("\\", "/");
+var isInsidePrivateRouteSubfolder = (fullPath) => {
+  const { privateFolderPrefix, apiMarker, syncMarker } = getRoutingRules();
+  const segments = normalizePath(fullPath).split("/");
+  const markerIndex = segments.findLastIndex((segment) => segment === apiMarker || segment === syncMarker);
+  if (markerIndex === -1) return false;
+  return segments.slice(markerIndex + 1).some((segment) => segment.startsWith(privateFolderPrefix));
+};
+var isRouteSurfaceFile = (fullPath) => !isInsidePrivateRouteSubfolder(fullPath) && !isTestFile(fullPath);
+var walkRouteFiles = (dir, results = []) => {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const apiSeg = apiMarkerSegment();
+  const syncSeg = syncMarkerSegment();
+  const { ignore } = getRoutingRules();
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const normalizedFullPath = normalizePath(fullPath);
+    if (ignore(toRel(fullPath))) continue;
+    if (isInsidePrivateRouteSubfolder(fullPath)) continue;
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      walkRouteFiles(fullPath, results);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".ts")) {
+      continue;
+    }
+    if (isRouteTestFile(entry.name)) {
+      continue;
+    }
+    if (normalizedFullPath.includes(apiSeg) || normalizedFullPath.includes(syncSeg)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+};
+var getFileRouteToken = ({
+  normalizedFilePath,
+  marker
+}) => {
+  const markerIndex = normalizedFilePath.indexOf(marker);
+  if (markerIndex === -1) {
+    return "";
+  }
+  const tokenStart = markerIndex + marker.length;
+  return normalizedFilePath.slice(tokenStart, normalizedFilePath.length - ".ts".length);
+};
+var validateRouteFilePath = (filePath) => {
+  const issues = [];
+  const normalizedFilePath = normalizePath(path.resolve(filePath));
+  const fileName = path.basename(filePath);
+  const apiSeg = apiMarkerSegment();
+  const syncSeg = syncMarkerSegment();
+  if (normalizedFilePath.includes(apiSeg)) {
+    const apiRouteToken = getFileRouteToken({ normalizedFilePath, marker: apiSeg });
+    if (apiRouteToken.includes("/")) {
+      issues.push({
+        kind: "api",
+        filePath: normalizedFilePath,
+        reason: 'API route token cannot contain nested path segments ("/").',
+        expected: ROUTE_NAMING_RULES.api
+      });
+    }
+    if (!isVersionedApiFileName(fileName)) {
+      issues.push({
+        kind: "api",
+        filePath: normalizedFilePath,
+        reason: "API filename does not match versioned naming.",
+        expected: ROUTE_NAMING_RULES.api
+      });
+    }
+  }
+  if (normalizedFilePath.includes(syncSeg)) {
+    const syncRouteToken = getFileRouteToken({ normalizedFilePath, marker: syncSeg });
+    if (syncRouteToken.includes("/")) {
+      issues.push({
+        kind: "sync",
+        filePath: normalizedFilePath,
+        reason: 'Sync route token cannot contain nested path segments ("/").',
+        expected: `${ROUTE_NAMING_RULES.syncServer} or ${ROUTE_NAMING_RULES.syncClient}`
+      });
+    }
+    if (!isVersionedSyncFileName(fileName)) {
+      issues.push({
+        kind: "sync",
+        filePath: normalizedFilePath,
+        reason: "Sync filename does not match versioned naming.",
+        expected: `${ROUTE_NAMING_RULES.syncServer} or ${ROUTE_NAMING_RULES.syncClient}`
+      });
+    }
+  }
+  return issues;
+};
+var resolveApiRouteKey = ({
+  srcDir,
+  filePath
+}) => {
+  const rules2 = getRoutingRules();
+  const relativePath = normalizePath(path.relative(srcDir, filePath));
+  const segments = relativePath.split("/");
+  const apiIndex = segments.indexOf(rules2.apiMarker);
+  if (apiIndex === -1 || apiIndex === segments.length - 1) {
+    return null;
+  }
+  const pageLocation = segments.slice(0, apiIndex).join("/");
+  const apiFilePath = segments.slice(apiIndex + 1).join("/");
+  const rawApiName = apiFilePath.replace(/\.ts$/, "");
+  const versionMatch = rawApiName.match(rules2.apiVersionRegex);
+  if (!versionMatch) {
+    return null;
+  }
+  const version = `v${versionMatch[1]}`;
+  const apiName = rawApiName.replace(rules2.apiVersionRegex, "");
+  const mappedPageLocation = pageLocation || "system";
+  return `api/${mappedPageLocation}/${apiName}/${version}`;
+};
+var resolveSyncRouteKey = ({
+  srcDir,
+  filePath
+}) => {
+  const rules2 = getRoutingRules();
+  const relativePath = normalizePath(path.relative(srcDir, filePath));
+  const segments = relativePath.split("/");
+  const syncIndex = segments.indexOf(rules2.syncMarker);
+  if (syncIndex === -1 || syncIndex === segments.length - 1) {
+    return null;
+  }
+  const pageLocation = segments.slice(0, syncIndex).join("/");
+  const syncFilePath = segments.slice(syncIndex + 1).join("/");
+  const rawSyncName = syncFilePath.replace(/\.ts$/, "");
+  const syncMatch = rawSyncName.match(rules2.syncVersionRegex);
+  if (!syncMatch) {
+    return null;
+  }
+  const kind = syncMatch[1];
+  const version = `v${syncMatch[2]}`;
+  const syncName = rawSyncName.replace(rules2.syncVersionRegex, "");
+  const routeBaseKey = pageLocation ? `sync/${pageLocation}/${syncName}/${version}` : `sync/${syncName}/${version}`;
+  return `${routeBaseKey}_${kind}`;
+};
+var collectInvalidRouteNamingIssues = (srcDir) => {
+  const allRouteFiles = walkRouteFiles(srcDir);
+  const issues = [];
+  for (const filePath of allRouteFiles) {
+    issues.push(...validateRouteFilePath(filePath));
+  }
+  return issues.toSorted((a, b) => a.filePath.localeCompare(b.filePath));
+};
+var collectDuplicateNormalizedRouteKeyIssues = (srcDir) => {
+  const allRouteFiles = walkRouteFiles(srcDir);
+  const routeKeyToFilePaths = /* @__PURE__ */ new Map();
+  const routeKeyKinds = /* @__PURE__ */ new Map();
+  const apiSeg = apiMarkerSegment();
+  const syncSeg = syncMarkerSegment();
+  for (const filePath of allRouteFiles) {
+    const normalizedFilePath = normalizePath(path.resolve(filePath));
+    if (normalizedFilePath.includes(apiSeg)) {
+      const routeKey = resolveApiRouteKey({ srcDir, filePath });
+      if (!routeKey) {
+        continue;
+      }
+      getOrInit(routeKeyToFilePaths, routeKey, () => []).push(normalizedFilePath);
+      routeKeyKinds.set(routeKey, "api");
+      continue;
+    }
+    if (normalizedFilePath.includes(syncSeg)) {
+      const routeKey = resolveSyncRouteKey({ srcDir, filePath });
+      if (!routeKey) {
+        continue;
+      }
+      getOrInit(routeKeyToFilePaths, routeKey, () => []).push(normalizedFilePath);
+      routeKeyKinds.set(routeKey, "sync");
+    }
+  }
+  const issues = [];
+  for (const [routeKey, filePaths] of routeKeyToFilePaths.entries()) {
+    if (filePaths.length < 2) {
+      continue;
+    }
+    issues.push({
+      kind: routeKeyKinds.get(routeKey) ?? "api",
+      routeKey,
+      filePaths: filePaths.toSorted((a, b) => a.localeCompare(b))
+    });
+  }
+  return issues.toSorted((a, b) => a.routeKey.localeCompare(b.routeKey));
+};
+var formatRouteNamingIssues = ({
+  issues,
+  context
+}) => {
+  const plural = issues.length === 1 ? "" : "s";
+  const header = `[RouteNaming] Found ${issues.length} invalid API/sync route file${plural} while ${context}.`;
+  const details = issues.map((issue, index) => {
+    return `${index + 1}. [${issue.kind.toUpperCase()}] ${issue.filePath}
+   reason: ${issue.reason}
+   expected: ${issue.expected}`;
+  }).join("\n");
+  return `${header}
+${details}`;
+};
+var formatDuplicateRouteKeyIssues = ({
+  issues,
+  context
+}) => {
+  const plural = issues.length === 1 ? "" : "s";
+  const header = `[RouteNaming] Found ${issues.length} duplicate normalized route key${plural} while ${context}.`;
+  const details = issues.map((issue, index) => {
+    const fileList = issue.filePaths.map((filePath) => `   - ${filePath}`).join("\n");
+    return `${index + 1}. [${issue.kind.toUpperCase()}] ${issue.routeKey}
+   files:
+${fileList}`;
+  }).join("\n");
+  return `${header}
+${details}`;
+};
+var assertValidRouteNaming = ({
+  srcDir,
+  context
+}) => {
+  const issues = collectInvalidRouteNamingIssues(srcDir);
+  if (issues.length === 0) {
+    return;
+  }
+  throw new Error(formatRouteNamingIssues({ issues, context }));
+};
+var assertNoDuplicateNormalizedRouteKeys = ({
+  srcDir,
+  context
+}) => {
+  const issues = collectDuplicateNormalizedRouteKeyIssues(srcDir);
+  if (issues.length === 0) {
+    return;
+  }
+  throw new Error(formatDuplicateRouteKeyIssues({ issues, context }));
+};
+var walkPageFiles = (dir, results = []) => {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      walkPageFiles(fullPath, results);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (entry.name === "page.tsx" || entry.name === "page.jsx") {
+      results.push(fullPath);
+    }
+  }
+  return results;
+};
+var collectDuplicatePageRoutes = (srcDir) => {
+  const pageFiles = walkPageFiles(srcDir);
+  const routeToFiles = /* @__PURE__ */ new Map();
+  for (const absoluteFilePath of pageFiles) {
+    const relative = normalizePath(path.relative(srcDir, absoluteFilePath));
+    const result = validatePagePath(relative);
+    if (!result.valid || !result.route) continue;
+    const list = routeToFiles.get(result.route) ?? [];
+    list.push(normalizePath(path.relative(ROOT_DIR, absoluteFilePath)));
+    routeToFiles.set(result.route, list);
+  }
+  const issues = [];
+  for (const [route, filePaths] of routeToFiles) {
+    if (filePaths.length > 1) {
+      issues.push({ route, filePaths });
+    }
+  }
+  return issues;
+};
+var formatDuplicatePageRouteIssues = ({
+  issues,
+  context
+}) => {
+  const plural = issues.length === 1 ? "" : "s";
+  const header = `[RouteNaming] Found ${issues.length} duplicate page route${plural} while ${context}.`;
+  const details = issues.map((issue, index) => {
+    const fileList = issue.filePaths.map((filePath) => `   - ${filePath}`).join("\n");
+    return `${index + 1}. ${issue.route}
+   files:
+${fileList}
+   fix: rename or move one of the files so only one page.tsx resolves to "${issue.route}". Remember that "_<folder>" segments are stripped from the URL (invisible-parent rule).`;
+  }).join("\n");
+  return `${header}
+${details}`;
+};
+var assertNoDuplicatePageRoutes = ({
+  srcDir,
+  context
+}) => {
+  const issues = collectDuplicatePageRoutes(srcDir);
+  if (issues.length === 0) return;
+  throw new Error(formatDuplicatePageRouteIssues({ issues, context }));
 };
 
 // src/typeMap/discovery.ts
 var toForwardSlashRelative = (absolute) => {
-  const rel = path.relative(ROOT_DIR, absolute);
+  const rel = path2.relative(ROOT_DIR2, absolute);
   return rel.replaceAll("\\", "/");
 };
 var walkFiles = (dir, matcher, results = [], visited = /* @__PURE__ */ new Set()) => {
   let realDir;
   try {
-    realDir = fs.realpathSync(dir);
+    realDir = fs2.realpathSync(dir);
   } catch {
     return results;
   }
@@ -91,15 +439,15 @@ var walkFiles = (dir, matcher, results = [], visited = /* @__PURE__ */ new Set()
   visited.add(realDir);
   const { ignore } = getRoutingRules();
   try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path2.join(dir, entry.name);
       const relativePath = toForwardSlashRelative(fullPath);
       if (ignore(relativePath)) continue;
       if (entry.isDirectory() || entry.isSymbolicLink()) {
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
         try {
-          if (fs.statSync(fullPath).isDirectory()) {
+          if (fs2.statSync(fullPath).isDirectory()) {
             walkFiles(fullPath, matcher, results, visited);
           }
         } catch {
@@ -119,47 +467,27 @@ var findAllApiFiles = (srcDir) => {
   const apiSegment = apiMarkerSegment();
   return walkFiles(srcDir, (fullPath, entryName) => {
     const normalized = fullPath.replaceAll("\\", "/");
-    return isApiFileName(entryName) && normalized.includes(apiSegment);
+    return isApiFileName(entryName) && normalized.includes(apiSegment) && isRouteSurfaceFile(normalized);
   });
 };
 var findAllSyncServerFiles = (srcDir) => {
   const syncSegment = syncMarkerSegment();
   return walkFiles(srcDir, (fullPath, entryName) => {
     const normalized = fullPath.replaceAll("\\", "/");
-    return isSyncServerFileName(entryName) && normalized.includes(syncSegment);
+    return isSyncServerFileName(entryName) && normalized.includes(syncSegment) && isRouteSurfaceFile(normalized);
   });
 };
 var findAllSyncClientFiles = (srcDir) => {
   const syncSegment = syncMarkerSegment();
   return walkFiles(srcDir, (fullPath, entryName) => {
     const normalized = fullPath.replaceAll("\\", "/");
-    return isSyncClientFileName(entryName) && normalized.includes(syncSegment);
+    return isSyncClientFileName(entryName) && normalized.includes(syncSegment) && isRouteSurfaceFile(normalized);
   });
 };
 
 // src/typeMap/routeMeta.ts
-import path2 from "path";
+import path3 from "path";
 import { getSrcDir } from "@luckystack/core";
-
-// src/routeConventions.ts
-var API_VERSION_TOKEN_REGEX = /_v(\d+)$/;
-var SYNC_VERSION_TOKEN_REGEX = /_(server|client)_v(\d+)$/;
-var ROUTE_NAMING_RULES = {
-  api: "<name>_v<number>.ts",
-  syncServer: "<name>_server_v<number>.ts",
-  syncClient: "<name>_client_v<number>.ts"
-};
-var ROUTE_NAMING_EXAMPLES = {
-  api: "updateUser_v1.ts",
-  syncServer: "updateCounter_server_v1.ts",
-  syncClient: "updateCounter_client_v1.ts"
-};
-var isVersionedApiFileName = (fileName) => isApiFileName(fileName);
-var isVersionedSyncFileName = (fileName) => isSyncFileName(fileName);
-var isVersionedSyncServerFileName = (fileName) => isSyncServerFileName(fileName);
-var isVersionedSyncClientFileName = (fileName) => isSyncClientFileName(fileName);
-
-// src/typeMap/routeMeta.ts
 var VERSION_SUFFIX_REGEX = API_VERSION_TOKEN_REGEX;
 var escapeRegExp = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
 var stripVersionSuffix = (name) => {
@@ -173,7 +501,7 @@ var extractVersionFromName = (name) => {
 var extractPagePath = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
   const srcDirNormalized = getSrcDir().replaceAll("\\", "/");
-  const rel = path2.posix.relative(srcDirNormalized, normalized);
+  const rel = path3.posix.relative(srcDirNormalized, normalized);
   if (rel.startsWith("..")) {
     throw new Error(`[routeMeta] file is outside srcDir \u2014 cannot extract page path: ${filePath}`);
   }
@@ -191,20 +519,20 @@ var extractApiName = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
   const { apiMarker } = getRoutingRules();
   const match = new RegExp(String.raw`${escapeRegExp(apiMarker)}\/(.+)\.ts$`).exec(normalized);
-  const rawName = match?.[1] ?? path2.basename(filePath, ".ts");
+  const rawName = match?.[1] ?? path3.basename(filePath, ".ts");
   return stripVersionSuffix(rawName);
 };
 var extractApiVersion = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
   const { apiMarker } = getRoutingRules();
   const match = new RegExp(String.raw`${escapeRegExp(apiMarker)}\/(.+)\.ts$`).exec(normalized);
-  const rawName = match?.[1] ?? path2.basename(filePath, ".ts");
+  const rawName = match?.[1] ?? path3.basename(filePath, ".ts");
   return extractVersionFromName(rawName) ?? "v1";
 };
 var extractSyncPagePath = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
   const srcDirNormalized = getSrcDir().replaceAll("\\", "/");
-  const rel = path2.posix.relative(srcDirNormalized, normalized);
+  const rel = path3.posix.relative(srcDirNormalized, normalized);
   const { syncMarker } = getRoutingRules();
   const match = new RegExp(String.raw`^(?:(.+?)\/)${escapeRegExp(syncMarker)}\/`).exec(rel);
   if (match) {
@@ -220,7 +548,7 @@ var extractSyncName = (filePath) => {
   const { syncMarker } = getRoutingRules();
   const match = new RegExp(String.raw`${escapeRegExp(syncMarker)}\/(.+)\.ts$`).exec(normalized);
   if (!match) {
-    const basename = path2.basename(filePath, ".ts");
+    const basename = path3.basename(filePath, ".ts");
     return basename.replace(SYNC_VERSION_TOKEN_REGEX, "");
   }
   return (match[1] ?? "").replace(SYNC_VERSION_TOKEN_REGEX, "");
@@ -230,7 +558,7 @@ var extractSyncVersion = (filePath) => {
   const { syncMarker } = getRoutingRules();
   const match = new RegExp(String.raw`${escapeRegExp(syncMarker)}\/(.+)\.ts$`).exec(normalized);
   if (!match) {
-    const basename = path2.basename(filePath, ".ts");
+    const basename = path3.basename(filePath, ".ts");
     const versionMatch2 = SYNC_VERSION_TOKEN_REGEX.exec(basename);
     return versionMatch2 ? `v${versionMatch2[2] ?? "1"}` : "v1";
   }
@@ -240,7 +568,7 @@ var extractSyncVersion = (filePath) => {
 
 // src/typeMap/apiMeta.ts
 import * as ts from "typescript";
-import fs2 from "fs";
+import fs3 from "fs";
 import { inferHttpMethod, tryCatchSync } from "@luckystack/core";
 var findExportedConst = (sourceFile, name) => {
   for (const statement of sourceFile.statements) {
@@ -262,7 +590,7 @@ var unwrapExpression = (node) => {
 };
 var extractHttpMethod = (filePath, apiName) => {
   const [error, method] = tryCatchSync(() => {
-    const content = fs2.readFileSync(filePath, "utf8");
+    const content = fs3.readFileSync(filePath, "utf8");
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
     const decl = findExportedConst(sourceFile, "httpMethod");
     const initializer = decl?.initializer ? unwrapExpression(decl.initializer) : void 0;
@@ -279,7 +607,7 @@ var extractHttpMethod = (filePath, apiName) => {
 };
 var extractRateLimit = (filePath) => {
   const [error, rateLimit] = tryCatchSync(() => {
-    const content = fs2.readFileSync(filePath, "utf8");
+    const content = fs3.readFileSync(filePath, "utf8");
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
     const decl = findExportedConst(sourceFile, "rateLimit");
     if (decl?.initializer) {
@@ -325,7 +653,7 @@ var commentToString = (commentValue) => {
 };
 var extractDocsMeta = (filePath) => {
   const [error, docsMeta] = tryCatchSync(() => {
-    const content = fs2.readFileSync(filePath, "utf8");
+    const content = fs3.readFileSync(filePath, "utf8");
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
     const result = {};
     const consumeTag = (tag) => {
@@ -362,7 +690,7 @@ var extractDocsMeta = (filePath) => {
 };
 var extractAuth = (filePath) => {
   const [, auth] = tryCatchSync(() => {
-    const content = fs2.readFileSync(filePath, "utf8");
+    const content = fs3.readFileSync(filePath, "utf8");
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
     const decl = findExportedConst(sourceFile, "auth");
     const authInitializer = decl?.initializer ? unwrapExpression(decl.initializer) : void 0;
@@ -392,27 +720,11 @@ var extractAuth = (filePath) => {
 };
 
 // src/typeMap/emitterArtifacts.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import * as ts3 from "typescript";
 import { getGeneratedApiDocsPath, getGeneratedApiSchemasPath, getGeneratedSocketTypesPath } from "@luckystack/core";
 
-// src/internal/mapUtils.ts
-var getOrInit = (map, key, factory) => {
-  const existing = map.get(key);
-  if (existing !== void 0) return existing;
-  const fresh = factory();
-  map.set(key, fresh);
-  return fresh;
-};
-var mustGet = (map, key, label) => {
-  const value = map.get(key);
-  if (value === void 0) {
-    throw new Error(`[devkit] invariant violation: '${String(key)}' missing from ${label}`);
-  }
-  return value;
-};
-
 // src/typeMap/zodEmitter.ts
 import * as ts2 from "typescript";
 var wrapOptional = (inner) => `${inner}.optional()`;
@@ -575,13 +887,13 @@ var splitVersionedKey = (value) => {
   return { name: name ?? "", version: version ?? "v1" };
 };
 var writeFileIfChanged = (filePath, content) => {
-  if (fs3.existsSync(filePath)) {
-    const currentContent = fs3.readFileSync(filePath, "utf8");
+  if (fs4.existsSync(filePath)) {
+    const currentContent = fs4.readFileSync(filePath, "utf8");
     if (currentContent === content) {
       return false;
     }
   }
-  fs3.writeFileSync(filePath, content, "utf8");
+  fs4.writeFileSync(filePath, content, "utf8");
   return true;
 };
 var indentStr = (str, indentText) => {
@@ -1139,9 +1451,9 @@ var writeTypeMapArtifacts = ({
       }
     }
     const docsPath = getGeneratedApiDocsPath();
-    const docsDir = path3.dirname(docsPath);
-    if (!fs3.existsSync(docsDir)) {
-      fs3.mkdirSync(docsDir, { recursive: true });
+    const docsDir = path4.dirname(docsPath);
+    if (!fs4.existsSync(docsDir)) {
+      fs4.mkdirSync(docsDir, { recursive: true });
     }
     const docsContent = JSON.stringify(docsData, null, 2);
     const hasUpdatedDocs = writeFileIfChanged(docsPath, docsContent);
@@ -1149,7 +1461,7 @@ var writeTypeMapArtifacts = ({
       console.log("[TypeMapGenerator] Generated apiDocs.generated.json");
     }
     if (diagnosticsData !== void 0) {
-      const diagnosticsPath = path3.join(path3.dirname(docsPath), "apiTypeDiagnostics.generated.json");
+      const diagnosticsPath = path4.join(path4.dirname(docsPath), "apiTypeDiagnostics.generated.json");
       const diagnosticsContent = JSON.stringify(diagnosticsData, null, 2);
       const hasUpdatedDiagnostics = writeFileIfChanged(diagnosticsPath, diagnosticsContent);
       if (hasUpdatedDiagnostics) {
@@ -1166,22 +1478,22 @@ var writeTypeMapArtifacts = ({
 
 // src/typeMap/extractors.ts
 import * as ts5 from "typescript";
-import path5 from "path";
+import path6 from "path";
 
 // src/typeMap/tsProgram.ts
 import * as ts4 from "typescript";
-import path4 from "path";
-import { ROOT_DIR as ROOT_DIR2, getGeneratedSocketTypesPath as getGeneratedSocketTypesPath2 } from "@luckystack/core";
+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_DIR2, ts4.sys.fileExists.bind(ts4.sys), "tsconfig.server.json");
+  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,
-    path4.dirname(tsconfigPath)
+    path5.dirname(tsconfigPath)
   );
   cachedProgram = ts4.createProgram(fileNames, options);
   return cachedProgram;
@@ -1290,10 +1602,10 @@ var getLiteralTypeFromPropertySymbol = (symbol, checker, depth) => {
   return null;
 };
 var normalizeImportPath = (targetFilePath) => {
-  const fromDir = path4.dirname(getGeneratedSocketTypesPath2());
+  const fromDir = path5.dirname(getGeneratedSocketTypesPath2());
   const from = fromDir.replaceAll("\\", "/");
   const to = targetFilePath.replaceAll("\\", "/");
-  const normalized = path4.posix.relative(from, to).replaceAll("\\", "/");
+  const normalized = path5.posix.relative(from, to).replaceAll("\\", "/");
   const withoutExtension = normalized.replace(/(\.d)?\.(ts|tsx|js|jsx)$/i, "");
   if (withoutExtension.startsWith(".")) return withoutExtension;
   return `./${withoutExtension}`;
@@ -1586,10 +1898,10 @@ var KNOWN_GLOBAL_TYPE_NAMES = /* @__PURE__ */ new Set([
   "JsonPrimitive"
 ]);
 var normalizeImportPath2 = (targetFilePath) => {
-  const fromDir = path5.dirname(getGeneratedSocketTypesPath3());
+  const fromDir = path6.dirname(getGeneratedSocketTypesPath3());
   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}`;
@@ -1943,18 +2255,18 @@ var getSyncClientOutputTypeDetailsFromFile = (filePath) => {
 
 // src/typeMap/functionsMeta.ts
 import * as ts7 from "typescript";
-import fs5 from "fs";
-import path8 from "path";
+import fs6 from "fs";
+import path9 from "path";
 
 // src/typeMap/typeContext.ts
 import * as ts6 from "typescript";
-import path6 from "path";
+import path7 from "path";
 import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath4 } from "@luckystack/core";
 var toGeneratedImportPath = (source, filePath) => {
   if (!source.startsWith(".")) return source;
-  const outputDir = path6.dirname(getGeneratedSocketTypesPath4());
-  const absoluteSource = path6.resolve(path6.dirname(filePath), source);
-  let relPath = path6.relative(outputDir, absoluteSource).replaceAll("\\", "/");
+  const outputDir = path7.dirname(getGeneratedSocketTypesPath4());
+  const absoluteSource = path7.resolve(path7.dirname(filePath), source);
+  let relPath = path7.relative(outputDir, absoluteSource).replaceAll("\\", "/");
   relPath = relPath.replace(/\.tsx?$/, "");
   if (!relPath.startsWith(".")) relPath = `./${relPath}`;
   return relPath;
@@ -2038,14 +2350,14 @@ var sanitizeTypeAndCollectImports = ({
 };
 
 // src/typeMap/functionsMeta.ts
-import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath5, ROOT_DIR as ROOT_DIR4 } from "@luckystack/core";
+import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath5, ROOT_DIR as ROOT_DIR5 } from "@luckystack/core";
 
 // src/functionRegistry.ts
-import fs4 from "fs";
-import path7 from "path";
-import { ROOT_DIR as ROOT_DIR3, getServerFunctionDirs, isTestFile, isTestDirectory } from "@luckystack/core";
-var normalizePath = (value) => value.replaceAll("\\", "/");
-var toWorkspaceRelative = (absolutePath) => normalizePath(path7.relative(ROOT_DIR3, absolutePath));
+import fs5 from "fs";
+import path8 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 formatFunctionKeyPath = (keyPath) => keyPath.join(".");
 var functionModuleFileName = (keyPath) => {
   const fileName = keyPath.at(-1);
@@ -2057,18 +2369,18 @@ 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 = fs4.readdirSync(dir).toSorted();
+  const entries = fs5.readdirSync(dir).toSorted();
   for (const entry of entries) {
     if (entry === "node_modules") continue;
-    const fullPath = path7.join(dir, entry);
+    const fullPath = path8.join(dir, entry);
     if (getRoutingRules().ignore(toWorkspaceRelative(fullPath))) continue;
-    if (fs4.statSync(fullPath).isDirectory()) {
-      if (isTestDirectory(entry)) continue;
+    if (fs5.statSync(fullPath).isDirectory()) {
+      if (isTestDirectory2(entry)) continue;
       walkFunctionRoot(fullPath, rootDir, [...basePath, entry], collected);
       continue;
     }
     if (!entry.endsWith(".ts")) continue;
-    if (isTestFile(entry)) continue;
+    if (isTestFile2(entry)) continue;
     collected.push({
       keyPath: [...basePath, entry.slice(0, -".ts".length)],
       sourcePath: toWorkspaceRelative(fullPath),
@@ -2105,7 +2417,7 @@ var collectFunctionModules = (options = {}) => {
     onConflict(message);
   };
   for (const root of functionRoots) {
-    if (!fs4.existsSync(root)) continue;
+    if (!fs5.existsSync(root)) continue;
     const fromThisRoot = [];
     walkFunctionRoot(root, root, [], fromThisRoot);
     for (const module of fromThisRoot) {
@@ -2202,9 +2514,9 @@ var simplifyInferredType = (value) => {
   if (/\bRedis\b/.test(value)) return "Redis";
   return value;
 };
-var getGeneratedFileDir = () => path8.dirname(getGeneratedSocketTypesPath5());
+var getGeneratedFileDir = () => path9.dirname(getGeneratedSocketTypesPath5());
 var sourceModuleSpecifier = (sourceFilePath) => {
-  const relative = path8.relative(getGeneratedFileDir(), sourceFilePath).replaceAll("\\", "/").replace(/\.tsx?$/i, "");
+  const relative = path9.relative(getGeneratedFileDir(), sourceFilePath).replaceAll("\\", "/").replace(/\.tsx?$/i, "");
   return relative.startsWith(".") ? relative : `./${relative}`;
 };
 var portableInferredValueType = (inferred, sourceFilePath, exportName) => {
@@ -2215,9 +2527,9 @@ var relativizeModuleSpecifier = (specifier, sourceFilePath) => {
   if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
     return specifier;
   }
-  const absolute = path8.resolve(path8.dirname(sourceFilePath), specifier);
-  const rel = path8.relative(getGeneratedFileDir(), absolute);
-  const normalized = rel.split(path8.sep).join("/");
+  const absolute = path9.resolve(path9.dirname(sourceFilePath), specifier);
+  const rel = path9.relative(getGeneratedFileDir(), absolute);
+  const normalized = rel.split(path9.sep).join("/");
   return normalized.startsWith(".") ? normalized : `./${normalized}`;
 };
 var findProgramVariableDeclaration = (sourceFile, exportName) => {
@@ -2391,7 +2703,7 @@ var findSignatureForExport = (name, sourceFile, rawContent, filePath, availableE
 };
 var parseFunctionFile = (fullPath, collectors) => {
   try {
-    const rawContent = fs5.readFileSync(fullPath, "utf8");
+    const rawContent = fs6.readFileSync(fullPath, "utf8");
     const sourceFile = ts7.createSourceFile(fullPath, rawContent, ts7.ScriptTarget.Latest, true);
     const { availableExports, fileImports } = parseFileTypeContext(rawContent);
     const program = getServerProgram();
@@ -2461,406 +2773,95 @@ var parseFunctionFile = (fullPath, collectors) => {
         }
       }
       if (ts7.isExportAssignment(statement) && !statement.isExportEquals && ts7.isIdentifier(statement.expression)) {
-        defaultExportName = statement.expression.text;
-      }
-      if (ts7.isExportDeclaration(statement) && !statement.exportClause && statement.moduleSpecifier && ts7.isStringLiteral(statement.moduleSpecifier)) {
-        wildcardReExport = relativizeModuleSpecifier(statement.moduleSpecifier.text, fullPath);
-      }
-    }
-    return { kind: "file", exports, defaultExportName, wildcardReExport, sourcePath: fullPath };
-  } catch (error) {
-    console.error(`[TypeMapGenerator] Error parsing functions file ${fullPath}:`, error);
-    return null;
-  }
-};
-var insertFileNode = (root, keyPath, file) => {
-  let target = root;
-  for (const segment of keyPath.slice(0, -1)) {
-    const existing = target.children.get(segment);
-    if (existing?.kind === "dir") {
-      target = existing;
-      continue;
-    }
-    const created = { kind: "dir", children: /* @__PURE__ */ new Map(), sourcePath: segment };
-    target.children.set(segment, created);
-    target = created;
-  }
-  target.children.set(functionModuleFileName(keyPath), file);
-};
-var serializeIRDir = (dir, indent) => {
-  let output = "";
-  for (const [name, child] of dir.children) {
-    if (child.kind === "dir") {
-      const subOutput = serializeIRDir(child, `${indent}  `);
-      if (subOutput.trim()) {
-        output += `${indent}${name}: {
-${subOutput}${indent}};
-`;
-      }
-      continue;
-    }
-    const exportsCopy = new Map(child.exports);
-    const defaultExportName = child.defaultExportName;
-    const defaultSig = defaultExportName ? exportsCopy.get(defaultExportName) : void 0;
-    if (defaultSig && defaultExportName) exportsCopy.delete(defaultExportName);
-    if (child.wildcardReExport && exportsCopy.size === 0 && !defaultSig) {
-      output += `${indent}${name}: typeof import('${child.wildcardReExport}');
-`;
-      continue;
-    }
-    if (!defaultSig && exportsCopy.size === 1 && exportsCopy.has("default")) {
-      const reExportSig = exportsCopy.get("default");
-      if (reExportSig) {
-        exportsCopy.delete("default");
-        exportsCopy.set(name, reExportSig);
-      }
-    }
-    let fileOutput = "";
-    for (const [exportName, sig] of exportsCopy) {
-      fileOutput += `${indent}  ${exportName}: ${sig};
-`;
-    }
-    if (defaultSig && !fileOutput.trim()) {
-      fileOutput += `${indent}  ${name}: ${defaultSig};
-`;
-    }
-    if (fileOutput) {
-      output += `${indent}${name}: {
-${fileOutput}${indent}};
-`;
-    }
-  }
-  return output;
-};
-var generateServerFunctions = (collectors) => {
-  const modules = collectFunctionModules();
-  if (modules.length === 0) return "";
-  const merged = { kind: "dir", children: /* @__PURE__ */ new Map(), sourcePath: "<merged>" };
-  for (const module of modules) {
-    const absolutePath = path8.resolve(ROOT_DIR4, module.sourcePath);
-    const parsed = parseFunctionFile(absolutePath, collectors);
-    if (!parsed) continue;
-    if (parsed.exports.size === 0 && parsed.defaultExportName === null && parsed.wildcardReExport === null) {
-      continue;
-    }
-    insertFileNode(merged, module.keyPath, parsed);
-  }
-  return serializeIRDir(merged, "	");
-};
-
-// src/typeMapGenerator.ts
-import { getSrcDir as getSrcDir2 } from "@luckystack/core";
-
-// src/routeNamingValidation.ts
-import fs6 from "fs";
-import path9 from "path";
-import { ROOT_DIR as ROOT_DIR5 } from "@luckystack/core";
-var normalizePath2 = (value) => {
-  return value.replaceAll("\\", "/");
-};
-var toRel = (absolute) => path9.relative(ROOT_DIR5, absolute).replaceAll("\\", "/");
-var isInsidePrivateRouteSubfolder = (fullPath) => {
-  const { privateFolderPrefix, apiMarker, syncMarker } = getRoutingRules();
-  const segments = normalizePath2(fullPath).split("/");
-  const markerIndex = segments.findIndex((segment) => segment === apiMarker || segment === syncMarker);
-  if (markerIndex === -1) return false;
-  return segments.slice(markerIndex + 1).some((segment) => segment.startsWith(privateFolderPrefix));
-};
-var walkRouteFiles = (dir, results = []) => {
-  const entries = fs6.readdirSync(dir, { withFileTypes: true });
-  const apiSeg = apiMarkerSegment();
-  const syncSeg = syncMarkerSegment();
-  const { ignore } = getRoutingRules();
-  for (const entry of entries) {
-    const fullPath = path9.join(dir, entry.name);
-    const normalizedFullPath = normalizePath2(fullPath);
-    if (ignore(toRel(fullPath))) continue;
-    if (isInsidePrivateRouteSubfolder(fullPath)) continue;
-    if (entry.isDirectory()) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules") {
-        continue;
-      }
-      walkRouteFiles(fullPath, results);
-      continue;
-    }
-    if (!entry.isFile() || !entry.name.endsWith(".ts")) {
-      continue;
-    }
-    if (isRouteTestFile(entry.name)) {
-      continue;
-    }
-    if (normalizedFullPath.includes(apiSeg) || normalizedFullPath.includes(syncSeg)) {
-      results.push(fullPath);
-    }
-  }
-  return results;
-};
-var getFileRouteToken = ({
-  normalizedFilePath,
-  marker
-}) => {
-  const markerIndex = normalizedFilePath.indexOf(marker);
-  if (markerIndex === -1) {
-    return "";
-  }
-  const tokenStart = markerIndex + marker.length;
-  return normalizedFilePath.slice(tokenStart, normalizedFilePath.length - ".ts".length);
-};
-var validateRouteFilePath = (filePath) => {
-  const issues = [];
-  const normalizedFilePath = normalizePath2(path9.resolve(filePath));
-  const fileName = path9.basename(filePath);
-  const apiSeg = apiMarkerSegment();
-  const syncSeg = syncMarkerSegment();
-  if (normalizedFilePath.includes(apiSeg)) {
-    const apiRouteToken = getFileRouteToken({ normalizedFilePath, marker: apiSeg });
-    if (apiRouteToken.includes("/")) {
-      issues.push({
-        kind: "api",
-        filePath: normalizedFilePath,
-        reason: 'API route token cannot contain nested path segments ("/").',
-        expected: ROUTE_NAMING_RULES.api
-      });
-    }
-    if (!isVersionedApiFileName(fileName)) {
-      issues.push({
-        kind: "api",
-        filePath: normalizedFilePath,
-        reason: "API filename does not match versioned naming.",
-        expected: ROUTE_NAMING_RULES.api
-      });
-    }
-  }
-  if (normalizedFilePath.includes(syncSeg)) {
-    const syncRouteToken = getFileRouteToken({ normalizedFilePath, marker: syncSeg });
-    if (syncRouteToken.includes("/")) {
-      issues.push({
-        kind: "sync",
-        filePath: normalizedFilePath,
-        reason: 'Sync route token cannot contain nested path segments ("/").',
-        expected: `${ROUTE_NAMING_RULES.syncServer} or ${ROUTE_NAMING_RULES.syncClient}`
-      });
-    }
-    if (!isVersionedSyncFileName(fileName)) {
-      issues.push({
-        kind: "sync",
-        filePath: normalizedFilePath,
-        reason: "Sync filename does not match versioned naming.",
-        expected: `${ROUTE_NAMING_RULES.syncServer} or ${ROUTE_NAMING_RULES.syncClient}`
-      });
+        defaultExportName = statement.expression.text;
+      }
+      if (ts7.isExportDeclaration(statement) && !statement.exportClause && statement.moduleSpecifier && ts7.isStringLiteral(statement.moduleSpecifier)) {
+        wildcardReExport = relativizeModuleSpecifier(statement.moduleSpecifier.text, fullPath);
+      }
     }
-  }
-  return issues;
-};
-var resolveApiRouteKey = ({
-  srcDir,
-  filePath
-}) => {
-  const rules2 = getRoutingRules();
-  const relativePath = normalizePath2(path9.relative(srcDir, filePath));
-  const segments = relativePath.split("/");
-  const apiIndex = segments.indexOf(rules2.apiMarker);
-  if (apiIndex === -1 || apiIndex === segments.length - 1) {
-    return null;
-  }
-  const pageLocation = segments.slice(0, apiIndex).join("/");
-  const apiFilePath = segments.slice(apiIndex + 1).join("/");
-  const rawApiName = apiFilePath.replace(/\.ts$/, "");
-  const versionMatch = rawApiName.match(rules2.apiVersionRegex);
-  if (!versionMatch) {
-    return null;
-  }
-  const version = `v${versionMatch[1]}`;
-  const apiName = rawApiName.replace(rules2.apiVersionRegex, "");
-  const mappedPageLocation = pageLocation || "system";
-  return `api/${mappedPageLocation}/${apiName}/${version}`;
-};
-var resolveSyncRouteKey = ({
-  srcDir,
-  filePath
-}) => {
-  const rules2 = getRoutingRules();
-  const relativePath = normalizePath2(path9.relative(srcDir, filePath));
-  const segments = relativePath.split("/");
-  const syncIndex = segments.indexOf(rules2.syncMarker);
-  if (syncIndex === -1 || syncIndex === segments.length - 1) {
-    return null;
-  }
-  const pageLocation = segments.slice(0, syncIndex).join("/");
-  const syncFilePath = segments.slice(syncIndex + 1).join("/");
-  const rawSyncName = syncFilePath.replace(/\.ts$/, "");
-  const syncMatch = rawSyncName.match(rules2.syncVersionRegex);
-  if (!syncMatch) {
+    return { kind: "file", exports, defaultExportName, wildcardReExport, sourcePath: fullPath };
+  } catch (error) {
+    console.error(`[TypeMapGenerator] Error parsing functions file ${fullPath}:`, error);
     return null;
   }
-  const kind = syncMatch[1];
-  const version = `v${syncMatch[2]}`;
-  const syncName = rawSyncName.replace(rules2.syncVersionRegex, "");
-  const routeBaseKey = pageLocation ? `sync/${pageLocation}/${syncName}/${version}` : `sync/${syncName}/${version}`;
-  return `${routeBaseKey}_${kind}`;
 };
-var collectInvalidRouteNamingIssues = (srcDir) => {
-  const allRouteFiles = walkRouteFiles(srcDir);
-  const issues = [];
-  for (const filePath of allRouteFiles) {
-    issues.push(...validateRouteFilePath(filePath));
+var insertFileNode = (root, keyPath, file) => {
+  let target = root;
+  for (const segment of keyPath.slice(0, -1)) {
+    const existing = target.children.get(segment);
+    if (existing?.kind === "dir") {
+      target = existing;
+      continue;
+    }
+    const created = { kind: "dir", children: /* @__PURE__ */ new Map(), sourcePath: segment };
+    target.children.set(segment, created);
+    target = created;
   }
-  return issues.toSorted((a, b) => a.filePath.localeCompare(b.filePath));
+  target.children.set(functionModuleFileName(keyPath), file);
 };
-var collectDuplicateNormalizedRouteKeyIssues = (srcDir) => {
-  const allRouteFiles = walkRouteFiles(srcDir);
-  const routeKeyToFilePaths = /* @__PURE__ */ new Map();
-  const routeKeyKinds = /* @__PURE__ */ new Map();
-  const apiSeg = apiMarkerSegment();
-  const syncSeg = syncMarkerSegment();
-  for (const filePath of allRouteFiles) {
-    const normalizedFilePath = normalizePath2(path9.resolve(filePath));
-    if (normalizedFilePath.includes(apiSeg)) {
-      const routeKey = resolveApiRouteKey({ srcDir, filePath });
-      if (!routeKey) {
-        continue;
+var serializeIRDir = (dir, indent) => {
+  let output = "";
+  for (const [name, child] of dir.children) {
+    if (child.kind === "dir") {
+      const subOutput = serializeIRDir(child, `${indent}  `);
+      if (subOutput.trim()) {
+        output += `${indent}${name}: {
+${subOutput}${indent}};
+`;
       }
-      getOrInit(routeKeyToFilePaths, routeKey, () => []).push(normalizedFilePath);
-      routeKeyKinds.set(routeKey, "api");
       continue;
     }
-    if (normalizedFilePath.includes(syncSeg)) {
-      const routeKey = resolveSyncRouteKey({ srcDir, filePath });
-      if (!routeKey) {
-        continue;
+    const exportsCopy = new Map(child.exports);
+    const defaultExportName = child.defaultExportName;
+    const defaultSig = defaultExportName ? exportsCopy.get(defaultExportName) : void 0;
+    if (defaultSig && defaultExportName) exportsCopy.delete(defaultExportName);
+    if (child.wildcardReExport && exportsCopy.size === 0 && !defaultSig) {
+      output += `${indent}${name}: typeof import('${child.wildcardReExport}');
+`;
+      continue;
+    }
+    if (!defaultSig && exportsCopy.size === 1 && exportsCopy.has("default")) {
+      const reExportSig = exportsCopy.get("default");
+      if (reExportSig) {
+        exportsCopy.delete("default");
+        exportsCopy.set(name, reExportSig);
       }
-      getOrInit(routeKeyToFilePaths, routeKey, () => []).push(normalizedFilePath);
-      routeKeyKinds.set(routeKey, "sync");
     }
-  }
-  const issues = [];
-  for (const [routeKey, filePaths] of routeKeyToFilePaths.entries()) {
-    if (filePaths.length < 2) {
-      continue;
+    let fileOutput = "";
+    for (const [exportName, sig] of exportsCopy) {
+      fileOutput += `${indent}  ${exportName}: ${sig};
+`;
     }
-    issues.push({
-      kind: routeKeyKinds.get(routeKey) ?? "api",
-      routeKey,
-      filePaths: filePaths.toSorted((a, b) => a.localeCompare(b))
-    });
-  }
-  return issues.toSorted((a, b) => a.routeKey.localeCompare(b.routeKey));
-};
-var formatRouteNamingIssues = ({
-  issues,
-  context
-}) => {
-  const plural = issues.length === 1 ? "" : "s";
-  const header = `[RouteNaming] Found ${issues.length} invalid API/sync route file${plural} while ${context}.`;
-  const details = issues.map((issue, index) => {
-    return `${index + 1}. [${issue.kind.toUpperCase()}] ${issue.filePath}
-   reason: ${issue.reason}
-   expected: ${issue.expected}`;
-  }).join("\n");
-  return `${header}
-${details}`;
-};
-var formatDuplicateRouteKeyIssues = ({
-  issues,
-  context
-}) => {
-  const plural = issues.length === 1 ? "" : "s";
-  const header = `[RouteNaming] Found ${issues.length} duplicate normalized route key${plural} while ${context}.`;
-  const details = issues.map((issue, index) => {
-    const fileList = issue.filePaths.map((filePath) => `   - ${filePath}`).join("\n");
-    return `${index + 1}. [${issue.kind.toUpperCase()}] ${issue.routeKey}
-   files:
-${fileList}`;
-  }).join("\n");
-  return `${header}
-${details}`;
-};
-var assertValidRouteNaming = ({
-  srcDir,
-  context
-}) => {
-  const issues = collectInvalidRouteNamingIssues(srcDir);
-  if (issues.length === 0) {
-    return;
-  }
-  throw new Error(formatRouteNamingIssues({ issues, context }));
-};
-var assertNoDuplicateNormalizedRouteKeys = ({
-  srcDir,
-  context
-}) => {
-  const issues = collectDuplicateNormalizedRouteKeyIssues(srcDir);
-  if (issues.length === 0) {
-    return;
-  }
-  throw new Error(formatDuplicateRouteKeyIssues({ issues, context }));
-};
-var walkPageFiles = (dir, results = []) => {
-  let entries;
-  try {
-    entries = fs6.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    const fullPath = path9.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      walkPageFiles(fullPath, results);
-      continue;
+    if (defaultSig && !fileOutput.trim()) {
+      fileOutput += `${indent}  ${name}: ${defaultSig};
+`;
     }
-    if (!entry.isFile()) continue;
-    if (entry.name === "page.tsx" || entry.name === "page.jsx") {
-      results.push(fullPath);
+    if (fileOutput) {
+      output += `${indent}${name}: {
+${fileOutput}${indent}};
+`;
     }
   }
-  return results;
+  return output;
 };
-var collectDuplicatePageRoutes = (srcDir) => {
-  const pageFiles = walkPageFiles(srcDir);
-  const routeToFiles = /* @__PURE__ */ new Map();
-  for (const absoluteFilePath of pageFiles) {
-    const relative = normalizePath2(path9.relative(srcDir, absoluteFilePath));
-    const result = validatePagePath(relative);
-    if (!result.valid || !result.route) continue;
-    const list = routeToFiles.get(result.route) ?? [];
-    list.push(normalizePath2(path9.relative(ROOT_DIR5, absoluteFilePath)));
-    routeToFiles.set(result.route, list);
-  }
-  const issues = [];
-  for (const [route, filePaths] of routeToFiles) {
-    if (filePaths.length > 1) {
-      issues.push({ route, filePaths });
+var generateServerFunctions = (collectors) => {
+  const modules = collectFunctionModules();
+  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 parsed = parseFunctionFile(absolutePath, collectors);
+    if (!parsed) continue;
+    if (parsed.exports.size === 0 && parsed.defaultExportName === null && parsed.wildcardReExport === null) {
+      continue;
     }
+    insertFileNode(merged, module.keyPath, parsed);
   }
-  return issues;
-};
-var formatDuplicatePageRouteIssues = ({
-  issues,
-  context
-}) => {
-  const plural = issues.length === 1 ? "" : "s";
-  const header = `[RouteNaming] Found ${issues.length} duplicate page route${plural} while ${context}.`;
-  const details = issues.map((issue, index) => {
-    const fileList = issue.filePaths.map((filePath) => `   - ${filePath}`).join("\n");
-    return `${index + 1}. ${issue.route}
-   files:
-${fileList}
-   fix: rename or move one of the files so only one page.tsx resolves to "${issue.route}". Remember that "_<folder>" segments are stripped from the URL (invisible-parent rule).`;
-  }).join("\n");
-  return `${header}
-${details}`;
-};
-var assertNoDuplicatePageRoutes = ({
-  srcDir,
-  context
-}) => {
-  const issues = collectDuplicatePageRoutes(srcDir);
-  if (issues.length === 0) return;
-  throw new Error(formatDuplicatePageRouteIssues({ issues, context }));
+  return serializeIRDir(merged, "	");
 };
 
 // src/typeMapGenerator.ts
+import { getSrcDir as getSrcDir2 } from "@luckystack/core";
 var collectApiTypes = (apiFiles, collectors) => {
   const { namedImports, unresolvedTypeAliases, quiet } = collectors;
   const typesByPage = /* @__PURE__ */ new Map();
@@ -3085,7 +3086,7 @@ registerDefaultTemplateRules();
 import fs7 from "fs";
 import path10 from "path";
 import { pathToFileURL } from "url";
-import { tryCatch, getSrcDir as getSrcDir3, ROOT_DIR as ROOT_DIR6 } from "@luckystack/core";
+import { tryCatch, getSrcDir as getSrcDir3, ROOT_DIR as ROOT_DIR6, isTestFile as isTestFile3 } from "@luckystack/core";
 
 // src/runtimeTypeResolver.ts
 import * as ts8 from "typescript";
@@ -3481,6 +3482,9 @@ var resolveApiRouteMetaFromPath = (filePath) => {
   if (!normalizedAbsolutePath.startsWith(normalizedSrcDir) || !normalizedAbsolutePath.endsWith(".ts")) {
     return null;
   }
+  if (!isRouteSurfaceFile(normalizedAbsolutePath)) {
+    return null;
+  }
   const rules2 = getRoutingRules();
   const relativePath = normalizePath3(path10.relative(getSrcDir3(), absolutePath));
   const segments = relativePath.split("/");
@@ -3508,6 +3512,9 @@ var resolveSyncRouteMetaFromPath = (filePath) => {
   if (!normalizedAbsolutePath.startsWith(normalizedSrcDir) || !normalizedAbsolutePath.endsWith(".ts")) {
     return null;
   }
+  if (!isRouteSurfaceFile(normalizedAbsolutePath)) {
+    return null;
+  }
   const rules2 = getRoutingRules();
   const relativePath = normalizePath3(path10.relative(getSrcDir3(), absolutePath));
   const segments = relativePath.split("/");
@@ -3560,8 +3567,9 @@ var collectTsFiles = (dir, relativeTo = "") => {
     if (isIgnoredPath(entryPath)) continue;
     const relPath = relativeTo ? `${relativeTo}/${entry}` : entry;
     if (fs7.statSync(entryPath).isDirectory()) {
+      if (isNonRouteDirectory(entry)) continue;
       results.push(...collectTsFiles(entryPath, relPath));
-    } else if (entry.endsWith(".ts") && !isRouteTestFile(entry)) {
+    } else if (entry.endsWith(".ts") && !isTestFile3(entry)) {
       results.push(relPath);
     }
   }
@@ -3600,7 +3608,7 @@ var upsertApiFromFile = async (filePath) => {
   const routeMeta = resolveApiRouteMetaFromPath(filePath);
   if (!routeMeta) {
     const normalized = normalizePath3(path10.resolve(filePath));
-    if (normalized.includes("/_api/") && normalized.endsWith(".ts") && !isRouteTestFile(normalized)) {
+    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.`,
         "red"
@@ -3650,7 +3658,7 @@ var scanApiFolder = async (file, basePath = "") => {
   const fullPath = path10.join(getSrcDir3(), basePath, file);
   if (isIgnoredPath(fullPath)) return;
   if (!fs7.statSync(fullPath).isDirectory()) return;
-  if (!file.toLowerCase().endsWith("api")) {
+  if (file !== getRoutingRules().apiMarker) {
     const subFolders = fs7.readdirSync(fullPath);
     for (const sub of subFolders) {
       await scanApiFolder(sub, path10.join(basePath, file));
@@ -3713,7 +3721,7 @@ var upsertSyncFromFile = async (filePath) => {
   const routeMeta = resolveSyncRouteMetaFromPath(filePath);
   if (!routeMeta) {
     const normalized = normalizePath3(path10.resolve(filePath));
-    if (normalized.includes(`/${getRoutingRules().syncMarker}/`) && normalized.endsWith(".ts") && !isRouteTestFile(normalized)) {
+    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.`,
         "red"
@@ -3768,7 +3776,7 @@ var scanSyncFolder = async (file, basePath = "") => {
   const fullPath = path10.join(getSrcDir3(), basePath, file);
   if (isIgnoredPath(fullPath)) return;
   if (!fs7.statSync(fullPath).isDirectory()) return;
-  if (!file.toLowerCase().endsWith("sync")) {
+  if (file !== getRoutingRules().syncMarker) {
     const subFolders = fs7.readdirSync(fullPath);
     for (const sub of subFolders) {
       await scanSyncFolder(sub, path10.join(basePath, file));