@luckystack/devkit 0.14.0 → 0.15.0

package/AGENTS.md

@@ -6,4 +6,4 @@ Generated route contracts must preserve transport-safe types. A source file miss
 
 The one deliberate diagnostics exception — an absent optional sync side — must stay scoped to that side's own field and run after the thrown-extraction check (ADR 0057). Server-backed sync routes share the API side's auth/rate-limit extractors and schema converter so the test-runner can sweep them (ADR 0064). See `docs/type-map-generation.md`.
 
-Hot reload should not block serving live requests while building developer artifacts. Avoid invalidating the shared Program on initial population without cause; do invalidate when source changes. Consumer-owned template overrides intentionally outlive the installed devkit's bundled defaults; do not overwrite them on upgrade.
+Hot reload does pause request handling while it builds the TypeScript Program and regenerates the type map: that work is synchronous, and deferring it only lets the current event finish. The pause is accepted for development; keep its duration logged and keep generation off the boot path so the server listens first. Do not describe it as non-blocking (see `docs/hot-reload.md`). Avoid invalidating the shared Program on initial population without cause; do invalidate when source changes. Consumer-owned template overrides intentionally outlive the installed devkit's bundled defaults; do not overwrite them on upgrade.

package/CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to `@luckystack/devkit` are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.15.0] - 2026-10-19
+
+### Changed
+
+- **Editing a file that a route imports restarts the supervised dev server** (`npm run server`), so the new code actually runs; connected clients reconnect (ADR 0079). Before, the route was re-imported but kept running the old dependency code. The supervisor now starts the dev server with an IPC channel for this (Node; Bun on Linux and macOS). Without the supervisor, a warning says a restart is needed. Editing a route file itself still reloads it in place.
+- **Hot reload logs how long type-map regeneration and each route reload took.** The docs now say the dev server answers no requests during that time (ADR 0080).
+
+### Fixed
+
+- **The dev server starts, and type generation runs, when a `.test.ts` or `.spec.ts` file sits next to a route.**
+- **A project checked out under a folder named `_api` or `_sync` boots again.** Route naming is validated relative to the source folder.
+- **The duplicate-route check reports a root sync** (`src/_sync/x_server_v1.ts`) that collides with `src/system/_sync/x_server_v1.ts`, as it already did for APIs.
+- **Deleting a sync `_server` file moves the real `clientInput` type into the paired client** instead of an empty placeholder, and that client rewrite is no longer lost when another sync file is saved within the reload debounce window.
+- **Helpers in a private folder under `_api`/`_sync`** (for example `_api/_lib/helpers.ts`) **and test files next to routes are no longer treated as misnamed routes:** a new empty helper gets no guidance comment written into it, there is no false "ignored by route loading" warning, and editing a helper regenerates types and reloads the routes that use it.
+- **The paired-sync rewrite writes the correct `PagePath`** when the project lives under a folder named `src`, uses a different source folder, or uses a custom sync marker.
+- **A fully commented-out route or page file that arrives by rename, move, `git checkout` or `stash pop` is no longer overwritten with the starter template.** Only empty files, or files that still hold only the injector's guidance line, receive a template.
+- **Route reloads after a dependency change honour a custom source folder and custom route markers.**
+- **Writing the generated Zod schema file no longer triggers a second full type-map generation.**
+- **Saving a watched file while the supervisor waits to restart a crashed server no longer starts two server processes.**
+
 ## [0.14.0] - 2026-10-16
 
 ### Fixed

package/dist/chunk-FWE6YJ3G.js

@@ -0,0 +1,17 @@
+// src/devServerRestart.ts
+var DEV_RESTART_MESSAGE_TYPE = "luckystack:dev-restart";
+var isDevRestartMessage = (value) => typeof value === "object" && value !== null && "type" in value && value.type === DEV_RESTART_MESSAGE_TYPE && "reason" in value && typeof value.reason === "string";
+var requestDevServerRestart = (reason) => {
+  if (process.env.LUCKYSTACK_CORE_SUPERVISED !== "true") return false;
+  if (typeof process.send !== "function" || !process.connected) return false;
+  const message = { type: DEV_RESTART_MESSAGE_TYPE, reason };
+  return process.send(message, void 0, void 0, (error) => {
+    if (error) console.log(`[HotReload] Could not ask the supervisor to restart: ${String(error)}`, "red");
+  });
+};
+
+export {
+  isDevRestartMessage,
+  requestDevServerRestart
+};
+//# sourceMappingURL=chunk-FWE6YJ3G.js.map

