@boon4681/giri 0.0.2-alpha-6 → 0.0.2-alpha-8

package/dist/cli.js

@@ -46,12 +46,18 @@ var init_es5 = __esm({
 });
 
 // src/generator/schema/program.ts
-function createSchemaProgram(paths, routeFiles) {
+function leanOptions(options) {
+  return {
+    ...options,
+    types: []
+  };
+}
+function createSchemaProgram(paths, routeFiles, programOptions = {}) {
   let options = { ...DEFAULT_OPTIONS };
-  const configPath = import_typescript.default.findConfigFile(paths.cwd, import_typescript.default.sys.fileExists, "tsconfig.json");
+  const configPath = import_typescript2.default.findConfigFile(paths.cwd, import_typescript2.default.sys.fileExists, "tsconfig.json");
   if (configPath) {
-    const parsed = import_typescript.default.getParsedCommandLineOfConfigFile(configPath, {}, {
-      ...import_typescript.default.sys,
+    const parsed = import_typescript2.default.getParsedCommandLineOfConfigFile(configPath, {}, {
+      ...import_typescript2.default.sys,
       onUnRecoverableConfigFileDiagnostic: () => {
       }
     });
@@ -59,17 +65,20 @@ function createSchemaProgram(paths, routeFiles) {
       options = { ...parsed.options, noEmit: true };
     }
   }
-  return import_typescript.default.createProgram(routeFiles, options);
+  if (programOptions.lean) {
+    options = leanOptions(options);
+  }
+  return import_typescript2.default.createProgram(routeFiles, options);
 }
-var import_typescript, DEFAULT_OPTIONS;
+var import_typescript2, DEFAULT_OPTIONS;
 var init_program = __esm({
   "src/generator/schema/program.ts"() {
     "use strict";
-    import_typescript = __toESM(require("typescript"));
+    import_typescript2 = __toESM(require("typescript"));
     DEFAULT_OPTIONS = {
-      target: import_typescript.default.ScriptTarget.ES2022,
-      module: import_typescript.default.ModuleKind.NodeNext,
-      moduleResolution: import_typescript.default.ModuleResolutionKind.NodeNext,
+      target: import_typescript2.default.ScriptTarget.ES2022,
+      module: import_typescript2.default.ModuleKind.NodeNext,
+      moduleResolution: import_typescript2.default.ModuleResolutionKind.NodeNext,
       strict: true,
       skipLibCheck: true,
       noEmit: true
@@ -103,7 +112,7 @@ function literalValuesOf(types) {
   for (const member of types) {
     if (member.isStringLiteral() || member.isNumberLiteral()) {
       values.push(member.value);
-    } else if (member.flags & import_typescript2.default.TypeFlags.BooleanLiteral) {
+    } else if (member.flags & import_typescript3.default.TypeFlags.BooleanLiteral) {
       values.push(intrinsicName(member) === "true");
     } else {
       return void 0;
@@ -112,7 +121,7 @@ function literalValuesOf(types) {
   return values;
 }
 function walkUnion(type, ctx) {
-  const flag = import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void | import_typescript2.default.TypeFlags.Never;
+  const flag = import_typescript3.default.TypeFlags.Undefined | import_typescript3.default.TypeFlags.Void | import_typescript3.default.TypeFlags.Never;
   const members = type.types.filter((member) => !(member.flags & flag));
   if (members.length === 1) {
     return walkType(members[0], ctx);
@@ -125,13 +134,13 @@ function walkUnion(type, ctx) {
 }
 function buildObjectSchema(type, ctx) {
   const { checker } = ctx;
-  const indexInfo = checker.getIndexInfoOfType(type, import_typescript2.default.IndexKind.String) ?? checker.getIndexInfoOfType(type, import_typescript2.default.IndexKind.Number);
+  const indexInfo = checker.getIndexInfoOfType(type, import_typescript3.default.IndexKind.String) ?? checker.getIndexInfoOfType(type, import_typescript3.default.IndexKind.Number);
   const properties = {};
   const required = [];
   for (const symbol of checker.getPropertiesOfType(type)) {
     const name = symbol.getName();
     const propType = checker.getTypeOfSymbolAtLocation(symbol, ctx.location);
-    const optional = Boolean(symbol.getFlags() & import_typescript2.default.SymbolFlags.Optional) || Boolean(propType.flags & import_typescript2.default.TypeFlags.Union && propType.types.some((t) => t.flags & import_typescript2.default.TypeFlags.Undefined));
+    const optional = Boolean(symbol.getFlags() & import_typescript3.default.SymbolFlags.Optional) || Boolean(propType.flags & import_typescript3.default.TypeFlags.Union && propType.types.some((t) => t.flags & import_typescript3.default.TypeFlags.Undefined));
     properties[name] = walkType(propType, ctx);
     if (!optional) {
       required.push(name);
@@ -190,16 +199,16 @@ function walkObject(type, ctx) {
 }
 function walkType(type, ctx) {
   const flags = type.flags;
-  if (flags & (import_typescript2.default.TypeFlags.Any | import_typescript2.default.TypeFlags.Unknown)) {
+  if (flags & (import_typescript3.default.TypeFlags.Any | import_typescript3.default.TypeFlags.Unknown)) {
     return {};
   }
-  if (flags & import_typescript2.default.TypeFlags.Null) {
+  if (flags & import_typescript3.default.TypeFlags.Null) {
     return { type: "null" };
   }
-  if (flags & (import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void)) {
+  if (flags & (import_typescript3.default.TypeFlags.Undefined | import_typescript3.default.TypeFlags.Void)) {
     return {};
   }
-  if (flags & (import_typescript2.default.TypeFlags.BigInt | import_typescript2.default.TypeFlags.BigIntLiteral)) {
+  if (flags & (import_typescript3.default.TypeFlags.BigInt | import_typescript3.default.TypeFlags.BigIntLiteral)) {
     ctx.warnings.push("bigint is not JSON-serializable (JSON.stringify throws); documented as string.");
     return { type: "string" };
   }
@@ -209,45 +218,45 @@ function walkType(type, ctx) {
   if (type.isNumberLiteral()) {
     return { type: "number", const: type.value };
   }
-  if (flags & import_typescript2.default.TypeFlags.BooleanLiteral) {
+  if (flags & import_typescript3.default.TypeFlags.BooleanLiteral) {
     return { type: "boolean", const: intrinsicName(type) === "true" };
   }
-  if (flags & import_typescript2.default.TypeFlags.String) {
+  if (flags & import_typescript3.default.TypeFlags.String) {
     return { type: "string" };
   }
-  if (flags & import_typescript2.default.TypeFlags.Number) {
+  if (flags & import_typescript3.default.TypeFlags.Number) {
     return { type: "number" };
   }
-  if (flags & import_typescript2.default.TypeFlags.Boolean) {
+  if (flags & import_typescript3.default.TypeFlags.Boolean) {
     return { type: "boolean" };
   }
   if (type.isUnion()) {
     return walkUnion(type, ctx);
   }
-  if (flags & import_typescript2.default.TypeFlags.Object || type.isIntersection()) {
+  if (flags & import_typescript3.default.TypeFlags.Object || type.isIntersection()) {
     return walkObject(type, ctx);
   }
   return {};
 }
-var import_typescript2;
+var import_typescript3;
 var init_json_schema = __esm({
   "src/generator/schema/json-schema.ts"() {
     "use strict";
-    import_typescript2 = __toESM(require("typescript"));
+    import_typescript3 = __toESM(require("typescript"));
   }
 });
 
 // src/generator/schema/responses.ts
 function findHandleFunction(source) {
   let found;
-  const isExported = (node) => import_typescript3.default.canHaveModifiers(node) && (import_typescript3.default.getModifiers(node)?.some((m) => m.kind === import_typescript3.default.SyntaxKind.ExportKeyword) ?? false);
+  const isExported = (node) => import_typescript4.default.canHaveModifiers(node) && (import_typescript4.default.getModifiers(node)?.some((m) => m.kind === import_typescript4.default.SyntaxKind.ExportKeyword) ?? false);
   for (const statement of source.statements) {
-    if (import_typescript3.default.isFunctionDeclaration(statement) && statement.name?.text === "handle" && isExported(statement)) {
+    if (import_typescript4.default.isFunctionDeclaration(statement) && statement.name?.text === "handle" && isExported(statement)) {
       found = statement;
     }
-    if (import_typescript3.default.isVariableStatement(statement) && isExported(statement)) {
+    if (import_typescript4.default.isVariableStatement(statement) && isExported(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (import_typescript3.default.isIdentifier(declaration.name) && declaration.name.text === "handle" && declaration.initializer && (import_typescript3.default.isArrowFunction(declaration.initializer) || import_typescript3.default.isFunctionExpression(declaration.initializer))) {
+        if (import_typescript4.default.isIdentifier(declaration.name) && declaration.name.text === "handle" && declaration.initializer && (import_typescript4.default.isArrowFunction(declaration.initializer) || import_typescript4.default.isFunctionExpression(declaration.initializer))) {
           found = declaration.initializer;
         }
       }
@@ -256,7 +265,7 @@ function findHandleFunction(source) {
   return found;
 }
 function collectReturnExpressions(fn) {
-  if (import_typescript3.default.isArrowFunction(fn) && !import_typescript3.default.isBlock(fn.body)) {
+  if (import_typescript4.default.isArrowFunction(fn) && !import_typescript4.default.isBlock(fn.body)) {
     return [fn.body];
   }
   if (!fn.body) {
@@ -264,15 +273,15 @@ function collectReturnExpressions(fn) {
   }
   const expressions = [];
   const visit = (node) => {
-    if (import_typescript3.default.isFunctionDeclaration(node) || import_typescript3.default.isFunctionExpression(node) || import_typescript3.default.isArrowFunction(node)) {
+    if (import_typescript4.default.isFunctionDeclaration(node) || import_typescript4.default.isFunctionExpression(node) || import_typescript4.default.isArrowFunction(node)) {
       return;
     }
-    if (import_typescript3.default.isReturnStatement(node) && node.expression) {
+    if (import_typescript4.default.isReturnStatement(node) && node.expression) {
       expressions.push(node.expression);
     }
-    import_typescript3.default.forEachChild(node, visit);
+    import_typescript4.default.forEachChild(node, visit);
   };
-  import_typescript3.default.forEachChild(fn.body, visit);
+  import_typescript4.default.forEachChild(fn.body, visit);
   return expressions;
 }
 function propertyType(checker, type, name, location) {
@@ -284,15 +293,21 @@ function isTypedResponse(checker, type) {
     checker.getPropertyOfType(type, "data") && checker.getPropertyOfType(type, "status") && checker.getPropertyOfType(type, "format")
   );
 }
-function readFromCall(checker, expression) {
-  if (!import_typescript3.default.isCallExpression(expression) || !import_typescript3.default.isPropertyAccessExpression(expression.expression)) {
+function firstParameterName(fn) {
+  const [first] = fn.parameters;
+  return first && import_typescript4.default.isIdentifier(first.name) ? first.name.text : void 0;
+}
+function readFromCall(checker, expression, contextName) {
+  if (!import_typescript4.default.isCallExpression(expression) || !import_typescript4.default.isPropertyAccessExpression(expression.expression)) {
     return void 0;
   }
   const method = expression.expression.name.text;
   if (method !== "json" && method !== "text") {
     return void 0;
   }
-  if (!isTypedResponse(checker, checker.getTypeAtLocation(expression))) {
+  const target = expression.expression.expression;
+  const directContextCall = contextName && import_typescript4.default.isIdentifier(target) && target.text === contextName;
+  if (!directContextCall && !isTypedResponse(checker, checker.getTypeAtLocation(expression))) {
     return void 0;
   }
   const [dataArg, statusArg] = expression.arguments;
@@ -332,6 +347,7 @@ function extractRouteResponses(program, file) {
     return result;
   }
   const ctx = createWalkContext(checker, fn);
+  const contextName = firstParameterName(fn);
   const byStatus = /* @__PURE__ */ new Map();
   const record = (hit) => {
     const schema = walkType(hit.data, ctx);
@@ -340,7 +356,7 @@ function extractRouteResponses(program, file) {
     byStatus.set(hit.status, bucket);
   };
   for (const expression of collectReturnExpressions(fn)) {
-    const fromCall = readFromCall(checker, expression);
+    const fromCall = readFromCall(checker, expression, contextName);
     if (fromCall) {
       record(fromCall);
       continue;
@@ -366,11 +382,11 @@ function extractRouteResponses(program, file) {
   result.$defs = ctx.defs;
   return result;
 }
-var import_typescript3;
+var import_typescript4;
 var init_responses = __esm({
   "src/generator/schema/responses.ts"() {
     "use strict";
-    import_typescript3 = __toESM(require("typescript"));
+    import_typescript4 = __toESM(require("typescript"));
     init_json_schema();
   }
 });
@@ -394,7 +410,7 @@ var init_schema = __esm({
 
 // src/cli.ts
 var import_node_child_process = require("child_process");
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var import_promises4 = require("fs/promises");
 var import_node_path15 = require("path");
 var prompts = __toESM(require("@clack/prompts"));
@@ -526,13 +542,18 @@ function methodFromFile(fileName) {
   const stem = fileName.replace(/\.(?:[cm]?[jt]s|[jt]sx)$/, "").toLowerCase();
   return METHOD_FROM_FILE.get(stem);
 }
-function sharedFileIn(dir) {
+function sharedFileIn(dir, cache) {
+  if (cache?.has(dir)) {
+    return cache.get(dir);
+  }
   for (const ext of ["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts"]) {
     const file = (0, import_node_path2.join)(dir, `+shared.${ext}`);
     if ((0, import_node_fs2.existsSync)(file)) {
+      cache?.set(dir, file);
       return file;
     }
   }
+  cache?.set(dir, void 0);
   return void 0;
 }
 function physicalRouteSegments(routesDir, routeDir) {
@@ -601,7 +622,7 @@ async function scanRouteFolders(routesDir) {
 function routeParamsForDir(routesDir, dir) {
   return pathFromSegments(physicalRouteSegments(routesDir, dir)).params;
 }
-function sharedFilesForDir(routesDir, dir) {
+function sharedFilesForDir(routesDir, dir, cache) {
   const segments = physicalRouteSegments(routesDir, dir);
   const dirs = [routesDir];
   let current = routesDir;
@@ -609,7 +630,7 @@ function sharedFilesForDir(routesDir, dir) {
     current = (0, import_node_path2.join)(current, segment);
     dirs.push(current);
   }
-  return dirs.map(sharedFileIn).filter((file) => Boolean(file));
+  return dirs.map((currentDir) => sharedFileIn(currentDir, cache)).filter((file) => Boolean(file));
 }
 async function scanRoutes(routesDir) {
   if (!(0, import_node_fs2.existsSync)(routesDir)) {
@@ -621,6 +642,7 @@ async function scanRoutes(routesDir) {
     onlyFiles: true
   });
   const routes = [];
+  const sharedCache = /* @__PURE__ */ new Map();
   for (const file of files) {
     const method = methodFromFile((0, import_node_path2.basename)(file));
     if (!method) {
@@ -636,7 +658,7 @@ async function scanRoutes(routesDir) {
       routeDir,
       routeSegments,
       params,
-      sharedFiles: sharedFilesForDir(routesDir, routeDir)
+      sharedFiles: sharedFilesForDir(routesDir, routeDir, sharedCache)
     });
   }
   return routes.sort((left, right) => {
@@ -665,9 +687,11 @@ function isGiriBodySchema(value) {
 }
 
 // src/app.ts
-function loadModule(file) {
+function loadModule(file, force = true) {
   const resolved = require.resolve(file);
-  delete require.cache[resolved];
+  if (force) {
+    delete require.cache[resolved];
+  }
   return require(resolved);
 }
 function interopDefault(value) {
@@ -802,13 +826,23 @@ async function buildGiriApp(config, options = {}) {
   const { unregister } = await safeRegister();
   const unregisterAliasResolver = registerAliasResolver(config.alias, paths.cwd);
   try {
+    const dirty = options.dirty;
+    const forceReload = dirty === void 0;
+    const isDirty = (file) => forceReload || dirty.has(file);
+    const sharedCache = /* @__PURE__ */ new Map();
+    const loadShared = (file) => {
+      if (!sharedCache.has(file)) {
+        sharedCache.set(file, loadModule(file, isDirty(file)));
+      }
+      return sharedCache.get(file);
+    };
     for (const route of routes) {
-      const routeModule = loadModule(route.file);
+      const routeModule = loadModule(route.file, isDirty(route.file));
       if (typeof routeModule.handle !== "function") {
         throw new Error(`${route.file} must export a named handle function.`);
       }
       const folderMiddleware = routeModule.config?.skipInherited ? [] : route.sharedFiles.flatMap(
-        (file) => normalizeMiddleware(loadModule(file).middleware, file)
+        (file) => normalizeMiddleware(loadShared(file).middleware, file)
       );
       const verbMiddleware = normalizeMiddleware(routeModule.middleware, route.file);
       config.adapter.register(app, {
@@ -829,7 +863,7 @@ async function buildGiriApp(config, options = {}) {
 }
 
 // src/generator/sync.ts
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 var import_promises3 = require("fs/promises");
 var import_node_path11 = require("path");
 
@@ -1083,6 +1117,7 @@ function buildOpenApiDocument(paths, routes, data = {}) {
   const documentPaths = {};
   const schemas = {};
   const securitySchemes = {};
+  const tagOrder = [];
   for (const route of routes) {
     if (data.hiddenFiles?.has(route.file)) {
       continue;
@@ -1090,10 +1125,32 @@ function buildOpenApiDocument(paths, routes, data = {}) {
     const responses = data.responsesByFile?.get(route.file);
     const input = data.inputsByFile?.get(route.file);
     const security = data.securityByFile?.get(route.file);
+    const meta = data.openapiByFile?.get(route.file);
     for (const [name, schema] of Object.entries(responses?.$defs ?? {})) {
       schemas[name] = rewriteRefs(schema);
     }
-    const operation = { responses: buildResponses(responses?.responses ?? []) };
+    const operation = {};
+    if (meta?.tags && meta.tags.length > 0) {
+      operation.tags = meta.tags;
+      for (const tag2 of meta.tags) {
+        if (!tagOrder.includes(tag2)) {
+          tagOrder.push(tag2);
+        }
+      }
+    }
+    if (meta?.summary) {
+      operation.summary = meta.summary;
+    }
+    if (meta?.description) {
+      operation.description = meta.description;
+    }
+    if (meta?.operationId) {
+      operation.operationId = meta.operationId;
+    }
+    if (meta?.deprecated) {
+      operation.deprecated = true;
+    }
+    operation.responses = buildResponses(responses?.responses ?? []);
     const parameters = [...pathParameters(route), ...queryParameters(input?.query)];
     if (parameters.length > 0) {
       operation.parameters = parameters;
@@ -1125,6 +1182,9 @@ function buildOpenApiDocument(paths, routes, data = {}) {
     info: readProjectInfo(paths.cwd),
     paths: documentPaths
   };
+  if (tagOrder.length > 0) {
+    document.tags = tagOrder.map((name) => ({ name }));
+  }
   const components = {};
   if (Object.keys(schemas).length > 0) {
     components.schemas = schemas;
@@ -1156,14 +1216,29 @@ function paramsType(params) {
 ${fields}
 }`;
 }
-function varsType(typesDir, sharedFiles) {
-  if (sharedFiles.length === 0) {
-    return "{}";
+function middlewareVarsType(typesDir, sharedFile) {
+  const spec = JSON.stringify(moduleSpecifier(typesDir, sharedFile));
+  return `(typeof import(${spec}) extends { middleware: infer M } ? import("@boon4681/giri").InferStackVars<M> : {})`;
+}
+function ownSharedFile(dir, sharedFiles) {
+  for (let index = sharedFiles.length - 1; index >= 0; index -= 1) {
+    if ((0, import_node_path8.dirname)(sharedFiles[index]) === dir) {
+      return sharedFiles[index];
+    }
   }
-  return sharedFiles.map((file) => {
-    const spec = JSON.stringify(moduleSpecifier(typesDir, file));
-    return `(typeof import(${spec}) extends { middleware: infer M } ? import("@boon4681/giri").InferStackVars<M> : {})`;
-  }).join("\n    & ");
+  return void 0;
+}
+function varsType(paths, file, dir, sharedFiles) {
+  const typesDir = (0, import_node_path8.dirname)(file);
+  const parts = [];
+  if (dir !== paths.routesDir) {
+    parts.push(`import(${JSON.stringify(importPath(file, typeFilePath(paths, (0, import_node_path8.dirname)(dir))))}).Vars`);
+  }
+  const ownShared = ownSharedFile(dir, sharedFiles);
+  if (ownShared) {
+    parts.push(middlewareVarsType(typesDir, ownShared));
+  }
+  return parts.length > 0 ? parts.join("\n    & ") : "{}";
 }
 function methodExports(typesDir, verbs) {
   return verbs.map(({ method, file }) => {
@@ -1174,14 +1249,14 @@ function methodExports(typesDir, verbs) {
   });
 }
 async function writeParamTypes(paths, folders) {
-  for (const { dir, params, sharedFiles, verbs } of folders) {
+  await Promise.all(folders.map(({ dir, params, sharedFiles, verbs }) => {
     const file = typeFilePath(paths, dir);
     const typesDir = (0, import_node_path8.dirname)(file);
     const lines = [
       GENERATED_HEADER,
       `export type Params = ${paramsType(params)};`,
       "export type RouteParams = Params;",
-      `type Vars = ${varsType(typesDir, sharedFiles)};`,
+      `export type Vars = ${varsType(paths, file, dir, sharedFiles)};`,
       "export type Middleware<Injects extends Record<string, unknown> = {}> =",
       '  import("@boon4681/giri").Middleware<Params, import("@boon4681/giri").ValidatedInput, Injects>;',
       'export type Handle<Input extends import("@boon4681/giri").ValidatedInput = import("@boon4681/giri").ValidatedInput> =',
@@ -1191,10 +1266,14 @@ async function writeParamTypes(paths, folders) {
       lines.push(...methodExports(typesDir, verbs));
     }
     lines.push("");
-    await writeGenerated(file, lines.join("\n"));
-  }
+    return writeGenerated(file, lines.join("\n"));
+  }));
 }
 
+// src/generator/route-meta.ts
+var import_node_fs6 = require("fs");
+var import_typescript = __toESM(require("typescript"));
+
 // src/generator/inputs.ts
 function sanitize(schema) {
   const { $schema, ...rest } = schema;
@@ -1255,28 +1334,315 @@ function readInput(routeModule) {
   }
   return input.body || input.query ? input : void 0;
 }
-function hiddenFrom(value) {
-  if (value === false) {
+function hasExportModifier(node) {
+  return import_typescript.default.canHaveModifiers(node) && (import_typescript.default.getModifiers(node)?.some((modifier) => modifier.kind === import_typescript.default.SyntaxKind.ExportKeyword) ?? false);
+}
+function unwrapExpression(expression) {
+  let current = expression;
+  while (import_typescript.default.isParenthesizedExpression(current) || import_typescript.default.isAsExpression(current) || import_typescript.default.isSatisfiesExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+}
+function staticBoolean(expression) {
+  const value = unwrapExpression(expression);
+  if (value.kind === import_typescript.default.SyntaxKind.TrueKeyword) {
     return true;
   }
-  if (value === true) {
+  if (value.kind === import_typescript.default.SyntaxKind.FalseKeyword) {
     return false;
   }
-  if (value && typeof value === "object" && "hidden" in value) {
-    return Boolean(value.hidden);
+  return void 0;
+}
+function staticString(expression) {
+  const value = unwrapExpression(expression);
+  return import_typescript.default.isStringLiteralLike(value) ? value.text : void 0;
+}
+function staticStringArray(expression) {
+  const value = unwrapExpression(expression);
+  if (!import_typescript.default.isArrayLiteralExpression(value)) {
+    return void 0;
+  }
+  const strings = [];
+  for (const element of value.elements) {
+    const string = staticString(element);
+    if (string === void 0) {
+      return void 0;
+    }
+    strings.push(string);
+  }
+  return strings;
+}
+function propertyName(name) {
+  if (import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name) || import_typescript.default.isNumericLiteral(name)) {
+    return name.text;
   }
   return void 0;
 }
-function collectHidden(route, routeModule, loadShared) {
+function collectImportedNames(source) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of source.statements) {
+    if (!import_typescript.default.isImportDeclaration(statement)) {
+      continue;
+    }
+    const clause = statement.importClause;
+    if (!clause) {
+      continue;
+    }
+    if (clause.name) {
+      names.add(clause.name.text);
+    }
+    const bindings = clause.namedBindings;
+    if (bindings && import_typescript.default.isNamespaceImport(bindings)) {
+      names.add(bindings.name.text);
+    }
+    if (bindings && import_typescript.default.isNamedImports(bindings)) {
+      for (const element of bindings.elements) {
+        names.add(element.name.text);
+      }
+    }
+  }
+  return names;
+}
+function expressionReferencesImportedMiddleware(expression, importedNames) {
+  let found = false;
+  const allowedImportedHelpers = /* @__PURE__ */ new Set(["stack", "fromHono"]);
+  const visit = (node) => {
+    if (found) {
+      return;
+    }
+    if (import_typescript.default.isIdentifier(node) && importedNames.has(node.text) && !allowedImportedHelpers.has(node.text)) {
+      found = true;
+      return;
+    }
+    import_typescript.default.forEachChild(node, visit);
+  };
+  visit(expression);
+  return found;
+}
+function parseStaticOpenApi(expression) {
+  const value = unwrapExpression(expression);
+  const boolean = staticBoolean(value);
+  if (boolean !== void 0) {
+    return boolean;
+  }
+  if (!import_typescript.default.isObjectLiteralExpression(value)) {
+    return void 0;
+  }
+  const openapi = {};
+  for (const property of value.properties) {
+    if (!import_typescript.default.isPropertyAssignment(property)) {
+      return void 0;
+    }
+    const name = propertyName(property.name);
+    if (!name) {
+      return void 0;
+    }
+    if (name === "hidden") {
+      const hidden = staticBoolean(property.initializer);
+      if (hidden === void 0) {
+        return void 0;
+      }
+      openapi.hidden = hidden;
+    } else if (name === "tags") {
+      const tags = staticStringArray(property.initializer);
+      if (!tags) {
+        return void 0;
+      }
+      openapi.tags = tags;
+    } else if (name === "summary" || name === "description" || name === "operationId") {
+      const string = staticString(property.initializer);
+      if (string === void 0) {
+        return void 0;
+      }
+      openapi[name] = string;
+    } else if (name === "deprecated") {
+      const deprecated = staticBoolean(property.initializer);
+      if (deprecated === void 0) {
+        return void 0;
+      }
+      openapi.deprecated = deprecated;
+    } else {
+      return void 0;
+    }
+  }
+  return openapi;
+}
+function readStaticModuleMeta(file) {
+  let source;
+  try {
+    source = import_typescript.default.createSourceFile(file, (0, import_node_fs6.readFileSync)(file, "utf8"), import_typescript.default.ScriptTarget.Latest, true);
+  } catch {
+    return void 0;
+  }
+  const importedNames = collectImportedNames(source);
+  const sourceText = source.getFullText();
+  const canSkipMiddlewareRuntime = !sourceText.includes("defineMiddleware") && !sourceText.includes(".openapi");
+  const meta = { middlewareSecurity: false };
+  for (const statement of source.statements) {
+    if (import_typescript.default.isImportDeclaration(statement) || import_typescript.default.isInterfaceDeclaration(statement) || import_typescript.default.isTypeAliasDeclaration(statement) || import_typescript.default.isEmptyStatement(statement) || !hasExportModifier(statement)) {
+      continue;
+    }
+    if (import_typescript.default.isFunctionDeclaration(statement) && statement.name?.text === "handle") {
+      continue;
+    }
+    if (import_typescript.default.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!import_typescript.default.isIdentifier(declaration.name)) {
+          return void 0;
+        }
+        const name = declaration.name.text;
+        if (name === "openapi") {
+          if (!declaration.initializer) {
+            return void 0;
+          }
+          const openapi = parseStaticOpenApi(declaration.initializer);
+          if (openapi === void 0) {
+            return void 0;
+          }
+          meta.openapi = openapi;
+        } else if (name === "handle") {
+          if (!declaration.initializer || !import_typescript.default.isArrowFunction(declaration.initializer) && !import_typescript.default.isFunctionExpression(declaration.initializer)) {
+            return void 0;
+          }
+          continue;
+        } else if (name === "middleware") {
+          if (!declaration.initializer || !canSkipMiddlewareRuntime || expressionReferencesImportedMiddleware(declaration.initializer, importedNames)) {
+            return void 0;
+          }
+          meta.middlewareSecurity = false;
+          continue;
+        } else {
+          return void 0;
+        }
+      }
+      continue;
+    }
+    return void 0;
+  }
+  return meta;
+}
+function resolveStaticOpenApi(route, routeModule, loadShared) {
   let hidden = false;
+  const tags = [];
+  const meta = {};
+  const apply = (value, isVerb) => {
+    if (value === false) {
+      hidden = true;
+      return;
+    }
+    if (value === true) {
+      hidden = false;
+      return;
+    }
+    if (!value) {
+      return;
+    }
+    if (typeof value.hidden === "boolean") {
+      hidden = value.hidden;
+    }
+    if (value.tags) {
+      tags.push(...value.tags);
+    }
+    if (typeof value.summary === "string") {
+      meta.summary = value.summary;
+    }
+    if (typeof value.description === "string") {
+      meta.description = value.description;
+    }
+    if (typeof value.deprecated === "boolean") {
+      meta.deprecated = value.deprecated;
+    }
+    if (isVerb && typeof value.operationId === "string") {
+      meta.operationId = value.operationId;
+    }
+  };
   for (const file of route.sharedFiles) {
-    const opinion = hiddenFrom(loadShared(file).openapi);
-    if (opinion !== void 0) {
-      hidden = opinion;
+    const shared = loadShared(file);
+    if (!shared) {
+      return void 0;
     }
+    apply(shared.openapi, false);
+  }
+  apply(routeModule.openapi, true);
+  if (tags.length > 0) {
+    meta.tags = [...new Set(tags)];
+  }
+  return { hidden, meta };
+}
+function extractStaticMeta(route, routeModule, loadShared) {
+  const openapi = resolveStaticOpenApi(route, routeModule, loadShared);
+  if (!openapi) {
+    return void 0;
+  }
+  const meta = {};
+  if (openapi.hidden) {
+    meta.hidden = true;
+  }
+  if (Object.keys(openapi.meta).length > 0) {
+    meta.openapi = openapi.meta;
   }
-  const verb = hiddenFrom(routeModule.openapi);
-  return verb ?? hidden;
+  return meta;
+}
+function extractRuntimeSharedMeta(route, routeModule, loadShared) {
+  const meta = {};
+  const security = collectSecurity(route, {}, loadShared);
+  const { hidden, meta: openapi } = resolveOpenApi(route, { openapi: routeModule.openapi }, loadShared);
+  if (security) {
+    meta.security = security;
+  }
+  if (hidden) {
+    meta.hidden = true;
+  }
+  if (Object.keys(openapi).length > 0) {
+    meta.openapi = openapi;
+  }
+  return meta;
+}
+function resolveOpenApi(route, routeModule, loadShared) {
+  let hidden = false;
+  const tags = [];
+  const meta = {};
+  const apply = (value, isVerb) => {
+    if (value === false) {
+      hidden = true;
+      return;
+    }
+    if (value === true) {
+      hidden = false;
+      return;
+    }
+    if (!value || typeof value !== "object") {
+      return;
+    }
+    const o = value;
+    if ("hidden" in o) {
+      hidden = Boolean(o.hidden);
+    }
+    if (Array.isArray(o.tags)) {
+      tags.push(...o.tags.filter((tag2) => typeof tag2 === "string"));
+    }
+    if (typeof o.summary === "string") {
+      meta.summary = o.summary;
+    }
+    if (typeof o.description === "string") {
+      meta.description = o.description;
+    }
+    if (typeof o.deprecated === "boolean") {
+      meta.deprecated = o.deprecated;
+    }
+    if (isVerb && typeof o.operationId === "string") {
+      meta.operationId = o.operationId;
+    }
+  };
+  for (const file of route.sharedFiles) {
+    apply(loadShared(file).openapi, false);
+  }
+  apply(routeModule.openapi, true);
+  if (tags.length > 0) {
+    meta.tags = [...new Set(tags)];
+  }
+  return { hidden, meta };
 }
 function collectSecurity(route, routeModule, loadShared) {
   const skipInherited = Boolean(
@@ -1308,6 +1674,33 @@ function collectSecurity(route, routeModule, loadShared) {
 }
 async function extractRouteMeta(config, paths, routes) {
   const byFile = /* @__PURE__ */ new Map();
+  const remainingRoutes = [];
+  const runtimeSharedRoutes = [];
+  const staticCache = /* @__PURE__ */ new Map();
+  const loadStatic = (file) => {
+    if (!staticCache.has(file)) {
+      staticCache.set(file, readStaticModuleMeta(file));
+    }
+    return staticCache.get(file);
+  };
+  for (const route of routes) {
+    const routeModule = loadStatic(route.file);
+    if (!routeModule) {
+      remainingRoutes.push(route);
+      continue;
+    }
+    const meta = extractStaticMeta(route, routeModule, loadStatic);
+    if (meta) {
+      if (meta.hidden || meta.openapi) {
+        byFile.set(route.file, meta);
+      }
+      continue;
+    }
+    runtimeSharedRoutes.push({ route, routeModule });
+  }
+  if (remainingRoutes.length === 0 && runtimeSharedRoutes.length === 0) {
+    return byFile;
+  }
   const { unregister } = await safeRegister();
   const unregisterAlias = registerAliasResolver(config.alias, paths.cwd);
   const sharedCache = /* @__PURE__ */ new Map();
@@ -1322,13 +1715,19 @@ async function extractRouteMeta(config, paths, routes) {
     return sharedCache.get(file);
   };
   try {
-    for (const route of routes) {
+    for (const { route, routeModule } of runtimeSharedRoutes) {
+      const meta = extractRuntimeSharedMeta(route, routeModule, loadShared);
+      if (meta.input || meta.security || meta.hidden || meta.openapi) {
+        byFile.set(route.file, meta);
+      }
+    }
+    for (const route of remainingRoutes) {
       try {
         const routeModule = loadModule2(route.file);
         const meta = {};
         const input = readInput(routeModule);
         const security = collectSecurity(route, routeModule, loadShared);
-        const hidden = collectHidden(route, routeModule, loadShared);
+        const { hidden, meta: openapi } = resolveOpenApi(route, routeModule, loadShared);
         if (input) {
           meta.input = input;
         }
@@ -1338,7 +1737,10 @@ async function extractRouteMeta(config, paths, routes) {
         if (hidden) {
           meta.hidden = true;
         }
-        if (meta.input || meta.security || meta.hidden) {
+        if (Object.keys(openapi).length > 0) {
+          meta.openapi = openapi;
+        }
+        if (meta.input || meta.security || meta.hidden || meta.openapi) {
           byFile.set(route.file, meta);
         }
       } catch {
@@ -1420,10 +1822,11 @@ async function typeFolders(paths, routes) {
     verbsByDir.set(key, list);
   }
   const dirs = await scanRouteFolders(paths.routesDir);
+  const sharedCache = /* @__PURE__ */ new Map();
   return dirs.map((dir) => ({
     dir,
     params: routeParamsForDir(paths.routesDir, dir),
-    sharedFiles: sharedFilesForDir(paths.routesDir, dir),
+    sharedFiles: sharedFilesForDir(paths.routesDir, dir, sharedCache),
     verbs: verbsByDir.get(slash(dir)) ?? []
   }));
 }
@@ -1436,24 +1839,63 @@ async function extractResponses(paths, routes) {
     const { createSchemaProgram: createSchemaProgram2, extractRouteResponses: extractRouteResponses2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
     const files = [...new Set(routes.map((route) => route.file))];
     const appTypes = (0, import_node_path11.join)(paths.outDir, "types", "app.d.ts");
-    const program = createSchemaProgram2(
-      paths,
-      (0, import_node_fs6.existsSync)(appTypes) ? [...files, appTypes] : files
-    );
+    const roots = (0, import_node_fs7.existsSync)(appTypes) ? [...files, appTypes] : files;
+    const program = createSchemaProgram2(paths, roots, { lean: true });
+    const fallbackFiles = [];
     for (const file of files) {
-      byFile.set(file, extractRouteResponses2(program, file));
+      const responses = extractRouteResponses2(program, file);
+      byFile.set(file, responses);
+      if (hasLooseResponseSchema(responses)) {
+        fallbackFiles.push(file);
+      }
+    }
+    if (fallbackFiles.length > 0) {
+      const fullProgram = createSchemaProgram2(
+        paths,
+        (0, import_node_fs7.existsSync)(appTypes) ? [...fallbackFiles, appTypes] : fallbackFiles
+      );
+      for (const file of fallbackFiles) {
+        byFile.set(file, extractRouteResponses2(fullProgram, file));
+      }
     }
   } catch (error) {
     console.warn(`giri: skipped response schema generation (${error.message}).`);
   }
   return byFile;
 }
+function isLooseSchema(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const schema = value;
+  const keys = Object.keys(schema);
+  if (keys.length === 0) {
+    return true;
+  }
+  if (typeof schema.$ref === "string") {
+    return false;
+  }
+  if (Array.isArray(schema.anyOf) && schema.anyOf.some(isLooseSchema)) {
+    return true;
+  }
+  if (schema.items && isLooseSchema(schema.items)) {
+    return true;
+  }
+  if (schema.properties && typeof schema.properties === "object") {
+    return Object.values(schema.properties).some(isLooseSchema);
+  }
+  return false;
+}
+function hasLooseResponseSchema(responses) {
+  return responses.responses.some((response) => isLooseSchema(response.schema));
+}
 async function extractMeta(config, paths, routes) {
   const inputsByFile = /* @__PURE__ */ new Map();
   const securityByFile = /* @__PURE__ */ new Map();
   const hiddenFiles = /* @__PURE__ */ new Set();
+  const openapiByFile = /* @__PURE__ */ new Map();
   if (routes.length === 0) {
-    return { inputsByFile, securityByFile, hiddenFiles };
+    return { inputsByFile, securityByFile, hiddenFiles, openapiByFile };
   }
   try {
     const meta = await extractRouteMeta(config, paths, routes);
@@ -1467,15 +1909,19 @@ async function extractMeta(config, paths, routes) {
       if (entry.hidden) {
         hiddenFiles.add(file);
       }
+      if (entry.openapi) {
+        openapiByFile.set(file, entry.openapi);
+      }
     }
   } catch (error) {
     console.warn(`giri: skipped input/security generation (${error.message}).`);
   }
-  return { inputsByFile, securityByFile, hiddenFiles };
+  return { inputsByFile, securityByFile, hiddenFiles, openapiByFile };
 }
 async function syncProject(config, options = {}) {
   const paths = resolveGiriPaths(config, options.cwd);
   assertSafeOutDir(paths);
+  const hadOutDir = (0, import_node_fs7.existsSync)(paths.outDir);
   const routes = await scanRoutes(paths.routesDir);
   const folders = await typeFolders(paths, routes);
   await (0, import_promises3.mkdir)(paths.outDir, { recursive: true });
@@ -1484,26 +1930,28 @@ async function syncProject(config, options = {}) {
   await writeAppTypes(paths);
   await writeTsConfig(paths, config);
   const responsesByFile = await extractResponses(paths, routes);
-  const { inputsByFile, securityByFile, hiddenFiles } = await extractMeta(config, paths, routes);
-  const data = { responsesByFile, inputsByFile, securityByFile, hiddenFiles };
+  const { inputsByFile, securityByFile, hiddenFiles, openapiByFile } = await extractMeta(config, paths, routes);
+  const data = { responsesByFile, inputsByFile, securityByFile, hiddenFiles, openapiByFile };
   await writeManifest(paths, routes, data);
   await writeOpenApi(paths, routes, data);
-  await pruneDir(
-    paths.outDir,
-    /* @__PURE__ */ new Set([
-      (0, import_node_path11.join)(paths.outDir, "tsconfig.json"),
-      (0, import_node_path11.join)(paths.outDir, "manifest.json"),
-      (0, import_node_path11.join)(paths.outDir, "openapi.json"),
-      (0, import_node_path11.join)(paths.outDir, "routes.d.ts"),
-      (0, import_node_path11.join)(paths.outDir, "types", "app.d.ts"),
-      ...folders.map((folder) => typeFilePath(paths, folder.dir))
-    ])
-  );
+  if (hadOutDir) {
+    await pruneDir(
+      paths.outDir,
+      /* @__PURE__ */ new Set([
+        (0, import_node_path11.join)(paths.outDir, "tsconfig.json"),
+        (0, import_node_path11.join)(paths.outDir, "manifest.json"),
+        (0, import_node_path11.join)(paths.outDir, "openapi.json"),
+        (0, import_node_path11.join)(paths.outDir, "routes.d.ts"),
+        (0, import_node_path11.join)(paths.outDir, "types", "app.d.ts"),
+        ...folders.map((folder) => typeFilePath(paths, folder.dir))
+      ])
+    );
+  }
   return { paths, routes, folders, data };
 }
 
 // src/generator/watch.ts
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_node_path13 = require("path");
 
 // src/loader/module-loader.ts
@@ -1592,6 +2040,7 @@ function createWatchUpdater(config, initial) {
     data.inputsByFile = result.data.inputsByFile;
     data.securityByFile = result.data.securityByFile;
     data.hiddenFiles = result.data.hiddenFiles;
+    data.openapiByFile = result.data.openapiByFile;
     purgeGeneratedModules(paths.outDir);
     return "full";
   };
@@ -1600,7 +2049,7 @@ function createWatchUpdater(config, initial) {
     try {
       const { createSchemaProgram: createSchemaProgram2, extractRouteResponses: extractRouteResponses2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
       const appTypes = (0, import_node_path13.join)(paths.outDir, "types", "app.d.ts");
-      const program = createSchemaProgram2(paths, (0, import_node_fs7.existsSync)(appTypes) ? [key, appTypes] : [key]);
+      const program = createSchemaProgram2(paths, (0, import_node_fs8.existsSync)(appTypes) ? [key, appTypes] : [key]);
       data.responsesByFile.set(key, extractRouteResponses2(program, key));
     } catch {
     }
@@ -1610,6 +2059,7 @@ function createWatchUpdater(config, initial) {
       data.inputsByFile.delete(key);
       data.securityByFile.delete(key);
       data.hiddenFiles.delete(key);
+      data.openapiByFile.delete(key);
       if (entry?.input) {
         data.inputsByFile.set(key, entry.input);
       }
@@ -1619,6 +2069,9 @@ function createWatchUpdater(config, initial) {
       if (entry?.hidden) {
         data.hiddenFiles.add(key);
       }
+      if (entry?.openapi) {
+        data.openapiByFile.set(key, entry.openapi);
+      }
     } catch {
     }
   };
@@ -1629,10 +2082,10 @@ function createWatchUpdater(config, initial) {
       }
       const abs = (0, import_node_path13.resolve)((0, import_node_path13.dirname)(paths.routesDir), filename);
       const file = slash(abs);
-      if (!(0, import_node_fs7.existsSync)(abs)) {
+      if (!(0, import_node_fs8.existsSync)(abs)) {
         return fullResync();
       }
-      if ((0, import_node_fs7.statSync)(abs).isDirectory()) {
+      if ((0, import_node_fs8.statSync)(abs).isDirectory()) {
         return "skip";
       }
       const graph = buildModuleGraph(paths.cwd);
@@ -1657,13 +2110,13 @@ function createWatchUpdater(config, initial) {
 }
 
 // src/lifecycle.ts
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_path14 = require("path");
 var MAIN_EXTENSIONS2 = ["ts", "tsx", "mts", "cts", "js", "jsx", "mjs", "cjs"];
 function resolveMainFile(cwd) {
   for (const ext of MAIN_EXTENSIONS2) {
     const file = (0, import_node_path14.join)(cwd, "src", `main.${ext}`);
-    if ((0, import_node_fs8.existsSync)(file)) {
+    if ((0, import_node_fs9.existsSync)(file)) {
       return file;
     }
   }
@@ -1830,7 +2283,7 @@ function parseFlags(args) {
 async function ensureGitignore(cwd) {
   const file = (0, import_node_path15.join)(cwd, ".gitignore");
   const entry = ".giri";
-  if (!(0, import_node_fs9.existsSync)(file)) {
+  if (!(0, import_node_fs10.existsSync)(file)) {
     await (0, import_promises4.writeFile)(file, `${entry}
 `);
     return;
@@ -1843,7 +2296,7 @@ async function ensureGitignore(cwd) {
 }
 async function ensureTsConfig(cwd) {
   const file = (0, import_node_path15.join)(cwd, "tsconfig.json");
-  if ((0, import_node_fs9.existsSync)(file)) {
+  if ((0, import_node_fs10.existsSync)(file)) {
     return;
   }
   await (0, import_promises4.writeFile)(
@@ -1941,7 +2394,7 @@ async function selectAdapter(interactive) {
   return ADAPTERS.find((adapter) => adapter.value === picked) ?? null;
 }
 async function initProject(cwd, flags) {
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path15.join)(cwd, "package.json"))) {
+  if (!(0, import_node_fs10.existsSync)((0, import_node_path15.join)(cwd, "package.json"))) {
     throw new Error(
       "No package.json found. Run `giri init` inside an existing project - set one up first (e.g. `npm init -y` and install typescript), then re-run."
     );
@@ -1967,11 +2420,11 @@ async function initProject(cwd, flags) {
     return;
   }
   const configPath = (0, import_node_path15.join)(cwd, "giri.config.ts");
-  if (!(0, import_node_fs9.existsSync)(configPath)) {
+  if (!(0, import_node_fs10.existsSync)(configPath)) {
     await (0, import_promises4.writeFile)(configPath, configSource(adapter));
   }
   const routePath = (0, import_node_path15.join)(cwd, "src", "routes", "+get.ts");
-  if (!(0, import_node_fs9.existsSync)(routePath)) {
+  if (!(0, import_node_fs10.existsSync)(routePath)) {
     await (0, import_promises4.mkdir)((0, import_node_path15.join)(cwd, "src", "routes"), { recursive: true });
     await (0, import_promises4.writeFile)(
       routePath,
@@ -2041,7 +2494,7 @@ function displayHost(address) {
 }
 async function serveProject(config, flags) {
   Error.stackTraceLimit = 30;
-  const { watch } = await import("fs");
+  const { watch } = await import("chokidar");
   let stop;
   const boot = async (cfg) => {
     const initial = await syncProject(cfg);
@@ -2058,7 +2511,7 @@ async function serveProject(config, flags) {
     const hostname = flags.hostname ?? cfg.server?.hostname;
     if (flags.watch) {
       const srcDir = (0, import_node_path15.resolve)(current.paths.routesDir, "..");
-      if ((0, import_node_fs9.existsSync)(srcDir)) {
+      if ((0, import_node_fs10.existsSync)(srcDir)) {
         let timer;
         let syncing = false;
         const changed = /* @__PURE__ */ new Set();
@@ -2078,21 +2531,30 @@ async function serveProject(config, flags) {
             while (changed.size > 0) {
               const batch = [...changed];
               changed.clear();
-              let dirty = false;
+              let rebuild = false;
+              let fullSync = false;
+              const dirtySet = /* @__PURE__ */ new Set();
               for (const name of batch) {
                 const outcome = await updater.apply(name || null);
                 if (outcome === "skip") {
                   continue;
                 }
-                dirty = true;
+                rebuild = true;
+                if (name) {
+                  dirtySet.add((0, import_node_path15.resolve)(srcDir, name));
+                }
                 const rel = name ? `src/${name.replace(/\\/g, "/")}` : "src";
                 log2.change(outcome === "full" ? "sync" : "update", rel, bump(rel));
                 if (outcome === "full") {
+                  fullSync = true;
                   break;
                 }
               }
-              if (dirty) {
-                current = await buildGiriApp(cfg, { services });
+              if (rebuild) {
+                current = await buildGiriApp(cfg, {
+                  services,
+                  dirty: fullSync ? void 0 : dirtySet
+                });
               }
             }
           } catch (error) {
@@ -2104,11 +2566,15 @@ async function serveProject(config, flags) {
             void flush();
           }
         };
-        const watcher = watch(srcDir, { recursive: true }, (_event, filename) => {
-          changed.add(filename ? filename.toString() : "");
+        const watcher = watch(srcDir, { persistent: true });
+        const onFileChange = (filename) => {
+          changed.add(filename);
           clearTimeout(timer);
           timer = setTimeout(() => void flush(), 150);
-        });
+        };
+        watcher.on("change", onFileChange);
+        watcher.on("add", onFileChange);
+        watcher.on("unlink", onFileChange);
         closers.push(() => {
           clearTimeout(timer);
           watcher.close();
@@ -2156,7 +2622,8 @@ async function serveProject(config, flags) {
         restarting = false;
       }
     };
-    watch((0, import_node_path15.dirname)(configPath), { recursive: false }, (_event, filename) => {
+    const configWatcher = watch((0, import_node_path15.dirname)(configPath), { persistent: true });
+    configWatcher.on("all", (_event, filename) => {
       if (filename && (0, import_node_path15.basename)(filename.toString()) === configName) {
         clearTimeout(timer);
         timer = setTimeout(() => void restart(), 150);