@luckystack/devkit 0.8.4 → 0.8.6

package/dist/index.js

@@ -1943,8 +1943,8 @@ var getSyncClientOutputTypeDetailsFromFile = (filePath) => {
 
 // src/typeMap/functionsMeta.ts
 import * as ts7 from "typescript";
-import fs4 from "fs";
-import path7 from "path";
+import fs5 from "fs";
+import path8 from "path";
 
 // src/typeMap/typeContext.ts
 import * as ts6 from "typescript";
@@ -2038,7 +2038,143 @@ var sanitizeTypeAndCollectImports = ({
 };
 
 // src/typeMap/functionsMeta.ts
-import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath5, getServerFunctionDirs } from "@luckystack/core";
+import { getGeneratedSocketTypesPath as getGeneratedSocketTypesPath5, ROOT_DIR as ROOT_DIR4 } 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));
+var formatFunctionKeyPath = (keyPath) => keyPath.join(".");
+var functionModuleFileName = (keyPath) => {
+  const fileName = keyPath.at(-1);
+  if (fileName === void 0) {
+    throw new Error("[function-injection] Internal error: encountered an empty function key path.");
+  }
+  return fileName;
+};
+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();
+  for (const entry of entries) {
+    if (entry === "node_modules") continue;
+    const fullPath = path7.join(dir, entry);
+    if (getRoutingRules().ignore(toWorkspaceRelative(fullPath))) continue;
+    if (fs4.statSync(fullPath).isDirectory()) {
+      if (isTestDirectory(entry)) continue;
+      walkFunctionRoot(fullPath, rootDir, [...basePath, entry], collected);
+      continue;
+    }
+    if (!entry.endsWith(".ts")) continue;
+    if (isTestFile(entry)) continue;
+    collected.push({
+      keyPath: [...basePath, entry.slice(0, -".ts".length)],
+      sourcePath: toWorkspaceRelative(fullPath),
+      rootPath: toWorkspaceRelative(rootDir)
+    });
+  }
+};
+var resolveNamespaceConflicts = (modules, reportConflict) => {
+  const byDottedKey = /* @__PURE__ */ new Map();
+  for (const module of modules) {
+    byDottedKey.set(formatFunctionKeyPath(module.keyPath), module);
+  }
+  return modules.filter((module) => {
+    for (let depth = 1; depth < module.keyPath.length; depth++) {
+      const ancestor = byDottedKey.get(formatFunctionKeyPath(module.keyPath.slice(0, depth)));
+      if (!ancestor) continue;
+      reportConflict(formatFunctionNamespaceConflict(
+        ancestor.keyPath,
+        ancestor.sourcePath,
+        module.keyPath,
+        module.sourcePath
+      ));
+      return false;
+    }
+    return true;
+  });
+};
+var collectFunctionModules = (options = {}) => {
+  const { roots, onConflict } = options;
+  const functionRoots = roots ?? getServerFunctionDirs();
+  const claimedByDottedKey = /* @__PURE__ */ new Map();
+  const reportConflict = (message) => {
+    if (!onConflict) throw new Error(message);
+    onConflict(message);
+  };
+  for (const root of functionRoots) {
+    if (!fs4.existsSync(root)) continue;
+    const fromThisRoot = [];
+    walkFunctionRoot(root, root, [], fromThisRoot);
+    for (const module of fromThisRoot) {
+      const dottedKey = formatFunctionKeyPath(module.keyPath);
+      const claimed = claimedByDottedKey.get(dottedKey);
+      if (claimed) {
+        reportConflict(formatFunctionKeyConflict(
+          module.keyPath,
+          claimed.sourcePath,
+          module.sourcePath
+        ));
+        continue;
+      }
+      claimedByDottedKey.set(dottedKey, module);
+    }
+  }
+  const modules = [...claimedByDottedKey.values()].toSorted((left, right) => formatFunctionKeyPath(left.keyPath).localeCompare(formatFunctionKeyPath(right.keyPath)));
+  return resolveNamespaceConflicts(modules, reportConflict);
+};
+var createRenderNode = () => ({ children: /* @__PURE__ */ new Map(), module: null });
+var renderModuleEntry = (varName, fileName, indent) => `(() => {
+${indent}  const { default: _default, ...named } = ${varName} as Record<string, unknown>;
+${indent}  const cleaned = Object.fromEntries(Object.entries(named).filter(([key]) => key !== '__esModule'));
+${indent}  if (Object.keys(cleaned).length > 0) return cleaned;
+${indent}  return _default !== undefined ? { ${JSON.stringify(fileName)}: _default } : {};
+${indent}})()`;
+var renderNode = (node, indent) => {
+  let output = "";
+  for (const [name, child] of node.children) {
+    if (child.module) {
+      output += `${indent}${JSON.stringify(name)}: ${renderModuleEntry(child.module.varName, child.module.fileName, indent)},
+`;
+      continue;
+    }
+    output += `${indent}${JSON.stringify(name)}: {
+${renderNode(child, `${indent}  `)}${indent}},
+`;
+  }
+  return output;
+};
+var renderFunctionsMap = ({
+  modules,
+  importPrefix,
+  varPrefix = "fn"
+}) => {
+  const imports = [];
+  const root = createRenderNode();
+  for (const [index, module] of modules.entries()) {
+    const varName = `${varPrefix}${index}`;
+    imports.push(`import * as ${varName} from '${importPrefix}${module.sourcePath.replace(/\.ts$/, "")}';`);
+    let target = root;
+    for (const segment of module.keyPath.slice(0, -1)) {
+      let child = target.children.get(segment);
+      if (!child) {
+        child = createRenderNode();
+        target.children.set(segment, child);
+      }
+      target = child;
+    }
+    const fileName = functionModuleFileName(module.keyPath);
+    const leaf = createRenderNode();
+    leaf.module = { varName, fileName };
+    target.children.set(fileName, leaf);
+  }
+  const source = "export const functions: Record<string, Record<string, unknown>> = {\n" + renderNode(root, "  ") + "};";
+  return { imports, source };
+};
+
+// src/typeMap/functionsMeta.ts
 var stripDefaultValues = (params) => {
   return params.replaceAll(/\s*=(?!>)[^,)]+/g, "");
 };
@@ -2066,9 +2202,9 @@ var simplifyInferredType = (value) => {
   if (/\bRedis\b/.test(value)) return "Redis";
   return value;
 };