package/dist/chunk-FWE6YJ3G.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/devServerRestart.ts"],"sourcesContent":["//? Restart request from the dev server (child) to the supervisor (parent).\n//?\n//? Why a restart and not a reload: hot reload re-imports a route with a `?v=`\n//? query, but the ESM loader caches the route's own imports by their plain URL.\n//? After a helper the route imports changes, the re-imported route still links\n//? to the cached OLD helper, so only a fresh process runs the new code. No\n//? loader hook can carry the query down the import graph under both tsx and\n//? Bun, so the supervisor restarts the child, the same way it does for a\n//? `config.ts` edit.\n//?\n//? This module is bundled into the supervisor entry, so it must import nothing\n//? from `@luckystack/core` (see the env invariant in `supervisor.ts`).\n\nexport const DEV_RESTART_MESSAGE_TYPE = 'luckystack:dev-restart';\n\nexport interface DevRestartMessage {\n  type: typeof DEV_RESTART_MESSAGE_TYPE;\n  reason: string;\n}\n\nexport const isDevRestartMessage = (value: unknown): value is DevRestartMessage =>\n  typeof value === 'object'\n  && value !== null\n  && 'type' in value\n  && value.type === DEV_RESTART_MESSAGE_TYPE\n  && 'reason' in value\n  && typeof value.reason === 'string';\n\n/**\n * Ask the supervisor to restart this dev server. Returns false when nothing\n * can restart it (started without the supervisor, or no IPC channel), so the\n * caller can tell the developer to restart by hand.\n */\nexport const requestDevServerRestart = (reason: string): boolean => {\n  if (process.env.LUCKYSTACK_CORE_SUPERVISED !== 'true') return false;\n  if (typeof process.send !== 'function' || !process.connected) return false;\n\n  const message: DevRestartMessage = { type: DEV_RESTART_MESSAGE_TYPE, reason };\n  //? The callback keeps a failed send from surfacing as an unhandled 'error'.\n  return process.send(message, undefined, undefined, (error: Error | null) => {\n    if (error) console.log(`[HotReload] Could not ask the supervisor to restart: ${String(error)}`, 'red');\n  });\n};\n"],"mappings":";AAaO,IAAM,2BAA2B;AAOjC,IAAM,sBAAsB,CAAC,UAClC,OAAO,UAAU,YACd,UAAU,QACV,UAAU,SACV,MAAM,SAAS,4BACf,YAAY,SACZ,OAAO,MAAM,WAAW;AAOtB,IAAM,0BAA0B,CAAC,WAA4B;AAClE,MAAI,QAAQ,IAAI,+BAA+B,OAAQ,QAAO;AAC9D,MAAI,OAAO,QAAQ,SAAS,cAAc,CAAC,QAAQ,UAAW,QAAO;AAErE,QAAM,UAA6B,EAAE,MAAM,0BAA0B,OAAO;AAE5E,SAAO,QAAQ,KAAK,SAAS,QAAW,QAAW,CAAC,UAAwB;AAC1E,QAAI,MAAO,SAAQ,IAAI,wDAAwD,OAAO,KAAK,CAAC,IAAI,KAAK;AAAA,EACvG,CAAC;AACH;","names":[]}

package/dist/devServerRestart.d.ts

@@ -0,0 +1,12 @@
+export declare const DEV_RESTART_MESSAGE_TYPE = "luckystack:dev-restart";
+export interface DevRestartMessage {
+    type: typeof DEV_RESTART_MESSAGE_TYPE;
+    reason: string;
+}
+export declare const isDevRestartMessage: (value: unknown) => value is DevRestartMessage;
+/**
+ * Ask the supervisor to restart this dev server. Returns false when nothing
+ * can restart it (started without the supervisor, or no IPC channel), so the
+ * caller can tell the developer to restart by hand.
+ */
+export declare const requestDevServerRestart: (reason: string) => boolean;

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) {
@@ -4524,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) => {
@@ -4719,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) => {
@@ -4836,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)));
@@ -4846,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();
@@ -4939,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) {
@@ -4980,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();
@@ -5001,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;
 };
@@ -5013,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");
@@ -5054,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();
@@ -5075,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();
@@ -5093,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) {
@@ -5130,6 +5169,7 @@ var setupWatchers = () => {
         await processPendingSyncChanges();
       });
     }
+    return false;
   };
   const handleAdd = async (filePath) => {
     const normalizedPath = normalizeFsPath(filePath);
@@ -5169,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 () => {
@@ -5177,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 () => {
@@ -5219,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)) {
@@ -5257,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);
@@ -5278,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)) {
@@ -5308,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();
       });
     }