@boon4681/giri 0.0.2-alpha-8 → 0.0.3-alpha-1

package/dist/cli.js

@@ -46,13 +46,7 @@ var init_es5 = __esm({
 });
 
 // src/generator/schema/program.ts
-function leanOptions(options) {
-  return {
-    ...options,
-    types: []
-  };
-}
-function createSchemaProgram(paths, routeFiles, programOptions = {}) {
+function createSchemaProgram(paths, routeFiles) {
   let options = { ...DEFAULT_OPTIONS };
   const configPath = import_typescript2.default.findConfigFile(paths.cwd, import_typescript2.default.sys.fileExists, "tsconfig.json");
   if (configPath) {
@@ -65,9 +59,6 @@ function createSchemaProgram(paths, routeFiles, programOptions = {}) {
       options = { ...parsed.options, noEmit: true };
     }
   }
-  if (programOptions.lean) {
-    options = leanOptions(options);
-  }
   return import_typescript2.default.createProgram(routeFiles, options);
 }
 var import_typescript2, DEFAULT_OPTIONS;
@@ -410,9 +401,9 @@ var init_schema = __esm({
 
 // src/cli.ts
 var import_node_child_process = require("child_process");
-var import_node_fs10 = require("fs");
-var import_promises4 = require("fs/promises");
-var import_node_path15 = require("path");
+var import_node_fs12 = require("fs");
+var import_promises5 = require("fs/promises");
+var import_node_path17 = require("path");
 var prompts = __toESM(require("@clack/prompts"));
 
 // src/app.ts
@@ -823,8 +814,11 @@ async function buildGiriApp(config, options = {}) {
   const routes = await scanRoutes(paths.routesDir);
   const app = config.adapter.createApp();
   ensureGiriAliasResolver(paths.outDir);
-  const { unregister } = await safeRegister();
-  const unregisterAliasResolver = registerAliasResolver(config.alias, paths.cwd);
+  if (options.lazy && (!options.loaderRegistered || !options.aliasResolverRegistered)) {
+    throw new Error("Lazy route loading requires persistent loader and alias registrations.");
+  }
+  const loader = options.loaderRegistered ? void 0 : await safeRegister();
+  const unregisterAliasResolver = options.aliasResolverRegistered ? void 0 : registerAliasResolver(config.alias, paths.cwd);
   try {
     const dirty = options.dirty;
     const forceReload = dirty === void 0;
@@ -836,7 +830,7 @@ async function buildGiriApp(config, options = {}) {
       }
       return sharedCache.get(file);
     };
-    for (const route of routes) {
+    const runtimeFor = (route) => {
       const routeModule = loadModule(route.file, isDirty(route.file));
       if (typeof routeModule.handle !== "function") {
         throw new Error(`${route.file} must export a named handle function.`);
@@ -845,7 +839,7 @@ async function buildGiriApp(config, options = {}) {
         (file) => normalizeMiddleware(loadShared(file).middleware, file)
       );
       const verbMiddleware = normalizeMiddleware(routeModule.middleware, route.file);
-      config.adapter.register(app, {
+      return {
         method: route.method,
         path: route.path,
         handle: routeModule.handle,
@@ -853,19 +847,45 @@ async function buildGiriApp(config, options = {}) {
         input: routeInput(routeModule, route.file),
         services: options.services,
         cookieSecret: config.cookieSecret
+      };
+    };
+    for (const route of routes) {
+      if (!options.lazy) {
+        config.adapter.register(app, runtimeFor(route));
+        continue;
+      }
+      let runtime;
+      const getRuntime = () => {
+        runtime ??= runtimeFor(route);
+        return runtime;
+      };
+      config.adapter.register(app, {
+        method: route.method,
+        path: route.path,
+        get handle() {
+          return getRuntime().handle;
+        },
+        get middleware() {
+          return getRuntime().middleware;
+        },
+        get input() {
+          return getRuntime().input;
+        },
+        services: options.services,
+        cookieSecret: config.cookieSecret
       });
     }
   } finally {
-    unregisterAliasResolver();
-    unregister();
+    unregisterAliasResolver?.();
+    loader?.unregister();
   }
   return { app, routes, paths };
 }
 
 // src/generator/sync.ts
-var import_node_fs7 = require("fs");
-var import_promises3 = require("fs/promises");
-var import_node_path11 = require("path");
+var import_node_fs8 = require("fs");
+var import_promises4 = require("fs/promises");
+var import_node_path12 = require("path");
 
 // src/generator/app-types.ts
 var import_node_fs4 = require("fs");
@@ -1812,6 +1832,103 @@ async function writeTsConfig(paths, config) {
   });
 }
 
+// src/generator/cache.ts
+var import_node_crypto = require("crypto");
+var import_node_fs7 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_path11 = require("path");
+var import_tinyglobby2 = require("tinyglobby");
+var CACHE_VERSION = 1;
+var SYNC_CACHE_NAME = ".sync-cache.json";
+function stableConfig(config) {
+  const alias = Object.entries(config.alias ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => [key, Array.isArray(value) ? [...value] : value]);
+  return { alias, outDir: config.outDir ?? ".giri" };
+}
+async function syncFingerprint(config, paths) {
+  const outRelative = slash((0, import_node_path11.relative)(paths.cwd, paths.outDir));
+  const ignore = ["**/node_modules/**", "**/.git/**"];
+  if (outRelative && !outRelative.startsWith("..")) {
+    ignore.push(`${outRelative}/**`);
+  }
+  const files = await (0, import_tinyglobby2.glob)([
+    "src/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,json}",
+    "giri.config.{ts,js,mts,cts,mjs,cjs}",
+    "tsconfig*.json",
+    "package.json",
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "bun.lock",
+    "bun.lockb"
+  ], {
+    cwd: paths.cwd,
+    absolute: false,
+    onlyFiles: true,
+    dot: true,
+    ignore
+  });
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(JSON.stringify(stableConfig(config)));
+  for (const file of files.sort()) {
+    hash.update("\0");
+    hash.update(slash(file));
+    hash.update("\0");
+    hash.update(await (0, import_promises3.readFile)((0, import_node_path11.resolve)(paths.cwd, file)));
+  }
+  return hash.digest("hex");
+}
+function cachePath(paths) {
+  return (0, import_node_path11.join)(paths.outDir, SYNC_CACHE_NAME);
+}
+function serializePath(paths, file) {
+  return slash((0, import_node_path11.relative)(paths.cwd, file));
+}
+function deserializePath(paths, file) {
+  return slash((0, import_node_path11.resolve)(paths.cwd, file.split("/").join(import_node_path11.sep)));
+}
+function serializeMap(paths, values) {
+  return [...values].map(([file, value]) => [serializePath(paths, file), value]);
+}
+function deserializeMap(paths, values) {
+  return new Map(values.map(([file, value]) => [deserializePath(paths, file), value]));
+}
+async function readSyncCache(paths, fingerprint) {
+  const file = cachePath(paths);
+  if (!(0, import_node_fs7.existsSync)(file)) {
+    return void 0;
+  }
+  try {
+    const cache = JSON.parse(await (0, import_promises3.readFile)(file, "utf8"));
+    if (cache.version !== CACHE_VERSION || cache.fingerprint !== fingerprint) {
+      return void 0;
+    }
+    return {
+      responsesByFile: deserializeMap(paths, cache.data.responsesByFile),
+      inputsByFile: deserializeMap(paths, cache.data.inputsByFile),
+      securityByFile: deserializeMap(paths, cache.data.securityByFile),
+      hiddenFiles: new Set(cache.data.hiddenFiles.map((entry) => deserializePath(paths, entry))),
+      openapiByFile: deserializeMap(paths, cache.data.openapiByFile)
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function writeSyncCache(paths, fingerprint, data) {
+  const cache = {
+    version: CACHE_VERSION,
+    fingerprint,
+    data: {
+      responsesByFile: serializeMap(paths, data.responsesByFile),
+      inputsByFile: serializeMap(paths, data.inputsByFile),
+      securityByFile: serializeMap(paths, data.securityByFile),
+      hiddenFiles: [...data.hiddenFiles].map((file) => serializePath(paths, file)),
+      openapiByFile: serializeMap(paths, data.openapiByFile)
+    }
+  };
+  await writeJson(cachePath(paths), cache);
+}
+
 // src/generator/sync.ts
 async function typeFolders(paths, routes) {
   const verbsByDir = /* @__PURE__ */ new Map();
@@ -1838,57 +1955,17 @@ async function extractResponses(paths, routes) {
   try {
     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 roots = (0, import_node_fs7.existsSync)(appTypes) ? [...files, appTypes] : files;
-    const program = createSchemaProgram2(paths, roots, { lean: true });
-    const fallbackFiles = [];
+    const appTypes = (0, import_node_path12.join)(paths.outDir, "types", "app.d.ts");
+    const roots = (0, import_node_fs8.existsSync)(appTypes) ? [...files, appTypes] : files;
+    const program = createSchemaProgram2(paths, roots);
     for (const file of files) {
-      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));
-      }
+      byFile.set(file, extractRouteResponses2(program, 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();
@@ -1921,28 +1998,44 @@ async function extractMeta(config, paths, routes) {
 async function syncProject(config, options = {}) {
   const paths = resolveGiriPaths(config, options.cwd);
   assertSafeOutDir(paths);
-  const hadOutDir = (0, import_node_fs7.existsSync)(paths.outDir);
+  const hadOutDir = (0, import_node_fs8.existsSync)(paths.outDir);
   const routes = await scanRoutes(paths.routesDir);
   const folders = await typeFolders(paths, routes);
-  await (0, import_promises3.mkdir)(paths.outDir, { recursive: true });
+  const fingerprint = await syncFingerprint(config, paths);
+  const cached = await readSyncCache(paths, fingerprint);
+  const generatedFiles = [
+    (0, import_node_path12.join)(paths.outDir, "tsconfig.json"),
+    (0, import_node_path12.join)(paths.outDir, "manifest.json"),
+    (0, import_node_path12.join)(paths.outDir, "openapi.json"),
+    (0, import_node_path12.join)(paths.outDir, "routes.d.ts"),
+    (0, import_node_path12.join)(paths.outDir, "types", "app.d.ts"),
+    ...folders.map((folder) => typeFilePath(paths, folder.dir))
+  ];
+  if (cached && generatedFiles.every(import_node_fs8.existsSync)) {
+    return { paths, routes, folders, data: cached };
+  }
+  await (0, import_promises4.mkdir)(paths.outDir, { recursive: true });
   await writeParamTypes(paths, folders);
   await writeRouteTypes(paths, routes);
   await writeAppTypes(paths);
   await writeTsConfig(paths, config);
-  const responsesByFile = await extractResponses(paths, routes);
-  const { inputsByFile, securityByFile, hiddenFiles, openapiByFile } = await extractMeta(config, paths, routes);
-  const data = { responsesByFile, inputsByFile, securityByFile, hiddenFiles, openapiByFile };
+  const data = cached ?? {
+    responsesByFile: await extractResponses(paths, routes),
+    ...await extractMeta(config, paths, routes)
+  };
   await writeManifest(paths, routes, data);
   await writeOpenApi(paths, routes, data);
+  await writeSyncCache(paths, fingerprint, data);
   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"),
+        (0, import_node_path12.join)(paths.outDir, "tsconfig.json"),
+        (0, import_node_path12.join)(paths.outDir, "manifest.json"),
+        (0, import_node_path12.join)(paths.outDir, "openapi.json"),
+        (0, import_node_path12.join)(paths.outDir, "routes.d.ts"),
+        (0, import_node_path12.join)(paths.outDir, SYNC_CACHE_NAME),
+        (0, import_node_path12.join)(paths.outDir, "types", "app.d.ts"),
         ...folders.map((folder) => typeFilePath(paths, folder.dir))
       ])
     );
@@ -1951,43 +2044,122 @@ async function syncProject(config, options = {}) {
 }
 
 // src/generator/watch.ts
-var import_node_fs8 = require("fs");
-var import_node_path13 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path15 = require("path");
 
-// src/loader/module-loader.ts
-var import_node_path12 = require("path");
-var toSlash = (path) => path.split(import_node_path12.sep).join("/");
-var isProjectModule = (id, root) => {
-  return id.startsWith(root) && !id.includes(`${import_node_path12.sep}node_modules${import_node_path12.sep}`) && !id.includes(`${import_node_path12.sep}.giri${import_node_path12.sep}`);
-};
-var buildModuleGraph = (cwd) => {
-  const root = (0, import_node_path12.resolve)(cwd) + import_node_path12.sep;
+// src/loader/import-graph.ts
+var import_node_fs9 = require("fs");
+var import_node_path13 = require("path");
+var import_typescript5 = __toESM(require("typescript"));
+var import_tinyglobby3 = require("tinyglobby");
+var RESOLVE_EXTS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var JS_EXT = /\.(?:c|m)?jsx?$/;
+var toSlash = (path) => path.split(import_node_path13.sep).join("/");
+function probeFile(base) {
+  if ((0, import_node_fs9.existsSync)(base) && (0, import_node_fs9.statSync)(base).isFile()) {
+    return base;
+  }
+  for (const ext of RESOLVE_EXTS) {
+    const candidate = base + ext;
+    if ((0, import_node_fs9.existsSync)(candidate)) {
+      return candidate;
+    }
+  }
+  for (const ext of RESOLVE_EXTS) {
+    const candidate = (0, import_node_path13.join)(base, `index${ext}`);
+    if ((0, import_node_fs9.existsSync)(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function resolveSpecifier(specifier, fromFile, alias, cwd) {
+  let target;
+  if (specifier.startsWith(".")) {
+    target = (0, import_node_path13.resolve)((0, import_node_path13.dirname)(fromFile), specifier);
+  } else {
+    const aliased = resolveAliasRequest(specifier, alias, cwd);
+    if (aliased === void 0) {
+      return void 0;
+    }
+    target = aliased;
+  }
+  const resolved = probeFile(target);
+  if (resolved) {
+    return resolved;
+  }
+  if (JS_EXT.test(target)) {
+    return probeFile(target.replace(JS_EXT, ""));
+  }
+  return void 0;
+}
+function importSpecifiers(file) {
+  let source;
+  try {
+    source = import_typescript5.default.createSourceFile(file, (0, import_node_fs9.readFileSync)(file, "utf8"), import_typescript5.default.ScriptTarget.Latest, false);
+  } catch {
+    return [];
+  }
+  const specifiers = [];
+  const visit = (node) => {
+    if ((import_typescript5.default.isImportDeclaration(node) || import_typescript5.default.isExportDeclaration(node)) && node.moduleSpecifier && import_typescript5.default.isStringLiteral(node.moduleSpecifier)) {
+      specifiers.push(node.moduleSpecifier.text);
+    } else if (import_typescript5.default.isImportEqualsDeclaration(node) && import_typescript5.default.isExternalModuleReference(node.moduleReference) && import_typescript5.default.isStringLiteralLike(node.moduleReference.expression)) {
+      specifiers.push(node.moduleReference.expression.text);
+    } else if (import_typescript5.default.isCallExpression(node)) {
+      const isRequire = import_typescript5.default.isIdentifier(node.expression) && node.expression.text === "require";
+      const isDynamicImport = node.expression.kind === import_typescript5.default.SyntaxKind.ImportKeyword;
+      const [first] = node.arguments;
+      if ((isRequire || isDynamicImport) && first && import_typescript5.default.isStringLiteralLike(first)) {
+        specifiers.push(first.text);
+      }
+    }
+    import_typescript5.default.forEachChild(node, visit);
+  };
+  visit(source);
+  return specifiers;
+}
+async function buildImportGraph(config, cwd) {
+  const root = (0, import_node_path13.resolve)(cwd);
+  const outDir = (0, import_node_path13.resolve)(root, config.outDir ?? ".giri") + import_node_path13.sep;
+  const outRel = (0, import_node_path13.relative)(root, outDir).split(import_node_path13.sep).join("/").replace(/\/$/, "");
+  const files = await (0, import_tinyglobby3.glob)("**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}", {
+    cwd: root,
+    absolute: true,
+    onlyFiles: true,
+    ignore: ["**/node_modules/**", "**/.git/**", outRel ? `${outRel}/**` : ".giri/**"]
+  });
   const importers = /* @__PURE__ */ new Map();
   const nodes = /* @__PURE__ */ new Set();
-  for (const id of Object.keys(require.cache)) {
-    if (!isProjectModule(id, root)) {
-      continue;
-    }
-    const mod = require.cache[id];
-    if (!mod) {
+  for (const file of files) {
+    if (file.startsWith(outDir)) {
       continue;
     }
-    nodes.add(toSlash(id));
-    for (const child of mod.children) {
-      if (!isProjectModule(child.id, root)) {
+    for (const specifier of importSpecifiers(file)) {
+      const dep = resolveSpecifier(specifier, file, config.alias, root);
+      if (!dep || dep.startsWith(outDir)) {
         continue;
       }
-      nodes.add(toSlash(child.id));
-      const dep = toSlash(child.id);
-      let set = importers.get(dep);
+      const from = toSlash(file);
+      const to = toSlash(dep);
+      nodes.add(from);
+      nodes.add(to);
+      let set = importers.get(to);
       if (!set) {
         set = /* @__PURE__ */ new Set();
-        importers.set(dep, set);
+        importers.set(to, set);
       }
-      set.add(toSlash(id));
+      set.add(from);
     }
   }
   return { importers, nodes };
+}
+
+// src/loader/module-loader.ts
+var import_node_path14 = require("path");
+var toSlash2 = (path) => path.split(import_node_path14.sep).join("/");
+var isProjectModule = (id, root) => {
+  return id.startsWith(root) && !id.includes(`${import_node_path14.sep}node_modules${import_node_path14.sep}`) && !id.includes(`${import_node_path14.sep}.giri${import_node_path14.sep}`);
 };
 var collectDependents = (graph, start) => {
   const out = /* @__PURE__ */ new Set([start]);
@@ -2005,13 +2177,13 @@ var collectDependents = (graph, start) => {
 };
 var purgeModules = (files) => {
   for (const id of Object.keys(require.cache)) {
-    if (files.has(toSlash(id))) {
+    if (files.has(toSlash2(id))) {
       delete require.cache[id];
     }
   }
 };
 var purgeProjectModules = (cwd) => {
-  const root = (0, import_node_path12.resolve)(cwd) + import_node_path12.sep;
+  const root = (0, import_node_path14.resolve)(cwd) + import_node_path14.sep;
   for (const id of Object.keys(require.cache)) {
     if (isProjectModule(id, root)) {
       delete require.cache[id];
@@ -2019,9 +2191,9 @@ var purgeProjectModules = (cwd) => {
   }
 };
 var purgeGeneratedModules = (outDir) => {
-  const root = (0, import_node_path12.resolve)(outDir) + import_node_path12.sep;
+  const root = (0, import_node_path14.resolve)(outDir) + import_node_path14.sep;
   for (const id of Object.keys(require.cache)) {
-    if ((0, import_node_path12.resolve)(id).startsWith(root)) {
+    if ((0, import_node_path14.resolve)(id).startsWith(root)) {
       delete require.cache[id];
     }
   }
@@ -2048,8 +2220,8 @@ function createWatchUpdater(config, initial) {
     const key = route.file;
     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_fs8.existsSync)(appTypes) ? [key, appTypes] : [key]);
+      const appTypes = (0, import_node_path15.join)(paths.outDir, "types", "app.d.ts");
+      const program = createSchemaProgram2(paths, (0, import_node_fs10.existsSync)(appTypes) ? [key, appTypes] : [key]);
       data.responsesByFile.set(key, extractRouteResponses2(program, key));
     } catch {
     }
@@ -2080,15 +2252,15 @@ function createWatchUpdater(config, initial) {
       if (!filename) {
         return fullResync();
       }
-      const abs = (0, import_node_path13.resolve)((0, import_node_path13.dirname)(paths.routesDir), filename);
+      const abs = (0, import_node_path15.resolve)((0, import_node_path15.dirname)(paths.routesDir), filename);
       const file = slash(abs);
-      if (!(0, import_node_fs8.existsSync)(abs)) {
+      if (!(0, import_node_fs10.existsSync)(abs)) {
         return fullResync();
       }
-      if ((0, import_node_fs8.statSync)(abs).isDirectory()) {
+      if ((0, import_node_fs10.statSync)(abs).isDirectory()) {
         return "skip";
       }
-      const graph = buildModuleGraph(paths.cwd);
+      const graph = await buildImportGraph(config, paths.cwd);
       const isRoute = routes.some((candidate) => slash(candidate.file) === file);
       if (!graph.nodes.has(file) && !isRoute) {
         return fullResync();
@@ -2103,6 +2275,7 @@ function createWatchUpdater(config, initial) {
       }
       await writeManifest(paths, routes, data);
       await writeOpenApi(paths, routes, data);
+      await writeSyncCache(paths, await syncFingerprint(config, paths), data);
       purgeGeneratedModules(paths.outDir);
       return "incremental";
     }
@@ -2110,20 +2283,20 @@ function createWatchUpdater(config, initial) {
 }
 
 // src/lifecycle.ts
-var import_node_fs9 = require("fs");
-var import_node_path14 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_path16 = 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_fs9.existsSync)(file)) {
+    const file = (0, import_node_path16.join)(cwd, "src", `main.${ext}`);
+    if ((0, import_node_fs11.existsSync)(file)) {
       return file;
     }
   }
   return void 0;
 }
 async function loadLifecycle(cwd = process.cwd()) {
-  const file = resolveMainFile((0, import_node_path14.resolve)(cwd));
+  const file = resolveMainFile((0, import_node_path16.resolve)(cwd));
   if (!file) {
     return {};
   }
@@ -2281,25 +2454,25 @@ function parseFlags(args) {
   return flags;
 }
 async function ensureGitignore(cwd) {
-  const file = (0, import_node_path15.join)(cwd, ".gitignore");
+  const file = (0, import_node_path17.join)(cwd, ".gitignore");
   const entry = ".giri";
-  if (!(0, import_node_fs10.existsSync)(file)) {
-    await (0, import_promises4.writeFile)(file, `${entry}
+  if (!(0, import_node_fs12.existsSync)(file)) {
+    await (0, import_promises5.writeFile)(file, `${entry}
 `);
     return;
   }
-  const content = await (0, import_promises4.readFile)(file, "utf8");
+  const content = await (0, import_promises5.readFile)(file, "utf8");
   if (!content.split(/\r?\n/).includes(entry)) {
-    await (0, import_promises4.appendFile)(file, `${content.endsWith("\n") ? "" : "\n"}${entry}
+    await (0, import_promises5.appendFile)(file, `${content.endsWith("\n") ? "" : "\n"}${entry}
 `);
   }
 }
 async function ensureTsConfig(cwd) {
-  const file = (0, import_node_path15.join)(cwd, "tsconfig.json");
-  if ((0, import_node_fs10.existsSync)(file)) {
+  const file = (0, import_node_path17.join)(cwd, "tsconfig.json");
+  if ((0, import_node_fs12.existsSync)(file)) {
     return;
   }
-  await (0, import_promises4.writeFile)(
+  await (0, import_promises5.writeFile)(
     file,
     `${JSON.stringify(
       {
@@ -2325,7 +2498,7 @@ async function ensureTsConfig(cwd) {
 async function missingDeps(cwd, candidates) {
   let pkg = {};
   try {
-    pkg = JSON.parse(await (0, import_promises4.readFile)((0, import_node_path15.join)(cwd, "package.json"), "utf8"));
+    pkg = JSON.parse(await (0, import_promises5.readFile)((0, import_node_path17.join)(cwd, "package.json"), "utf8"));
   } catch {
   }
   const present = /* @__PURE__ */ new Set();
@@ -2394,7 +2567,7 @@ async function selectAdapter(interactive) {
   return ADAPTERS.find((adapter) => adapter.value === picked) ?? null;
 }
 async function initProject(cwd, flags) {
-  if (!(0, import_node_fs10.existsSync)((0, import_node_path15.join)(cwd, "package.json"))) {
+  if (!(0, import_node_fs12.existsSync)((0, import_node_path17.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."
     );
@@ -2419,14 +2592,14 @@ async function initProject(cwd, flags) {
     prompts.cancel(`The ${adapter.label} adapter isn't available yet - only Hono ships today.`);
     return;
   }
-  const configPath = (0, import_node_path15.join)(cwd, "giri.config.ts");
-  if (!(0, import_node_fs10.existsSync)(configPath)) {
-    await (0, import_promises4.writeFile)(configPath, configSource(adapter));
+  const configPath = (0, import_node_path17.join)(cwd, "giri.config.ts");
+  if (!(0, import_node_fs12.existsSync)(configPath)) {
+    await (0, import_promises5.writeFile)(configPath, configSource(adapter));
   }
-  const routePath = (0, import_node_path15.join)(cwd, "src", "routes", "+get.ts");
-  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)(
+  const routePath = (0, import_node_path17.join)(cwd, "src", "routes", "+get.ts");
+  if (!(0, import_node_fs12.existsSync)(routePath)) {
+    await (0, import_promises5.mkdir)((0, import_node_path17.join)(cwd, "src", "routes"), { recursive: true });
+    await (0, import_promises5.writeFile)(
       routePath,
       [
         'import type { Handle } from "@boon4681/giri";',
@@ -2497,21 +2670,30 @@ async function serveProject(config, flags) {
   const { watch } = await import("chokidar");
   let stop;
   const boot = async (cfg) => {
-    const initial = await syncProject(cfg);
-    log2.success(
-      `synced ${initial.routes.length} route${initial.routes.length === 1 ? "" : "s"} ${muted(`at ${initial.paths.outDir}`)}`,
-      "sync"
-    );
     const closers = [];
-    closers.push(registerAliasResolver(cfg.alias, initial.paths.cwd));
+    closers.push(registerAliasResolver(cfg.alias, (0, import_node_path17.resolve)(process.cwd())));
     const lifecycle = await loadLifecycle();
-    const services = await runInit(lifecycle);
-    let current = await buildGiriApp(cfg, { services });
+    const sync = syncProject(cfg).then((initial2) => {
+      log2.success(
+        `synced ${initial2.routes.length} route${initial2.routes.length === 1 ? "" : "s"} ${muted(`at ${initial2.paths.outDir}`)}`,
+        "sync"
+      );
+      return initial2;
+    });
+    const [initial, services] = await Promise.all([sync, runInit(lifecycle)]);
+    const loader = await safeRegister();
+    closers.push(loader.unregister);
+    let current = await buildGiriApp(cfg, {
+      services,
+      lazy: true,
+      loaderRegistered: true,
+      aliasResolverRegistered: true
+    });
     const port = flags.port ?? cfg.server?.port ?? 3e3;
     const hostname = flags.hostname ?? cfg.server?.hostname;
     if (flags.watch) {
-      const srcDir = (0, import_node_path15.resolve)(current.paths.routesDir, "..");
-      if ((0, import_node_fs10.existsSync)(srcDir)) {
+      const srcDir = (0, import_node_path17.resolve)(current.paths.routesDir, "..");
+      if ((0, import_node_fs12.existsSync)(srcDir)) {
         let timer;
         let syncing = false;
         const changed = /* @__PURE__ */ new Set();
@@ -2541,7 +2723,7 @@ async function serveProject(config, flags) {
                 }
                 rebuild = true;
                 if (name) {
-                  dirtySet.add((0, import_node_path15.resolve)(srcDir, name));
+                  dirtySet.add((0, import_node_path17.resolve)(srcDir, name));
                 }
                 const rel = name ? `src/${name.replace(/\\/g, "/")}` : "src";
                 log2.change(outcome === "full" ? "sync" : "update", rel, bump(rel));
@@ -2553,7 +2735,10 @@ async function serveProject(config, flags) {
               if (rebuild) {
                 current = await buildGiriApp(cfg, {
                   services,
-                  dirty: fullSync ? void 0 : dirtySet
+                  dirty: fullSync ? void 0 : dirtySet,
+                  lazy: true,
+                  loaderRegistered: true,
+                  aliasResolverRegistered: true
                 });
               }
             }
@@ -2566,9 +2751,9 @@ async function serveProject(config, flags) {
             void flush();
           }
         };
-        const watcher = watch(srcDir, { persistent: true });
+        const watcher = watch(srcDir, { persistent: true, ignoreInitial: true });
         const onFileChange = (filename) => {
-          changed.add(filename);
+          changed.add((0, import_node_path17.isAbsolute)(filename) ? (0, import_node_path17.relative)(srcDir, filename) : filename);
           clearTimeout(timer);
           timer = setTimeout(() => void flush(), 150);
         };
@@ -2599,11 +2784,11 @@ async function serveProject(config, flags) {
     };
   };
   await boot(config);
-  const configPath = flags.watch ? findConfigPath((0, import_node_path15.resolve)(process.cwd())) : void 0;
+  const configPath = flags.watch ? findConfigPath((0, import_node_path17.resolve)(process.cwd())) : void 0;
   if (configPath) {
     let timer;
     let restarting = false;
-    const configName = (0, import_node_path15.basename)(configPath);
+    const configName = (0, import_node_path17.basename)(configPath);
     const restart = async () => {
       if (restarting) {
         return;
@@ -2622,12 +2807,10 @@ async function serveProject(config, flags) {
         restarting = false;
       }
     };
-    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);
-      }
+    const configWatcher = watch(configPath, { persistent: true, ignoreInitial: true });
+    configWatcher.on("all", () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => void restart(), 150);
     });
   }
   registerShutdown(() => stop?.());
@@ -2653,7 +2836,7 @@ function registerShutdown(cleanup) {
 }
 async function main() {
   const [command = "help", ...args] = process.argv.slice(2);
-  const cwd = (0, import_node_path15.resolve)(process.cwd());
+  const cwd = (0, import_node_path17.resolve)(process.cwd());
   if (command === "help" || command === "--help" || command === "-h") {
     help();
     return;