-var getGeneratedFileDir = () => path7.dirname(getGeneratedSocketTypesPath5());
+var getGeneratedFileDir = () => path8.dirname(getGeneratedSocketTypesPath5());
 var sourceModuleSpecifier = (sourceFilePath) => {
-  const relative = path7.relative(getGeneratedFileDir(), sourceFilePath).replaceAll("\\", "/").replace(/\.tsx?$/i, "");
+  const relative = path8.relative(getGeneratedFileDir(), sourceFilePath).replaceAll("\\", "/").replace(/\.tsx?$/i, "");
   return relative.startsWith(".") ? relative : `./${relative}`;
 };
 var portableInferredValueType = (inferred, sourceFilePath, exportName) => {
@@ -2079,9 +2215,9 @@ var relativizeModuleSpecifier = (specifier, sourceFilePath) => {
   if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
     return specifier;
   }
-  const absolute = path7.resolve(path7.dirname(sourceFilePath), specifier);
-  const rel = path7.relative(getGeneratedFileDir(), absolute);
-  const normalized = rel.split(path7.sep).join("/");
+  const absolute = path8.resolve(path8.dirname(sourceFilePath), specifier);
+  const rel = path8.relative(getGeneratedFileDir(), absolute);
+  const normalized = rel.split(path8.sep).join("/");
   return normalized.startsWith(".") ? normalized : `./${normalized}`;
 };
 var findProgramVariableDeclaration = (sourceFile, exportName) => {
@@ -2255,7 +2391,7 @@ var findSignatureForExport = (name, sourceFile, rawContent, filePath, availableE
 };
 var parseFunctionFile = (fullPath, collectors) => {
   try {
-    const rawContent = fs4.readFileSync(fullPath, "utf8");
+    const rawContent = fs5.readFileSync(fullPath, "utf8");
     const sourceFile = ts7.createSourceFile(fullPath, rawContent, ts7.ScriptTarget.Latest, true);
     const { availableExports, fileImports } = parseFileTypeContext(rawContent);
     const program = getServerProgram();
@@ -2337,48 +2473,19 @@ var parseFunctionFile = (fullPath, collectors) => {
     return null;
   }
 };
-var walkDirToIR = (dir, collectors) => {
-  if (!fs4.existsSync(dir)) return null;
-  const entries = fs4.readdirSync(dir, { withFileTypes: true });
-  const children = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const fullPath = path7.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      const subDir = walkDirToIR(fullPath, collectors);
-      if (subDir && subDir.children.size > 0) {
-        children.set(entry.name, subDir);
-      }
+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;
     }
-    if (!entry.isFile() || !entry.name.endsWith(".ts")) continue;
-    const fileName = entry.name.replace(".ts", "");
-    const parsed = parseFunctionFile(fullPath, collectors);
-    if (parsed && (parsed.exports.size > 0 || parsed.defaultExportName !== null || parsed.wildcardReExport !== null)) {
-      children.set(fileName, parsed);
-    }
-  }
-  return { kind: "dir", children, sourcePath: dir };
-};
-var formatConflict = (keyPath, a, b) => {
-  const dottedKey = keyPath.join(".");
-  return `[function-injection] Conflict at \`functions.${dottedKey}\`: defined in both \`${a.sourcePath}\` and \`${b.sourcePath}\`. Delete one \u2014 \`shared/\` is the canonical location for framework re-exports.`;
-};
-var mergeIR = (target, source, prefix = []) => {
-  for (const [name, sourceChild] of source.children) {
-    const targetChild = target.children.get(name);
-    if (!targetChild) {
-      target.children.set(name, sourceChild);
-      continue;
-    }
-    const keyPath = [...prefix, name];
-    if (targetChild.kind !== sourceChild.kind) {
-      throw new Error(formatConflict(keyPath, targetChild, sourceChild));
-    }
-    if (targetChild.kind === "file" || sourceChild.kind === "file") {
-      throw new Error(formatConflict(keyPath, targetChild, sourceChild));
-    }
-    mergeIR(targetChild, sourceChild, keyPath);
+    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 = "";
@@ -2426,13 +2533,17 @@ ${fileOutput}${indent}};
   return output;
 };
 var generateServerFunctions = (collectors) => {
-  const dirs = getServerFunctionDirs();
-  if (dirs.length === 0) return "";
+  const modules = collectFunctionModules();
+  if (modules.length === 0) return "";
   const merged = { kind: "dir", children: /* @__PURE__ */ new Map(), sourcePath: "<merged>" };
-  for (const dir of dirs) {
-    const ir = walkDirToIR(dir, collectors);
-    if (!ir) continue;
-    mergeIR(merged, ir);
+  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, "	");
 };
