@luckystack/devkit 0.13.0 → 0.15.0

package/dist/index.js

@@ -1,3 +1,6 @@
+import {
+  requestDevServerRestart
+} from "./chunk-FWE6YJ3G.js";
 import {
   validateDeploy
 } from "./chunk-BJN4XIUX.js";
@@ -64,9 +67,6 @@ var isSyncFileName = (fileName) => {
   const stem = fileName.slice(0, -3);
   return getRoutingRules().syncVersionRegex.test(stem);
 };
-var isRouteTestFile = (fileNameOrPath) => {
-  return fileNameOrPath.endsWith(".tests.ts");
-};
 var isNonRouteDirectory = (directoryName) => directoryName.startsWith(getRoutingRules().privateFolderPrefix) || isTestDirectory(directoryName);
 var validatePagePath = (srcRelativePath) => {
   const rules2 = getRoutingRules();
@@ -129,54 +129,56 @@ var isInsidePrivateRouteSubfolder = (fullPath) => {
   return segments.slice(markerIndex + 1).some((segment) => segment.startsWith(privateFolderPrefix));
 };
 var isRouteSurfaceFile = (fullPath) => !isInsidePrivateRouteSubfolder(fullPath) && !isTestFile(fullPath);
-var walkRouteFiles = (dir, results = []) => {
+var toSrcMarkerPath = (srcDir, filePath) => `/${normalizePath(path.relative(srcDir, filePath))}`;
+var walkRouteFiles = (srcDir, dir = srcDir, 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);
+    const srcMarkerPath = toSrcMarkerPath(srcDir, fullPath);
     if (ignore(toRel(fullPath))) continue;
-    if (isInsidePrivateRouteSubfolder(fullPath)) continue;
+    if (isInsidePrivateRouteSubfolder(srcMarkerPath)) continue;
     if (entry.isDirectory()) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      walkRouteFiles(fullPath, results);
+      walkRouteFiles(srcDir, fullPath, results);
       continue;
     }
     if (!entry.isFile() || !entry.name.endsWith(".ts")) {
       continue;
     }
-    if (isRouteTestFile(entry.name)) {
+    if (!isRouteSurfaceFile(srcMarkerPath)) {
       continue;
     }
-    if (normalizedFullPath.includes(apiSeg) || normalizedFullPath.includes(syncSeg)) {
+    if (srcMarkerPath.includes(apiSeg) || srcMarkerPath.includes(syncSeg)) {
       results.push(fullPath);
     }
   }
   return results;
 };
 var getFileRouteToken = ({
-  normalizedFilePath,
+  srcMarkerPath,
   marker
 }) => {
-  const markerIndex = normalizedFilePath.indexOf(marker);
+  const markerIndex = srcMarkerPath.indexOf(marker);
   if (markerIndex === -1) {
     return "";
   }
   const tokenStart = markerIndex + marker.length;
-  return normalizedFilePath.slice(tokenStart, normalizedFilePath.length - ".ts".length);
+  return srcMarkerPath.slice(tokenStart, srcMarkerPath.length - ".ts".length);
 };
-var validateRouteFilePath = (filePath) => {
+var validateRouteFilePath = (srcDir, filePath) => {
   const issues = [];
   const normalizedFilePath = normalizePath(path.resolve(filePath));
+  const srcMarkerPath = toSrcMarkerPath(srcDir, filePath);
   const fileName = path.basename(filePath);
   const apiSeg = apiMarkerSegment();
   const syncSeg = syncMarkerSegment();
-  if (normalizedFilePath.includes(apiSeg)) {
-    const apiRouteToken = getFileRouteToken({ normalizedFilePath, marker: apiSeg });
+  if (srcMarkerPath.includes(apiSeg)) {
+    const apiRouteToken = getFileRouteToken({ srcMarkerPath, marker: apiSeg });
     if (apiRouteToken.includes("/")) {
       issues.push({
         kind: "api",
@@ -194,8 +196,8 @@ var validateRouteFilePath = (filePath) => {
       });
     }
   }
-  if (normalizedFilePath.includes(syncSeg)) {
-    const syncRouteToken = getFileRouteToken({ normalizedFilePath, marker: syncSeg });
+  if (srcMarkerPath.includes(syncSeg)) {
+    const syncRouteToken = getFileRouteToken({ srcMarkerPath, marker: syncSeg });
     if (syncRouteToken.includes("/")) {
       issues.push({
         kind: "sync",
@@ -259,14 +261,14 @@ var resolveSyncRouteKey = ({
   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}`;
+  const routeBaseKey = `sync/${pageLocation || "system"}/${syncName}/${version}`;
   return `${routeBaseKey}_${kind}`;
 };
 var collectInvalidRouteNamingIssues = (srcDir) => {
   const allRouteFiles = walkRouteFiles(srcDir);
   const issues = [];
   for (const filePath of allRouteFiles) {
-    issues.push(...validateRouteFilePath(filePath));
+    issues.push(...validateRouteFilePath(srcDir, filePath));
   }
   return issues.toSorted((a, b) => a.filePath.localeCompare(b.filePath));
 };
@@ -278,7 +280,8 @@ var collectDuplicateNormalizedRouteKeyIssues = (srcDir) => {
   const syncSeg = syncMarkerSegment();
   for (const filePath of allRouteFiles) {
     const normalizedFilePath = normalizePath(path.resolve(filePath));
-    if (normalizedFilePath.includes(apiSeg)) {
+    const srcMarkerPath = toSrcMarkerPath(srcDir, filePath);
+    if (srcMarkerPath.includes(apiSeg)) {
       const routeKey = resolveApiRouteKey({ srcDir, filePath });
       if (!routeKey) {
         continue;
@@ -287,7 +290,7 @@ var collectDuplicateNormalizedRouteKeyIssues = (srcDir) => {
       routeKeyKinds.set(routeKey, "api");
       continue;
     }
-    if (normalizedFilePath.includes(syncSeg)) {
+    if (srcMarkerPath.includes(syncSeg)) {
       const routeKey = resolveSyncRouteKey({ srcDir, filePath });
       if (!routeKey) {
         continue;
@@ -4079,11 +4082,15 @@ import path15 from "path";
 import fs9 from "fs";
 import path12 from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "url";
-import { ScriptKind as ScriptKind3 } from "typescript-7-api/ast";
+import {
+  ScriptKind as ScriptKind3
+} from "typescript-7-api/ast";
 import {
   isIdentifier as isIdentifier8,
   isInterfaceDeclaration as isInterfaceDeclaration6,
   isPropertySignatureDeclaration as isPropertySignatureDeclaration4,
+  isStringLiteral as isStringLiteral7,
+  isTypeAliasDeclaration as isTypeAliasDeclaration6,
   isTypeLiteralNode as isTypeLiteralNode3
 } from "typescript-7-api/ast/is";
 import { ROOT_DIR as ROOT_DIR7, getGeneratedSocketTypesPath as getGeneratedSocketTypesPath6, getSrcDir as getSrcDir4 } from "@luckystack/core";
@@ -4156,23 +4163,22 @@ var isEmptyFile = (filePath) => {
     return false;
   }
 };
-var isCommentOnlyFile = (filePath) => {
+var INJECTED_GUIDANCE_PATTERN = /^\/\/ Invalid (?:API|sync) filename: [^\r\n]*$/;
+var isInjectedGuidanceOnlyFile = (filePath) => {
   try {
     const content = fs9.readFileSync(filePath, "utf8");
-    const withoutBlockComments = content.replaceAll(/\/\*[\s\S]*?\*\//g, "");
-    const withoutLineComments = withoutBlockComments.replaceAll(/(^|\s)\/\/.*$/gm, "$1");
-    return withoutLineComments.trim().length === 0;
+    return INJECTED_GUIDANCE_PATTERN.test(content.trim());
   } catch {
     return false;
   }
 };
 var isInApiFolder = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
-  return normalized.includes(apiMarkerSegment()) && filePath.endsWith(".ts") && !isRouteTestFile(filePath);
+  return normalized.includes(apiMarkerSegment()) && filePath.endsWith(".ts") && isRouteSurfaceFile(normalized);
 };
 var isInSyncFolder = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
-  return normalized.includes(syncMarkerSegment()) && filePath.endsWith(".ts") && !isRouteTestFile(filePath);
+  return normalized.includes(syncMarkerSegment()) && filePath.endsWith(".ts") && isRouteSurfaceFile(normalized);
 };
 var isPageFile = (filePath) => {
   const normalized = filePath.replaceAll("\\", "/");
@@ -4318,22 +4324,10 @@ var hasPairedFile = (filePath) => {
   if (!pairedPath) return false;
   return fs9.existsSync(pairedPath);
 };
-var extractSyncPagePath2 = (filePath) => {
-  const normalized = filePath.replaceAll("\\", "/");
-  const match = /src\/(.+?)\/_sync\//.exec(normalized);
-  if (match?.[1]) return match[1];
-  if (/(?:^|\/)src\/_sync\//.test(normalized)) return "system";
-  return "";
-};
-var extractSyncName2 = (filePath) => {
-  const normalized = filePath.replaceAll("\\", "/");
-  const match = /_sync\/(.+)\.ts$/.exec(normalized);
-  if (!match) {
-    const basename = path12.basename(filePath, ".ts");
-    return basename.replace(/_server_v\d+$/, "").replace(/_client_v\d+$/, "");
-  }
-  return (match[1] ?? "").replace(/_server_v\d+$/, "").replace(/_client_v\d+$/, "");
-};
+var toSrcRelativeOrSelf = (filePath) => computeSrcRelativePath(filePath) ?? filePath.replaceAll("\\", "/");
+var extractSyncPagePath2 = (filePath) => extractSyncPagePath(path12.resolve(filePath).replaceAll("\\", "/"));
+var extractSyncName2 = (filePath) => extractSyncName(toSrcRelativeOrSelf(filePath));
+var extractSyncVersion2 = (filePath) => extractSyncVersion(toSrcRelativeOrSelf(filePath));
 var extractClientInputFromFile = (filePath) => {
   try {
     const content = fs9.readFileSync(filePath, "utf8");
@@ -4364,43 +4358,32 @@ var extractClientInputFromFile = (filePath) => {
     return null;
   }
 };
-var extractClientInputFromGeneratedTypes = (pagePath, syncName) => {
+var propertyKeyText = (name) => isIdentifier8(name) || isStringLiteral7(name) ? name.text : null;
+var findTypeLiteralMemberType = (typeNode, key) => {
+  if (!typeNode || !isTypeLiteralNode3(typeNode)) return void 0;
+  for (const member of typeNode.members) {
+    if (isPropertySignatureDeclaration4(member) && propertyKeyText(member.name) === key) {
+      return member.type;
+    }
+  }
+  return void 0;
+};
+var extractClientInputFromGeneratedTypes = (pagePath, syncName, version) => {
   try {
     const generatedTypesPath = getGeneratedSocketTypesPath6();
     const content = fs9.readFileSync(generatedTypesPath, "utf8");
-    const escapeRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-    const escapedPagePath = escapeRegex(pagePath);
-    const escapedSyncName = escapeRegex(syncName);
-    const pageBlockRegex = new RegExp(String.raw`'${escapedPagePath}'\s*:\s*\{([\s\S]*?)\n\s{2}\};`, "m");
-    const pageBlockMatch = content.match(pageBlockRegex);
-    if (!pageBlockMatch?.[1]) {
-      console.log(`[TemplateInjector] Could not find page block for ${pagePath}`);
-      return null;
-    }
-    const pageBlock = pageBlockMatch[1];
-    const syncEntryPattern = new RegExp(String.raw`'${escapedSyncName}':\s*\{\s*clientInput:\s*`);
-    const match = pageBlock.match(syncEntryPattern);
-    if (!match || typeof match.index !== "number") {
-      console.log(`[TemplateInjector] Could not find sync entry for ${pagePath}/${syncName}`);
+    const sourceFile = parseSourceText(path12.basename(generatedTypesPath), content, ScriptKind3.TS);
+    const syncTypeMap = sourceFile.statements.find(
+      (statement) => isTypeAliasDeclaration6(statement) && statement.name.text === "_ProjectSyncTypeMap"
+    );
+    const pageType = findTypeLiteralMemberType(syncTypeMap?.type, pagePath);
+    const versionType = findTypeLiteralMemberType(findTypeLiteralMemberType(pageType, syncName), version);
+    const clientInputType = findTypeLiteralMemberType(versionType, "clientInput");
+    if (!clientInputType) {
+      console.log(`[TemplateInjector] Could not find sync entry for ${pagePath}/${syncName}/${version}`);
       return null;
     }
-    const pageStart = content.indexOf(pageBlock);
-    const globalMatchIndex = pageStart + match.index;
-    const searchStart = globalMatchIndex + match[0].length;
-    const braceStart = content.indexOf("{", searchStart - 1);
-    if (braceStart === -1) return null;
-    let depth = 0;
-    let endIndex = -1;
-    for (let i = braceStart; i < content.length; i++) {
-      if (content[i] === "{") depth++;
-      else if (content[i] === "}") depth--;
-      if (depth === 0) {
-        endIndex = i;
-        break;
-      }
-    }
-    if (endIndex === -1) return null;
-    const extracted = content.slice(braceStart, endIndex + 1);
+    const extracted = content.slice(clientInputType.getStart(sourceFile), clientInputType.getEnd());
     console.log(`[TemplateInjector] Extracted clientInput types: ${extracted}`);
     return extracted;
   } catch (error) {
@@ -4458,10 +4441,16 @@ var checkPagePlacement = (filePath, srcRelativePath) => {
   }
   return null;
 };
+var TEMPLATE_LINT_HEADER = /^(?:\/\* eslint-disable(?: unicorn\/no-abusive-eslint-disable)? \*\/[^\S\r\n]*\r?\n)+(?:[^\S\r\n]*\r?\n)?/;
+var BYTE_ORDER_MARK = String.fromCodePoint(65279);
+var stripTemplateLintHeader = (content) => {
+  const unmarked = content.startsWith(BYTE_ORDER_MARK) ? content.slice(1) : content;
+  return TEMPLATE_LINT_HEADER.test(unmarked) ? unmarked.replace(TEMPLATE_LINT_HEADER, "") : content;
+};
 var applyTemplatePlaceholders = (content, filePath, fileKind) => {
   const relPath = calculateRelativePath(filePath);
   const pragmaPattern = /\/\/\s*@ts-(?:ignore|expect-error).*\r?\n(.*)\{\{REL_PATH\}\}/g;
-  let result = content.replaceAll(pragmaPattern, (_, prefix) => `${prefix}${relPath}`);
+  let result = stripTemplateLintHeader(content).replaceAll(pragmaPattern, (_, prefix) => `${prefix}${relPath}`);
   result = result.replaceAll("{{REL_PATH}}", () => relPath);
   if (fileKind === "sync_client" || fileKind === "sync_server") {
     const pagePath = extractSyncPagePath2(filePath);
@@ -4518,7 +4507,7 @@ var shouldInjectTemplate = (filePath, options = {}) => {
     return false;
   }
   if (isEmptyFile(filePath)) return true;
-  if (options.isNewFile) return isCommentOnlyFile(filePath);
+  if (options.isNewFile) return isInjectedGuidanceOnlyFile(filePath);
   return false;
 };
 var ensureImportedTypes = (content, clientFilePath) => {
@@ -4685,11 +4674,12 @@ var injectServerTemplateWithClientInput = async (serverFilePath, clientInputType
   try {
     await ensureConsumerTemplateConfigLoaded();
     const relPath = calculateRelativePath(serverFilePath);
-    let content = resolveTemplateContent("sync_server");
-    if (content === null) {
+    const rawContent = resolveTemplateContent("sync_server");
+    if (rawContent === null) {
       console.error(`[TemplateInjector] No sync_server template content available for: ${serverFilePath}`);
       return false;
     }
+    let content = stripTemplateLintHeader(rawContent);
     const pragmaPattern = /\/\/\s*@ts-(?:ignore|expect-error).*\r?\n(.*)\{\{REL_PATH\}\}/g;
     content = content.replaceAll(pragmaPattern, (_, prefix) => {
       return `${prefix}${relPath}`;
@@ -4712,6 +4702,7 @@ var injectServerTemplateWithClientInput = async (serverFilePath, clientInputType
 import fs10 from "fs";
 import path13 from "path";
 import { ROOT_DIR as ROOT_DIR8, getServerFunctionDirs as getServerFunctionDirs2, getSharedDir, getSrcDir as getSrcDir5 } from "@luckystack/core";
+var srcDirFromRoot = () => path13.relative(ROOT_DIR8, getSrcDir5()).replaceAll("\\", "/");
 var SUPPORTED_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"];
 var normalizePath4 = (value) => path13.resolve(value).replaceAll("\\", "/");
 var isSupportedScriptFile = (value) => {
@@ -4829,9 +4820,12 @@ var resolveImportToFile = (importerPath, specifier) => {
     const relativeBase = path13.resolve(path13.dirname(importerPath), specifier);
     return tryResolveWithExtensions(relativeBase);
   }
-  if (specifier.startsWith("src/") || specifier.startsWith("@/")) {
-    const sourcePath = specifier.startsWith("@/") ? specifier.slice(2) : specifier.slice(4);
-    return tryResolveWithExtensions(path13.join(getSrcDir5(), sourcePath));
+  const srcFromRoot = srcDirFromRoot();
+  const srcAliases = ["src/", "@/"];
+  if (srcFromRoot && !srcFromRoot.startsWith("..")) srcAliases.push(`${srcFromRoot}/`);
+  const srcAlias = srcAliases.find((alias) => specifier.startsWith(alias));
+  if (srcAlias) {
+    return tryResolveWithExtensions(path13.join(getSrcDir5(), specifier.slice(srcAlias.length)));
   }
   if (specifier.startsWith("shared/")) {
     return tryResolveWithExtensions(path13.join(getSharedDir(), specifier.slice(7)));
@@ -4839,7 +4833,10 @@ var resolveImportToFile = (importerPath, specifier) => {
   return null;
 };
 var isRouteFile = (filePath) => {
-  return filePath.includes("/src/") && (filePath.includes("/_api/") || filePath.includes("/_sync/"));
+  const relative = path13.relative(getSrcDir5(), filePath).replaceAll("\\", "/");
+  if (relative.startsWith("..") || path13.isAbsolute(relative)) return false;
+  const markerPath = `/${relative}`;
+  return (markerPath.includes(apiMarkerSegment()) || markerPath.includes(syncMarkerSegment())) && isRouteSurfaceFile(markerPath);
 };
 var collectScopedFiles = () => {
   const now = Date.now();
@@ -4932,26 +4929,36 @@ var runPrismaGenerate = async () => tryCatch2(
 );
 
 // src/hotReload.ts
-import { tryCatch as tryCatch3, getProjectConfig, getLocaleReloader, isProductionRuntime } from "@luckystack/core";
+import {
+  tryCatch as tryCatch3,
+  getProjectConfig,
+  getLocaleReloader,
+  isProductionRuntime,
+  getGeneratedSocketTypesPath as getGeneratedSocketTypesPath7,
+  getGeneratedApiSchemasPath as getGeneratedApiSchemasPath2,
+  getGeneratedApiDocsPath as getGeneratedApiDocsPath2
+} from "@luckystack/core";
 var normalizeFsPath = (value) => path15.resolve(value).replaceAll("\\", "/");
 var isGeneratedPath = (normalizedPath) => {
-  return normalizedPath.includes("apiTypes.generated.ts") || normalizedPath.includes("apiDocs.generated.json");
+  if (normalizedPath.includes(".generated.")) return true;
+  return [getGeneratedSocketTypesPath7(), getGeneratedApiSchemasPath2(), getGeneratedApiDocsPath2()].some((generatedPath) => normalizeFsPath(generatedPath) === normalizedPath);
 };
 var createTypeMapQueue = () => {
   const queue = { pending: false, running: false };
   const run = () => {
     queue.running = true;
     queue.pending = false;
-    const startedAt = Date.now();
     setImmediate(() => {
       void (async () => {
+        const startedAt = Date.now();
         const [err] = await tryCatch3(() => {
           generateTypeMapFile({ quiet: true });
         });
+        const durationMs = Date.now() - startedAt;
         if (err) {
-          console.log(`[HotReload] type map regeneration failed: ${String(err)}`, "red");
+          console.log(`[HotReload] type map regeneration failed after ${durationMs}ms: ${String(err)}`, "red");
         } else {
-          console.log(`[HotReload] type map ready in ${Date.now() - startedAt}ms`, "green");
+          console.log(`[HotReload] type map regenerated in ${durationMs}ms (the server answered no requests meanwhile)`, "green");
         }
         queue.running = false;
         if (queue.pending) {
@@ -4973,7 +4980,12 @@ var createPendingChangeSets = () => ({
   apiUpserts: /* @__PURE__ */ new Set(),
   apiDeletes: /* @__PURE__ */ new Set(),
   syncUpserts: /* @__PURE__ */ new Set(),
-  syncDeletes: /* @__PURE__ */ new Set()
+  syncDeletes: /* @__PURE__ */ new Set(),
+  //? Deleted sync SERVER files whose paired client still needs its types
+  //? inlined. A set the sync task drains, not a closure handed to the
+  //? scheduler: any later sync event in the debounce window replaces the
+  //? scheduled task, and a closure would be dropped with it.
+  deletedSyncServers: /* @__PURE__ */ new Set()
 });
 var buildPathSegments = () => {
   const rules2 = getRoutingRules();
@@ -4994,10 +5006,11 @@ var buildPathSegments = () => {
   };
 };
 var makeIsInServerFunctionsDir = (segments) => (normalizedPath) => segments.serverFunctionsSegments.some((seg) => normalizedPath.includes(seg));
-var makeIsRouteDependencyFile = (segments) => (normalizedPath) => {
+var makeIsRouteFile = (segments) => (normalizedPath) => (normalizedPath.includes(segments.apiMarkerSlash) || normalizedPath.includes(segments.syncMarkerSlash)) && isRouteSurfaceFile(normalizedPath);
+var makeIsRouteDependencyFile = (segments, isRouteFile2) => (normalizedPath) => {
   if (!normalizedPath.endsWith(".ts") && !normalizedPath.endsWith(".tsx")) return false;
   if (!normalizedPath.includes(segments.srcSegment)) return false;
-  if (normalizedPath.includes(segments.apiMarkerSlash) || normalizedPath.includes(segments.syncMarkerSlash)) return false;
+  if (isRouteFile2(normalizedPath)) return false;
   if (isGeneratedPath(normalizedPath)) return false;
   return true;
 };
@@ -5006,10 +5019,10 @@ var makeIsSharedDependencyFile = (segments, isInServerFunctionsDir) => (normaliz
   if (normalizedPath.includes(segments.sharedSegment)) return true;
   return isInServerFunctionsDir(normalizedPath);
 };
-var makeIsTypeMapRelevantFile = (segments) => (normalizedPath) => {
+var makeIsTypeMapRelevantFile = (segments, isRouteFile2) => (normalizedPath) => {
   if (isGeneratedPath(normalizedPath)) return false;
   if (!(normalizedPath.endsWith(".ts") || normalizedPath.endsWith(".tsx"))) return false;
-  if (normalizedPath.includes(segments.apiMarkerSlash) || normalizedPath.includes(segments.syncMarkerSlash)) return false;
+  if (isRouteFile2(normalizedPath)) return false;
   return normalizedPath.includes(segments.srcSegment) || normalizedPath.endsWith("/config.ts") || normalizedPath.includes(segments.sharedSegment);
 };
 var makeIsLocaleFile = (segments) => (normalizedPath) => normalizedPath.includes(segments.localesSegment) && normalizedPath.endsWith(".json");
@@ -5047,9 +5060,10 @@ var setupWatchers = () => {
   if (!isDevMode) return;
   const segments = buildPathSegments();
   const isInServerFunctionsDir = makeIsInServerFunctionsDir(segments);
-  const isRouteDependencyFile = makeIsRouteDependencyFile(segments);
+  const isRouteFile2 = makeIsRouteFile(segments);
+  const isRouteDependencyFile = makeIsRouteDependencyFile(segments, isRouteFile2);
   const isSharedDependencyFile = makeIsSharedDependencyFile(segments, isInServerFunctionsDir);
-  const isTypeMapRelevantFile = makeIsTypeMapRelevantFile(segments);
+  const isTypeMapRelevantFile = makeIsTypeMapRelevantFile(segments, isRouteFile2);
   const isLocaleFile = makeIsLocaleFile(segments);
   const typeMap = createTypeMapQueue();
   const pending = createPendingChangeSets();
@@ -5068,11 +5082,31 @@ var setupWatchers = () => {
       console.log(`[HotReload] API removed: ${deletePath}`, "yellow");
     }
     for (const upsertPath of upsertPaths) {
+      const startedAt = Date.now();
       await upsertApiFromFile(upsertPath);
-      console.log(`[HotReload] API reloaded: ${upsertPath}`, "green");
+      console.log(`[HotReload] API reloaded in ${Date.now() - startedAt}ms: ${upsertPath}`, "green");
+    }
+  };
+  const migrateClientsOfDeletedSyncServers = async () => {
+    const serverPaths = [...pending.deletedSyncServers];
+    pending.deletedSyncServers.clear();
+    for (const serverPath of serverPaths) {
+      if (fs12.existsSync(serverPath)) continue;
+      const clientPath = getPairedSyncFile(serverPath);
+      if (!clientPath || !fs12.existsSync(clientPath)) continue;
+      const clientInputTypes = extractClientInputFromGeneratedTypes(
+        extractSyncPagePath2(serverPath),
+        extractSyncName2(serverPath),
+        extractSyncVersion2(serverPath)
+      );
+      await updateClientFileForDeletedServer(
+        clientPath,
+        clientInputTypes ?? "{\n    // Types were in _server.ts - please add them here\n  }"
+      );
     }
   };
   const processPendingSyncChanges = async ({ regenerateTypeMap = false } = {}) => {
+    await migrateClientsOfDeletedSyncServers();
     const deletePaths = [...pending.syncDeletes];
     const upsertPaths = [...pending.syncUpserts];
     pending.syncDeletes.clear();
@@ -5086,16 +5120,28 @@ var setupWatchers = () => {
       console.log(`[HotReload] Sync removed: ${deletePath}`, "yellow");
     }
     for (const upsertPath of upsertPaths) {
+      const startedAt = Date.now();
       await upsertSyncFromFile(upsertPath);
-      console.log(`[HotReload] Sync reloaded: ${upsertPath}`, "green");
+      console.log(`[HotReload] Sync reloaded in ${Date.now() - startedAt}ms: ${upsertPath}`, "green");
     }
   };
   const enqueueAffectedRoutesFromDependency = (changedPath) => {
     const affectedRoutes = findDependentRouteFiles(changedPath);
     if (affectedRoutes.size === 0) {
       console.log(`[HotReload] No API/Sync routes depend on: ${changedPath}`, "yellow");
-      return;
+      return false;
+    }
+    if (requestDevServerRestart(changedPath)) {
+      console.log(
+        `[HotReload] Dependency changed: ${changedPath} -> restarting the dev server (${affectedRoutes.size} route(s) import it)`,
+        "blue"
+      );
+      return true;
     }
+    console.log(
+      `[HotReload] ${changedPath} changed, but routes that import it keep running its old code until you restart the dev server (the supervised \`npm run server\` restarts automatically)`,
+      "yellow"
+    );
     let queuedApiCount = 0;
     let queuedSyncCount = 0;
     for (const routePath of affectedRoutes) {
@@ -5123,6 +5169,7 @@ var setupWatchers = () => {
         await processPendingSyncChanges();
       });
     }
+    return false;
   };
   const handleAdd = async (filePath) => {
     const normalizedPath = normalizeFsPath(filePath);
@@ -5162,7 +5209,8 @@ var setupWatchers = () => {
         return;
       }
     }
-    if (normalizedPath.includes(segments.apiMarkerNoLead)) {
+    const isRoute = isRouteFile2(normalizedPath);
+    if (isRoute && normalizedPath.includes(segments.apiMarkerNoLead)) {
       pending.apiDeletes.delete(normalizedPath);
       pending.apiUpserts.add(normalizedPath);
       scheduleReload("api", async () => {
@@ -5170,7 +5218,7 @@ var setupWatchers = () => {
       });
       return;
     }
-    if (normalizedPath.includes(segments.syncMarkerNoLead)) {
+    if (isRoute && normalizedPath.includes(segments.syncMarkerNoLead)) {
       pending.syncDeletes.delete(normalizedPath);
       pending.syncUpserts.add(normalizedPath);
       scheduleReload("sync", async () => {
@@ -5212,11 +5260,11 @@ var setupWatchers = () => {
       return;
     }
     if (isRouteDependencyFile(normalizedPath)) {
+      if (enqueueAffectedRoutesFromDependency(normalizedPath)) return;
       scheduleReload("typemap", () => {
         console.log(`[HotReload] Route dependency changed, scheduling type map regeneration`, "blue");
         typeMap.request();
       });
-      enqueueAffectedRoutesFromDependency(normalizedPath);
       return;
     }
     if (isTypeMapRelevantFile(normalizedPath)) {
@@ -5250,13 +5298,13 @@ var setupWatchers = () => {
   const handleFunctionChange = (changedPath) => {
     const normalizedPath = normalizeFsPath(changedPath);
     invalidateGraphForFile(normalizedPath);
+    if (isSharedDependencyFile(normalizedPath) && enqueueAffectedRoutesFromDependency(normalizedPath)) {
+      return;
+    }
     scheduleReload("functions", async () => {
       typeMap.request();
       await initializeFunctions();
     });
-    if (isSharedDependencyFile(normalizedPath)) {
-      enqueueAffectedRoutesFromDependency(normalizedPath);
-    }
   };
   const handleDelete = (filePath) => {
     const normalizedPath = normalizeFsPath(filePath);
@@ -5271,11 +5319,11 @@ var setupWatchers = () => {
       return;
     }
     if (isRouteDependencyFile(normalizedPath)) {
+      if (enqueueAffectedRoutesFromDependency(normalizedPath)) return;
       scheduleReload("typemap", () => {
         console.log(`[HotReload] Route dependency deleted, scheduling type map regeneration`, "blue");
         typeMap.request();
       });
-      enqueueAffectedRoutesFromDependency(normalizedPath);
       return;
     }
     if (isTypeMapRelevantFile(normalizedPath)) {
@@ -5301,19 +5349,10 @@ var setupWatchers = () => {
       });
       pending.syncUpserts.delete(normalizedPath);
       pending.syncDeletes.add(normalizedPath);
+      if (isSyncServerFile(normalizedPath)) {
+        pending.deletedSyncServers.add(normalizedPath);
+      }
       scheduleReload("sync", async () => {
-        if (isSyncServerFile(normalizedPath)) {
-          const clientPath = getPairedSyncFile(normalizedPath);
-          if (clientPath && fs12.existsSync(clientPath)) {
-            const pagePath = extractSyncPagePath2(normalizedPath);
-            const syncName = extractSyncName2(normalizedPath);
-            const clientInputTypes = extractClientInputFromGeneratedTypes(pagePath, syncName);
-            await updateClientFileForDeletedServer(
-              clientPath,
-              clientInputTypes ?? "{\n    // Types were in _server.ts - please add them here\n  }"
-            );
-          }
-        }
         await processPendingSyncChanges();
       });
     }