@@ -2441,28 +2552,28 @@ var generateServerFunctions = (collectors) => {
 import { getSrcDir as getSrcDir2 } from "@luckystack/core";
 
 // src/routeNamingValidation.ts
-import fs5 from "fs";
-import path8 from "path";
-import { ROOT_DIR as ROOT_DIR3 } from "@luckystack/core";
-var normalizePath = (value) => {
+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) => path8.relative(ROOT_DIR3, absolute).replaceAll("\\", "/");
+var toRel = (absolute) => path9.relative(ROOT_DIR5, absolute).replaceAll("\\", "/");
 var isInsidePrivateRouteSubfolder = (fullPath) => {
   const { privateFolderPrefix, apiMarker, syncMarker } = getRoutingRules();
-  const segments = normalizePath(fullPath).split("/");
+  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 = fs5.readdirSync(dir, { withFileTypes: true });
+  const entries = fs6.readdirSync(dir, { withFileTypes: true });
   const apiSeg = apiMarkerSegment();
   const syncSeg = syncMarkerSegment();
   const { ignore } = getRoutingRules();
   for (const entry of entries) {
-    const fullPath = path8.join(dir, entry.name);
-    const normalizedFullPath = normalizePath(fullPath);
+    const fullPath = path9.join(dir, entry.name);
+    const normalizedFullPath = normalizePath2(fullPath);
     if (ignore(toRel(fullPath))) continue;
     if (isInsidePrivateRouteSubfolder(fullPath)) continue;
     if (entry.isDirectory()) {
@@ -2497,8 +2608,8 @@ var getFileRouteToken = ({
 };
 var validateRouteFilePath = (filePath) => {
   const issues = [];
-  const normalizedFilePath = normalizePath(path8.resolve(filePath));
-  const fileName = path8.basename(filePath);
+  const normalizedFilePath = normalizePath2(path9.resolve(filePath));
+  const fileName = path9.basename(filePath);
   const apiSeg = apiMarkerSegment();
   const syncSeg = syncMarkerSegment();
   if (normalizedFilePath.includes(apiSeg)) {
@@ -2546,7 +2657,7 @@ var resolveApiRouteKey = ({
   filePath
 }) => {
   const rules2 = getRoutingRules();
-  const relativePath = normalizePath(path8.relative(srcDir, filePath));
+  const relativePath = normalizePath2(path9.relative(srcDir, filePath));
   const segments = relativePath.split("/");
   const apiIndex = segments.indexOf(rules2.apiMarker);
   if (apiIndex === -1 || apiIndex === segments.length - 1) {
@@ -2569,7 +2680,7 @@ var resolveSyncRouteKey = ({
   filePath
 }) => {
   const rules2 = getRoutingRules();
-  const relativePath = normalizePath(path8.relative(srcDir, filePath));
+  const relativePath = normalizePath2(path9.relative(srcDir, filePath));
   const segments = relativePath.split("/");
   const syncIndex = segments.indexOf(rules2.syncMarker);
   if (syncIndex === -1 || syncIndex === segments.length - 1) {
@@ -2603,7 +2714,7 @@ var collectDuplicateNormalizedRouteKeyIssues = (srcDir) => {
   const apiSeg = apiMarkerSegment();
   const syncSeg = syncMarkerSegment();
   for (const filePath of allRouteFiles) {
-    const normalizedFilePath = normalizePath(path8.resolve(filePath));
+    const normalizedFilePath = normalizePath2(path9.resolve(filePath));
     if (normalizedFilePath.includes(apiSeg)) {
       const routeKey = resolveApiRouteKey({ srcDir, filePath });
       if (!routeKey) {
@@ -2687,12 +2798,12 @@ var assertNoDuplicateNormalizedRouteKeys = ({
 var walkPageFiles = (dir, results = []) => {
   let entries;
   try {
-    entries = fs5.readdirSync(dir, { withFileTypes: true });
+    entries = fs6.readdirSync(dir, { withFileTypes: true });
   } catch {
     return results;
   }
   for (const entry of entries) {
-    const fullPath = path8.join(dir, entry.name);
+    const fullPath = path9.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
       walkPageFiles(fullPath, results);
@@ -2709,11 +2820,11 @@ var collectDuplicatePageRoutes = (srcDir) => {
   const pageFiles = walkPageFiles(srcDir);
   const routeToFiles = /* @__PURE__ */ new Map();
   for (const absoluteFilePath of pageFiles) {
-    const relative = normalizePath(path8.relative(srcDir, absoluteFilePath));
+    const relative = normalizePath2(path9.relative(srcDir, absoluteFilePath));
     const result = validatePagePath(relative);
     if (!result.valid || !result.route) continue;
     const list = routeToFiles.get(result.route) ?? [];
-    list.push(normalizePath(path8.relative(ROOT_DIR3, absoluteFilePath)));
+    list.push(normalizePath2(path9.relative(ROOT_DIR5, absoluteFilePath)));
     routeToFiles.set(result.route, list);
   }
   const issues = [];
@@ -2971,10 +3082,10 @@ var registerDefaultTemplateRules = () => {
 registerDefaultTemplateRules();
 
 // src/loader.ts
-import fs6 from "fs";
-import path9 from "path";
+import fs7 from "fs";
+import path10 from "path";
 import { pathToFileURL } from "url";
-import { tryCatch, getServerFunctionDirs as getServerFunctionDirs2, getSrcDir as getSrcDir3, ROOT_DIR as ROOT_DIR4 } from "@luckystack/core";
+import { tryCatch, getSrcDir as getSrcDir3, ROOT_DIR as ROOT_DIR6 } from "@luckystack/core";
 
 // src/runtimeTypeResolver.ts
 import * as ts8 from "typescript";
@@ -3352,9 +3463,9 @@ var resolveRuntimeTypeText = ({
 var devApis = {};
 var devSyncs = {};
 var devFunctions = {};
-var normalizePath2 = (value) => value.replaceAll("\\", "/");
+var normalizePath3 = (value) => value.replaceAll("\\", "/");
 var isIgnoredPath = (absolutePath) => {
-  const relativeFromRoot = normalizePath2(path9.relative(ROOT_DIR4, absolutePath));
+  const relativeFromRoot = normalizePath3(path10.relative(ROOT_DIR6, absolutePath));
   return getRoutingRules().ignore(relativeFromRoot);
 };
 var mapApiPageLocation = (pageLocation) => {
@@ -3364,14 +3475,14 @@ var mapSyncPageLocation = (pageLocation) => {
   return pageLocation || "system";
 };
 var resolveApiRouteMetaFromPath = (filePath) => {
-  const absolutePath = path9.resolve(filePath);
-  const normalizedAbsolutePath = normalizePath2(absolutePath);
-  const normalizedSrcDir = normalizePath2(getSrcDir3());
+  const absolutePath = path10.resolve(filePath);
+  const normalizedAbsolutePath = normalizePath3(absolutePath);
+  const normalizedSrcDir = normalizePath3(getSrcDir3());
   if (!normalizedAbsolutePath.startsWith(normalizedSrcDir) || !normalizedAbsolutePath.endsWith(".ts")) {
     return null;
   }
   const rules2 = getRoutingRules();
-  const relativePath = normalizePath2(path9.relative(getSrcDir3(), absolutePath));
+  const relativePath = normalizePath3(path10.relative(getSrcDir3(), absolutePath));
   const segments = relativePath.split("/");
   const apiIndex = segments.indexOf(rules2.apiMarker);
   if (apiIndex === -1 || apiIndex === segments.length - 1) {
@@ -3391,14 +3502,14 @@ var resolveApiRouteMetaFromPath = (filePath) => {
   return { routeKey, absolutePath };
 };
 var resolveSyncRouteMetaFromPath = (filePath) => {
-  const absolutePath = path9.resolve(filePath);
-  const normalizedAbsolutePath = normalizePath2(absolutePath);
-  const normalizedSrcDir = normalizePath2(getSrcDir3());
+  const absolutePath = path10.resolve(filePath);
+  const normalizedAbsolutePath = normalizePath3(absolutePath);
+  const normalizedSrcDir = normalizePath3(getSrcDir3());
   if (!normalizedAbsolutePath.startsWith(normalizedSrcDir) || !normalizedAbsolutePath.endsWith(".ts")) {
     return null;
   }
   const rules2 = getRoutingRules();
-  const relativePath = normalizePath2(path9.relative(getSrcDir3(), absolutePath));
+  const relativePath = normalizePath3(path10.relative(getSrcDir3(), absolutePath));
   const segments = relativePath.split("/");
   const syncIndex = segments.indexOf(rules2.syncMarker);
   if (syncIndex === -1 || syncIndex === segments.length - 1) {
@@ -3442,13 +3553,13 @@ var importFile = async (absolutePath) => {
 };
 var collectTsFiles = (dir, relativeTo = "") => {
   const results = [];
-  const entries = fs6.readdirSync(dir);
+  const entries = fs7.readdirSync(dir);
   for (const entry of entries) {
     if (entry === "node_modules") continue;
-    const entryPath = path9.join(dir, entry);
+    const entryPath = path10.join(dir, entry);
     if (isIgnoredPath(entryPath)) continue;
     const relPath = relativeTo ? `${relativeTo}/${entry}` : entry;
-    if (fs6.statSync(entryPath).isDirectory()) {
+    if (fs7.statSync(entryPath).isDirectory()) {
       results.push(...collectTsFiles(entryPath, relPath));
     } else if (entry.endsWith(".ts") && !isRouteTestFile(entry)) {
       results.push(relPath);
@@ -3479,16 +3590,16 @@ var resolveFunctionModule = (loadedModule, fileName) => {
 var initializeApis = async () => {
   for (const key of Object.keys(devApis)) delete devApis[key];
   clearRuntimeTypeResolverCache();
-  const srcFolder = fs6.readdirSync(getSrcDir3());
+  const srcFolder = fs7.readdirSync(getSrcDir3());
   for (const file of srcFolder) {
     await scanApiFolder(file);
   }
 };
 var upsertApiFromFile = async (filePath) => {
-  if (isIgnoredPath(path9.resolve(filePath))) return;
+  if (isIgnoredPath(path10.resolve(filePath))) return;
   const routeMeta = resolveApiRouteMetaFromPath(filePath);
   if (!routeMeta) {
-    const normalized = normalizePath2(path9.resolve(filePath));
+    const normalized = normalizePath3(path10.resolve(filePath));
     if (normalized.includes("/_api/") && normalized.endsWith(".ts") && !isRouteTestFile(normalized)) {
       console.log(
         `[loader][api] invalid filename: ${normalized}. Expected <name>_v<number>.ts. File will not be loaded.`,
@@ -3536,13 +3647,13 @@ var removeApiFromFile = (filePath) => {
   delete devApis[routeMeta.routeKey];
 };
 var scanApiFolder = async (file, basePath = "") => {
-  const fullPath = path9.join(getSrcDir3(), basePath, file);
+  const fullPath = path10.join(getSrcDir3(), basePath, file);
   if (isIgnoredPath(fullPath)) return;
-  if (!fs6.statSync(fullPath).isDirectory()) return;
+  if (!fs7.statSync(fullPath).isDirectory()) return;
   if (!file.toLowerCase().endsWith("api")) {
-    const subFolders = fs6.readdirSync(fullPath);
+    const subFolders = fs7.readdirSync(fullPath);
     for (const sub of subFolders) {
-      await scanApiFolder(sub, path9.join(basePath, file));
+      await scanApiFolder(sub, path10.join(basePath, file));
     }
     return;
   }
@@ -3555,7 +3666,7 @@ var scanApiFolder = async (file, basePath = "") => {
     const versionMatch = rawApiName.match(apiRules.apiVersionRegex);
     if (!versionMatch) {
       console.log(
-        `[loader][api] invalid filename: ${path9.join(fullPath, relFile)}. Expected <name>_v<number>.ts. File will not be loaded.`,
+        `[loader][api] invalid filename: ${path10.join(fullPath, relFile)}. Expected <name>_v<number>.ts. File will not be loaded.`,
         "red"
       );
       continue;
@@ -3563,7 +3674,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 = path9.resolve(path9.join(fullPath, relFile));
+    const modulePath = path10.resolve(path10.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");
@@ -3592,16 +3703,16 @@ var scanApiFolder = async (file, basePath = "") => {
 var initializeSyncs = async () => {
   for (const key of Object.keys(devSyncs)) delete devSyncs[key];
   clearRuntimeTypeResolverCache();
-  const srcFolder = fs6.readdirSync(getSrcDir3());
+  const srcFolder = fs7.readdirSync(getSrcDir3());
   for (const file of srcFolder) {
     await scanSyncFolder(file);
   }
 };
 var upsertSyncFromFile = async (filePath) => {
-  if (isIgnoredPath(path9.resolve(filePath))) return;
+  if (isIgnoredPath(path10.resolve(filePath))) return;
   const routeMeta = resolveSyncRouteMetaFromPath(filePath);
   if (!routeMeta) {
-    const normalized = normalizePath2(path9.resolve(filePath));
+    const normalized = normalizePath3(path10.resolve(filePath));
     if (normalized.includes(`/${getRoutingRules().syncMarker}/`) && normalized.endsWith(".ts") && !isRouteTestFile(normalized)) {
       console.log(
         `[loader][sync] invalid filename: ${normalized}. Expected <name>_server_v<number>.ts or <name>_client_v<number>.ts. File will not be loaded.`,
@@ -3654,13 +3765,13 @@ var removeSyncFromFile = (filePath) => {
   delete devSyncs[routeMeta.routeKey];
 };
 var scanSyncFolder = async (file, basePath = "") => {
-  const fullPath = path9.join(getSrcDir3(), basePath, file);
+  const fullPath = path10.join(getSrcDir3(), basePath, file);
   if (isIgnoredPath(fullPath)) return;
-  if (!fs6.statSync(fullPath).isDirectory()) return;
+  if (!fs7.statSync(fullPath).isDirectory()) return;
   if (!file.toLowerCase().endsWith("sync")) {
-    const subFolders = fs6.readdirSync(fullPath);
+    const subFolders = fs7.readdirSync(fullPath);
     for (const sub of subFolders) {
-      await scanSyncFolder(sub, path9.join(basePath, file));
+      await scanSyncFolder(sub, path10.join(basePath, file));
     }
     return;
   }
@@ -3672,7 +3783,7 @@ var scanSyncFolder = async (file, basePath = "") => {
     const syncMatch = rawSyncFileName.match(syncRules.syncVersionRegex);
     if (!syncMatch) {
       console.log(
-        `[loader][sync] invalid filename: ${path9.join(fullPath, relFile)}. Expected <name>_server_v<number>.ts or <name>_client_v<number>.ts. File will not be loaded.`,
+        `[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.`,
         "red"
       );
       continue;
@@ -3682,7 +3793,7 @@ var scanSyncFolder = async (file, basePath = "") => {
     const syncName = rawSyncFileName.replace(syncRules.syncVersionRegex, "");
     const mappedPageLocation = mapSyncPageLocation(pageLocation);
     const routeBaseKey = `sync/${mappedPageLocation}/${syncName}/${version}`;
-    const filePath = path9.resolve(path9.join(fullPath, relFile));
+    const filePath = path10.resolve(path10.join(fullPath, relFile));
     const [fileError, fileResult] = await tryCatch(async () => importFile(filePath));
     if (fileError) {
       console.log(`[loader][sync] failed to import ${filePath}:`, fileError, "red");
@@ -3706,79 +3817,50 @@ var scanSyncFolder = async (file, basePath = "") => {
     }
   }
 };
-var functionClaimMap = /* @__PURE__ */ new Map();
 var initializeFunctions = async () => {
   for (const key of Object.keys(devFunctions)) delete devFunctions[key];
-  functionClaimMap.clear();
-  const dirs = getServerFunctionDirs2();
-  for (const dir of dirs) {
-    if (fs6.existsSync(dir)) {
-      await scanFunctionsFolder(dir, dir);
-    }
-  }
-};
-var scanFunctionsFolder = async (dir, rootDir, basePath = []) => {
-  const entries = fs6.readdirSync(dir);
-  for (const entry of entries) {
-    const fullPath = path9.join(dir, entry);
-    if (isIgnoredPath(fullPath)) continue;
-    const stat = fs6.statSync(fullPath);
-    if (stat.isDirectory()) {
-      await scanFunctionsFolder(fullPath, rootDir, [...basePath, entry]);
-      continue;
-    }
-    if (!entry.endsWith(".ts")) {
-      continue;
+  const modules = collectFunctionModules({
+    onConflict: (message) => {
+      console.log(`[loader][function] ${message} Skipping the second copy.`, "red");
     }
-    const [err, module] = await tryCatch(async () => importFile(fullPath));
+  });
+  for (const functionModule of modules) {
+    const absolutePath = path10.resolve(ROOT_DIR6, functionModule.sourcePath);
+    const [err, module] = await tryCatch(async () => importFile(absolutePath));
     if (err) {
-      console.log(`[loader][function] failed to import ${fullPath}:`, err, "red");
+      console.log(`[loader][function] failed to import ${absolutePath}:`, err, "red");
       continue;
     }
-    const fileName = entry.replace(".ts", "");
+    const fileName = functionModuleFileName(functionModule.keyPath);
     const resolvedFunctionModule = resolveFunctionModule(module, fileName);
     if (!isMergeable(resolvedFunctionModule)) continue;
-    const keyPath = [...basePath, fileName].join(".");
-    const previousRoot = functionClaimMap.get(keyPath);
-    if (previousRoot !== void 0 && previousRoot !== rootDir) {
-      console.log(
-        `[loader][function] Conflict at \`functions.${keyPath}\`: defined in both \`${previousRoot}\` and \`${rootDir}\`. Skipping the second copy; fix the duplicate (delete one \u2014 \`shared/\` is the canonical location for framework re-exports).`,
-        "red"
-      );
-      continue;
-    }
-    functionClaimMap.set(keyPath, rootDir);
     let target = devFunctions;
-    for (const part of basePath) {
+    for (const part of functionModule.keyPath.slice(0, -1)) {
       const existing = target[part];
       if (!existing || typeof existing !== "object") {
         target[part] = {};
       }
       target = target[part];
     }
-    const existingAtFileName = target[fileName];
-    if (existingAtFileName !== void 0 && isMergeable(resolvedFunctionModule) && isMergeable(existingAtFileName)) {
-      Object.assign(resolvedFunctionModule, existingAtFileName);
-    }
     target[fileName] = resolvedFunctionModule;
   }
 };
 
 // src/hotReload.ts
 import { watch } from "chokidar";
-import fs10 from "fs";
-import path13 from "path";
+import fs11 from "fs";
+import path14 from "path";
 
 // src/templateInjector.ts
-import fs7 from "fs";
-import path10 from "path";
+import fs8 from "fs";
+import path11 from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "url";
 import * as ts9 from "typescript";
-import { ROOT_DIR as ROOT_DIR5, getGeneratedSocketTypesPath as getGeneratedSocketTypesPath6, getSrcDir as getSrcDir4 } from "@luckystack/core";
+import { ROOT_DIR as ROOT_DIR7, getGeneratedSocketTypesPath as getGeneratedSocketTypesPath6, getSrcDir as getSrcDir4 } from "@luckystack/core";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path10.dirname(__filename);
-var templatesDir = path10.join(__dirname, "templates");
-var getConsumerTemplatesDir = () => path10.join(ROOT_DIR5, ".luckystack", "templates");
+var __dirname = path11.dirname(__filename);
+var templatesDir = path11.join(__dirname, "templates");
+var getConsumerTemplatesDir = () => path11.join(ROOT_DIR7, ".luckystack", "templates");
 var templateContentFilenames = (kind) => {
   const builtIn = BUILT_IN_TEMPLATE_FILENAMES[kind];
   if (builtIn) return [builtIn];
@@ -3787,10 +3869,10 @@ var templateContentFilenames = (kind) => {
 var resolveTemplateContent = (kind) => {
   const consumerDir = getConsumerTemplatesDir();
   for (const fileName of templateContentFilenames(kind)) {
-    const consumerFile = path10.join(consumerDir, fileName);
-    if (fs7.existsSync(consumerFile)) {
+    const consumerFile = path11.join(consumerDir, fileName);
+    if (fs8.existsSync(consumerFile)) {
       try {
-        return fs7.readFileSync(consumerFile, "utf8");
+        return fs8.readFileSync(consumerFile, "utf8");
       } catch (error) {
         console.error(`[TemplateInjector] Could not read consumer template: ${consumerFile}`, error);
       }
@@ -3800,9 +3882,9 @@ var resolveTemplateContent = (kind) => {
   if (override !== null) return override;
   const builtInName = BUILT_IN_TEMPLATE_FILENAMES[kind];
   if (builtInName) {
-    const bundled = path10.join(templatesDir, builtInName);
+    const bundled = path11.join(templatesDir, builtInName);
     try {
-      return fs7.readFileSync(bundled, "utf8");
+      return fs8.readFileSync(bundled, "utf8");
     } catch (error) {
       console.error(`[TemplateInjector] Could not read bundled template: ${bundled}`, error);
       return null;
@@ -3816,11 +3898,11 @@ var ensureConsumerTemplateConfigLoaded = () => {
   consumerTemplateConfig ??= (async () => {
     const dir = getConsumerTemplatesDir();
     for (const fileName of ["templateRules.ts", "templateRules.mjs", "templateRules.js"]) {
-      const rulesFile = path10.join(dir, fileName);
-      if (!fs7.existsSync(rulesFile)) continue;
-      const resolvedRulesFile = path10.resolve(rulesFile);
-      const resolvedRoot = path10.resolve(ROOT_DIR5);
-      if (!resolvedRulesFile.startsWith(resolvedRoot + path10.sep) && resolvedRulesFile !== resolvedRoot) {
+      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) {
         console.warn(
           `[TemplateInjector] Template rules file resolves outside project root \u2014 skipping: ${rulesFile}`
         );
@@ -3838,7 +3920,7 @@ var ensureConsumerTemplateConfigLoaded = () => {
 };
 var isEmptyFile = (filePath) => {
   try {
-    const content = fs7.readFileSync(filePath, "utf8");
+    const content = fs8.readFileSync(filePath, "utf8");
     return content.trim().length === 0;
   } catch {
     return false;
@@ -3846,7 +3928,7 @@ var isEmptyFile = (filePath) => {
 };
 var isCommentOnlyFile = (filePath) => {
   try {
-    const content = fs7.readFileSync(filePath, "utf8");
+    const content = fs8.readFileSync(filePath, "utf8");
     const withoutBlockComments = content.replaceAll(/\/\*[\s\S]*?\*\//g, "");
     const withoutLineComments = withoutBlockComments.replaceAll(/(^|\s)\/\/.*$/gm, "$1");
     return withoutLineComments.trim().length === 0;
@@ -3880,7 +3962,7 @@ var isVersionedSyncFile = (filePath) => {
   return isVersionedSyncFileName(filePath);
 };
 var getFileName = (filePath) => {
-  return path10.basename(filePath.replaceAll("\\", "/"));
+  return path11.basename(filePath.replaceAll("\\", "/"));
 };
 var stripTsExtension = (fileName) => {
   return fileName.replace(/\.ts$/, "");
@@ -3956,7 +4038,7 @@ var getInvalidVersionMessage = (filePath) => {
 var computeSrcRelativePath = (filePath) => {
   try {
     const srcDir = getSrcDir4();
-    const absolute = path10.resolve(filePath);
+    const absolute = path11.resolve(filePath);
     const normalizedSrc = srcDir.replaceAll("\\", "/");
     const normalizedAbs = absolute.replaceAll("\\", "/");
     if (!normalizedAbs.startsWith(`${normalizedSrc}/`)) return null;
@@ -4004,7 +4086,7 @@ var getPairedSyncFile = (filePath) => {
 var hasPairedFile = (filePath) => {
   const pairedPath = getPairedSyncFile(filePath);
   if (!pairedPath) return false;
-  return fs7.existsSync(pairedPath);
+  return fs8.existsSync(pairedPath);
 };
 var extractSyncPagePath2 = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
@@ -4017,14 +4099,14 @@ var extractSyncName2 = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
   const match = /_sync\/(.+)\.ts$/.exec(normalized);
   if (!match) {
-    const basename = path10.basename(filePath, ".ts");
+    const basename = path11.basename(filePath, ".ts");
     return basename.replace(/_server_v\d+$/, "").replace(/_client_v\d+$/, "");
   }
   return (match[1] ?? "").replace(/_server_v\d+$/, "").replace(/_client_v\d+$/, "");
 };
 var extractClientInputFromFile = (filePath) => {
   try {
-    const content = fs7.readFileSync(filePath, "utf8");
+    const content = fs8.readFileSync(filePath, "utf8");
     const syncParamsMatch = /interface\s+SyncParams\s*\{/.exec(content);
     if (!syncParamsMatch) return null;
     const searchRegion = content.slice(syncParamsMatch.index + syncParamsMatch[0].length);
@@ -4055,7 +4137,7 @@ var extractClientInputFromFile = (filePath) => {
 var extractClientInputFromGeneratedTypes = (pagePath, syncName) => {
   try {
     const generatedTypesPath = getGeneratedSocketTypesPath6();
-    const content = fs7.readFileSync(generatedTypesPath, "utf8");
+    const content = fs8.readFileSync(generatedTypesPath, "utf8");
     const escapeRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
     const escapedPagePath = escapeRegex(pagePath);
     const escapedSyncName = escapeRegex(syncName);
@@ -4101,7 +4183,7 @@ var calculateRelativePath = (filePath) => {
   const srcRelative = computeSrcRelativePath(filePath);
   if (srcRelative !== null) {
     try {
-      const srcDepthFromRoot = path10.relative(ROOT_DIR5, getSrcDir4()).replaceAll("\\", "/").split("/").filter((segment) => segment.length > 0).length;
+      const srcDepthFromRoot = path11.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
@@ -4180,7 +4262,7 @@ var getTemplate = (filePath) => {
 var injectTemplate = async (filePath) => {
   await ensureConsumerTemplateConfigLoaded();
   if (getRouteFilenameValidationMessage(filePath)) {
-    fs7.writeFileSync(filePath, getInvalidVersionMessage(filePath), "utf8");
+    fs8.writeFileSync(filePath, getInvalidVersionMessage(filePath), "utf8");
     console.log(`[TemplateInjector] Invalid route filename, injected guidance: ${filePath}`);
     return true;
   }
@@ -4189,7 +4271,7 @@ var injectTemplate = async (filePath) => {
     return false;
   }
   try {
-    fs7.writeFileSync(filePath, template, "utf8");
+    fs8.writeFileSync(filePath, template, "utf8");
     console.log(`[TemplateInjector] Injected template into: ${filePath}`);
     return true;
   } catch (error) {
@@ -4317,10 +4399,10 @@ var updateClientFileForPairedServer = async (clientFilePath) => {
   try {
     const pagePath = extractSyncPagePath2(clientFilePath);
     const syncName = extractSyncName2(clientFilePath);
-    let content = fs7.readFileSync(clientFilePath, "utf8");
+    let content = fs8.readFileSync(clientFilePath, "utf8");
     content = ensureImportedTypes(content, clientFilePath);
     content = insertTypeAliases(content, pagePath, syncName);
-    const astResult = rewriteClientInputTypeAst(content, path10.basename(clientFilePath));
+    const astResult = rewriteClientInputTypeAst(content, path11.basename(clientFilePath));
     if (astResult === null) {
       console.log(
         `[TemplateInjector] AST clientInput rewrite unavailable for ${clientFilePath} \u2014 using regex fallback`,
@@ -4332,7 +4414,7 @@ var updateClientFileForPairedServer = async (clientFilePath) => {
     }
     content = addServerOutputToParams(content);
     content = addServerOutputToDestructuring(content);
-    fs7.writeFileSync(clientFilePath, content, "utf8");
+    fs8.writeFileSync(clientFilePath, content, "utf8");
     console.log(`[TemplateInjector] Updated client file to use paired types (preserved code): ${clientFilePath}`);
     return true;
   } catch (error) {
@@ -4373,7 +4455,7 @@ var splitAtMainBody = (content) => {
 };
 var updateClientFileForDeletedServer = async (clientFilePath, clientInputTypes) => {
   try {
-    let content = fs7.readFileSync(clientFilePath, "utf8");
+    let content = fs8.readFileSync(clientFilePath, "utf8");
     content = inlineClientInputType(content, clientInputTypes);
     const [header, body] = splitAtMainBody(content);
     const cleanedHeader = removeServerOutputFromDestructuring(removeServerOutputFromParams(header));
@@ -4381,7 +4463,7 @@ var updateClientFileForDeletedServer = async (clientFilePath, clientInputTypes)
     content = removeGeneratedTypeImports(content);
     content = removeTypeAliases(content);
     content = content.replaceAll(/\n{3,}/g, "\n\n");
-    fs7.writeFileSync(clientFilePath, content, "utf8");
+    fs8.writeFileSync(clientFilePath, content, "utf8");
     console.log(`[TemplateInjector] Updated client file for deleted server (preserved code): ${clientFilePath}`);
     return true;
   } catch (error) {
@@ -4407,7 +4489,7 @@ var injectServerTemplateWithClientInput = async (serverFilePath, clientInputType
       /clientInput:\s*\{[^}]*\}/s,
       (_match) => `clientInput: ${clientInputTypes}`
     );
-    fs7.writeFileSync(serverFilePath, content, "utf8");
+    fs8.writeFileSync(serverFilePath, content, "utf8");
     console.log(`[TemplateInjector] Injected server template with clientInput: ${serverFilePath}`);
     return true;
   } catch (error) {
@@ -4417,24 +4499,24 @@ var injectServerTemplateWithClientInput = async (serverFilePath, clientInputType
 };
 
 // src/importDependencyGraph.ts
-import fs8 from "fs";
-import path11 from "path";
-import { ROOT_DIR as ROOT_DIR6, getServerFunctionDirs as getServerFunctionDirs3, getSharedDir, getSrcDir as getSrcDir5 } from "@luckystack/core";
+import fs9 from "fs";
+import path12 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 normalizePath3 = (value) => path11.resolve(value).replaceAll("\\", "/");
+var normalizePath4 = (value) => path12.resolve(value).replaceAll("\\", "/");
 var isSupportedScriptFile = (value) => {
   return SUPPORTED_EXTENSIONS.some((extension) => value.endsWith(extension));
 };
 var existsFile = (value) => {
   try {
-    return fs8.existsSync(value) && fs8.statSync(value).isFile();
+    return fs9.existsSync(value) && fs9.statSync(value).isFile();
   } catch {
     return false;
   }
 };
 var existsDirectory = (value) => {
   try {
-    return fs8.existsSync(value) && fs8.statSync(value).isDirectory();
+    return fs9.existsSync(value) && fs9.statSync(value).isDirectory();
   } catch {
     return false;
   }
@@ -4445,23 +4527,23 @@ var collectScriptFiles = (dir, output, visited = /* @__PURE__ */ new Set()) => {
   }
   let realDir;
   try {
-    realDir = fs8.realpathSync(dir);
+    realDir = fs9.realpathSync(dir);
   } catch {
     return;
   }
   if (visited.has(realDir)) return;
   visited.add(realDir);
-  const entries = fs8.readdirSync(dir, { withFileTypes: true });
+  const entries = fs9.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === "node_modules") continue;
-    const fullPath = path11.join(dir, entry.name);
+    const fullPath = path12.join(dir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       if (existsDirectory(fullPath)) {
         collectScriptFiles(fullPath, output, visited);
       }
       continue;
     }
-    const normalizedPath = normalizePath3(fullPath);
+    const normalizedPath = normalizePath4(fullPath);
     if (isSupportedScriptFile(normalizedPath)) {
       output.add(normalizedPath);
     }
@@ -4473,7 +4555,7 @@ var SCOPED_FILES_TTL_MS = 1e3;
 var extractImportSpecifiers = (filePath) => {
   let mtimeMs = 0;
   try {
-    mtimeMs = fs8.statSync(filePath).mtimeMs;
+    mtimeMs = fs9.statSync(filePath).mtimeMs;
   } catch {
     specifiersCache.delete(filePath);
     return [];
@@ -4483,7 +4565,7 @@ var extractImportSpecifiers = (filePath) => {
     return cached.specifiers;
   }
   try {
-    const source = fs8.readFileSync(filePath, "utf8");
+    const source = fs9.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;
@@ -4503,24 +4585,24 @@ var extractImportSpecifiers = (filePath) => {
   }
 };
 var invalidateGraphForFile = (absolutePath) => {
-  specifiersCache.delete(normalizePath3(absolutePath));
+  specifiersCache.delete(normalizePath4(absolutePath));
   scopedFilesCache = null;
 };
 var tryResolveWithExtensions = (basePath) => {
   if (existsFile(basePath)) {
-    return normalizePath3(basePath);
+    return normalizePath4(basePath);
   }
   for (const extension of SUPPORTED_EXTENSIONS) {
     const withExtension = `${basePath}${extension}`;
     if (existsFile(withExtension)) {
-      return normalizePath3(withExtension);
+      return normalizePath4(withExtension);
     }
   }
   if (existsDirectory(basePath)) {
     for (const extension of SUPPORTED_EXTENSIONS) {
-      const indexFile = path11.join(basePath, `index${extension}`);
+      const indexFile = path12.join(basePath, `index${extension}`);
       if (existsFile(indexFile)) {
-        return normalizePath3(indexFile);
+        return normalizePath4(indexFile);
       }
     }
   }
@@ -4531,18 +4613,18 @@ var resolveImportToFile = (importerPath, specifier) => {
     return null;
   }
   if (specifier === "config") {
-    return tryResolveWithExtensions(path11.join(ROOT_DIR6, "config"));
+    return tryResolveWithExtensions(path12.join(ROOT_DIR8, "config"));
   }
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    const relativeBase = path11.resolve(path11.dirname(importerPath), specifier);
+    const relativeBase = path12.resolve(path12.dirname(importerPath), specifier);
     return tryResolveWithExtensions(relativeBase);
   }
   if (specifier.startsWith("src/") || specifier.startsWith("@/")) {
     const sourcePath = specifier.startsWith("@/") ? specifier.slice(2) : specifier.slice(4);
-    return tryResolveWithExtensions(path11.join(getSrcDir5(), sourcePath));
+    return tryResolveWithExtensions(path12.join(getSrcDir5(), sourcePath));
   }
   if (specifier.startsWith("shared/")) {
-    return tryResolveWithExtensions(path11.join(getSharedDir(), specifier.slice(7)));
+    return tryResolveWithExtensions(path12.join(getSharedDir(), specifier.slice(7)));
   }
   return null;
 };
@@ -4557,10 +4639,10 @@ var collectScopedFiles = () => {
   const files = /* @__PURE__ */ new Set();
   collectScriptFiles(getSrcDir5(), files);
   collectScriptFiles(getSharedDir(), files);
-  for (const dir of getServerFunctionDirs3()) {
+  for (const dir of getServerFunctionDirs2()) {
     collectScriptFiles(dir, files);
   }
-  const configFile = tryResolveWithExtensions(path11.join(ROOT_DIR6, "config"));
+  const configFile = tryResolveWithExtensions(path12.join(ROOT_DIR8, "config"));
   if (configFile) {
     files.add(configFile);
   }
@@ -4569,7 +4651,7 @@ var collectScopedFiles = () => {
 };
 var findDependentRouteFiles = (changedFilePath) => {
   const scopedFiles = collectScopedFiles();
-  const changedAbsolutePath = normalizePath3(changedFilePath);
+  const changedAbsolutePath = normalizePath4(changedFilePath);
   const reverseDependencies = /* @__PURE__ */ new Map();
   for (const filePath of scopedFiles) {
     const specifiers = extractImportSpecifiers(filePath);
@@ -4608,27 +4690,27 @@ var findDependentRouteFiles = (changedFilePath) => {
 };
 
 // src/prismaClientCheck.ts
-import fs9 from "fs";
-import path12 from "path";
+import fs10 from "fs";
+import path13 from "path";
 import { spawn } from "child_process";
-import { ROOT_DIR as ROOT_DIR7, tryCatch as tryCatch2 } from "@luckystack/core";
-var GENERATED_CLIENT_DIR = path12.join(ROOT_DIR7, "node_modules", ".prisma", "client");
-var GENERATED_CLIENT_MARKER = path12.join(GENERATED_CLIENT_DIR, "schema.prisma");
-var DEFAULT_SCHEMA_PATH = path12.join(ROOT_DIR7, "prisma", "schema.prisma");
-var isPrismaClientMissing = () => fs9.existsSync(DEFAULT_SCHEMA_PATH) && !fs9.existsSync(GENERATED_CLIENT_MARKER);
+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 runPrismaGenerate = async () => tryCatch2(
   () => new Promise((resolve, reject) => {
     const localBinName = process.platform === "win32" ? "prisma.cmd" : "prisma";
-    const localBin = path12.join(ROOT_DIR7, "node_modules", ".bin", localBinName);
-    const useLocal = fs9.existsSync(localBin);
+    const localBin = path13.join(ROOT_DIR9, "node_modules", ".bin", localBinName);
+    const useLocal = fs10.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(
       process.env.ComSpec ?? "cmd.exe",
       ["/d", "/s", "/c", `""${cmd}" ${args.join(" ")}"`],
-      { cwd: ROOT_DIR7, stdio: "inherit", windowsVerbatimArguments: true }
+      { cwd: ROOT_DIR9, stdio: "inherit", windowsVerbatimArguments: true }
     ) : spawn(cmd, args, {
-      cwd: ROOT_DIR7,
+      cwd: ROOT_DIR9,
       stdio: "inherit",
       shell: false
     });
@@ -4641,7 +4723,7 @@ var runPrismaGenerate = async () => tryCatch2(
 
 // src/hotReload.ts
 import { tryCatch as tryCatch3, getProjectConfig, getLocaleReloader, isProductionRuntime } from "@luckystack/core";
-var normalizeFsPath = (value) => path13.resolve(value).replaceAll("\\", "/");
+var normalizeFsPath = (value) => path14.resolve(value).replaceAll("\\", "/");
 var isGeneratedPath = (normalizedPath) => {
   return normalizedPath.includes("apiTypes.generated.ts") || normalizedPath.includes("apiDocs.generated.json");
 };
@@ -4849,7 +4931,7 @@ var setupWatchers = () => {
     if (shouldInjectTemplate(filePath, { isNewFile: true })) {
       if (isSyncServerFile(normalizedPath)) {
         const clientPath = getPairedSyncFile(normalizedPath);
-        if (clientPath && fs10.existsSync(clientPath) && !isEmptyFile(clientPath)) {
+        if (clientPath && fs11.existsSync(clientPath) && !isEmptyFile(clientPath)) {
           const clientInputTypes = extractClientInputFromFile(clientPath);
           if (clientInputTypes) {
             await injectServerTemplateWithClientInput(filePath, clientInputTypes);
@@ -5012,7 +5094,7 @@ var setupWatchers = () => {
       scheduleReload("sync", async () => {
         if (isSyncServerFile(normalizedPath)) {
           const clientPath = getPairedSyncFile(normalizedPath);
-          if (clientPath && fs10.existsSync(clientPath)) {
+          if (clientPath && fs11.existsSync(clientPath)) {
             const pagePath = extractSyncPagePath2(normalizedPath);
             const syncName = extractSyncName2(normalizedPath);
             const clientInputTypes = extractClientInputFromGeneratedTypes(pagePath, syncName);
@@ -5075,9 +5157,14 @@ export {
   clearRuntimeTypeResolverCache,
   clearTemplateOverrides,
   clearTemplateRules,
+  collectFunctionModules,
   devApis,
   devFunctions,
   devSyncs,
+  formatFunctionKeyConflict,
+  formatFunctionKeyPath,
+  formatFunctionNamespaceConflict,
+  functionModuleFileName,
   generateTypeMapFile,
   getInputTypeFromFile,
   getRegisteredTemplate,
@@ -5100,6 +5187,7 @@ export {
   registerTemplateRule,
   removeApiFromFile,
   removeSyncFromFile,
+  renderFunctionsMap,
   resolveRuntimeTypeText,
   resolveTemplateKind,
   setupWatchers,