@akanjs/devkit 3.0.0-beta.19 → 3.0.0-beta.20

package/recipeScanner.test.ts

@@ -1,12 +1,11 @@
 import { describe, expect, test } from "bun:test";
-import { mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { writeFile } from "node:fs/promises";
 import path from "node:path";
 import { collectRecipeSources, findInlineRecipeDuplicates, type RecipeInfo, scanRecipes } from "./recipeScanner";
+import { tempDirs } from "./testHelpers";
 
 const byName = (recipes: RecipeInfo[], name: string) => recipes.find((recipe) => recipe.name === name);
 
-// Mirrors pkgs/akanjs/ui/recipe/ (framework) — two recipes in one source, variant + size surfaces.
 // The scanner is per-source, so a folder of one-recipe files and a legacy multi-recipe file both parse.
 const FRAMEWORK = `
 import { recipe, tv } from "./recipeFactory";
@@ -24,7 +23,6 @@ export type ButtonVariants = NonNullable<Parameters<typeof buttonRecipe>[0]>;
 export const badgeRecipe = recipe(tv({ base: "rounded-full", variants: { variant: { default: "bg-muted", info: "bg-info" } } }));
 `;
 
-// Mirrors apps/minimal/ui/Recipe/ shapes — base-only (no variants) + single-variant, with per-export JSDoc.
 const APP = `
 import { recipe, tv } from "akanjs/ui";
 /** 전체 화면 배경/전경. 페이지 루트 컨테이너. */
@@ -97,12 +95,7 @@ describe("scanRecipes", () => {
   });
 });
 
-// Recipes moved from a flat `ui/Recipe.ts` to a `ui/Recipe/` folder. Three consumers (the AGENTS.md recipe
-// index, the recipeGate lint, the MCP module context) go through collectRecipeSources, and every one of them
-// degrades silently — empty list, no error — if it stops finding sources. These tests are that alarm.
-// The advisory exists to catch a look being re-authored inline. Requiring every base token only matched a
-// verbatim copy of the whole base — the one shape that never occurs in practice — so it reported nothing on
-// the near-copies it was built for, and silently, being advisory. These tests pin the ratio behaviour.
+// Requiring every base token matched only a verbatim copy, which never occurs; these tests pin the ratio instead.
 describe("findInlineRecipeDuplicates", () => {
   // 8 tokens → ceil(8 * 0.7) = 6 must be reproduced.
   const EIGHT = `export const cardRecipe = recipe(tv({ base: "flex rounded-box border border-border bg-card p-4 text-card-foreground shadow-sm" }));`;
@@ -135,9 +128,11 @@ describe("findInlineRecipeDuplicates", () => {
   });
 });
 
+// The AGENTS.md index, the recipeGate lint and the MCP module context all degrade silently if this finds nothing.
 describe("collectRecipeSources", () => {
+  const makeTempRoot = tempDirs("akan-recipe-");
   const seed = async (files: Record<string, string>) => {
-    const root = await mkdtemp(path.join(tmpdir(), "akan-recipe-"));
+    const root = await makeTempRoot();
     for (const [rel, content] of Object.entries(files)) {
       const abs = path.join(root, rel);
       await Bun.write(abs, content);
@@ -176,7 +171,7 @@ describe("collectRecipeSources", () => {
   });
 
   test("returns nothing when neither shape exists, without throwing", async () => {
-    const root = await mkdtemp(path.join(tmpdir(), "akan-recipe-"));
+    const root = await makeTempRoot();
     await writeFile(path.join(root, "placeholder"), "");
     expect(await collectRecipeSources(path.join(root, "ui"), "@apps/x/ui")).toEqual([]);
   });

package/recipeScanner.ts

@@ -1,11 +1,7 @@
 import { readdir } from "node:fs/promises";
 import ts from "typescript";
 
-/**
- * A single Akan UI recipe discovered by scanning source. `variants` maps each variant key to its allowed option
- * names (e.g. `{ variant: ["primary", "ghost"], size: ["sm", "md"] }`); a base-only recipe has `variants: {}`.
- * `importFrom` is the module a consumer imports the recipe from (e.g. `@apps/minimal/ui`).
- */
+/** `variants` maps each key to its option names (`{}` for a base-only recipe); `importFrom` is the consumer's module. */
 export interface RecipeInfo {
   name: string;
   importFrom: string;
@@ -22,13 +18,8 @@ export interface RecipeSource {
   importFrom: string;
 }
 
-/**
- * Collects every recipe source under a `ui` folder. Recipes live one-per-file in a `Recipe/` folder
- * (`recipe/` for the framework), so this reads the whole folder; the flat `Recipe.ts` is still read for
- * apps that have not moved yet. Every consumer of `scanRecipes` must go through here — three call sites
- * (AGENTS.md recipe index, `recipeGate` lint, MCP module context) hardcoded the flat path before, and each
- * one fails silently (empty list, no error) when the file is absent.
- */
+// One recipe per file under `Recipe/` (`recipe/` for the framework), plus the legacy flat `Recipe.ts`. Every
+// `scanRecipes` consumer goes through here: a hardcoded path fails silently (an empty list) when the file is absent.
 export const collectRecipeSources = async (
   uiDirPath: string,
   importFrom: string,
@@ -51,12 +42,8 @@ export const collectRecipeSources = async (
   return [flat, ...fromDir].filter((source): source is RecipeSource => !!source);
 };
 
-/**
- * Statically finds every `export const <name> = recipe(tv({ ... }))` across the given sources and extracts its
- * variant surface + leading JSDoc one-liner. Detection is by the `recipe(tv(...))` call shape (not by name suffix,
- * since base-only recipes like `appScreen` omit the `Recipe` suffix). Being AST-based, it never matches recipe
- * definitions that appear only inside string/template literals (e.g. code examples in docs pages).
- */
+// Detected by the `recipe(tv(...))` call shape, not the name suffix (base-only recipes like `appScreen` omit it);
+// AST-based, so code examples inside string literals never match.
 export const scanRecipes = (sources: RecipeSource[]): RecipeInfo[] => {
   const recipes: RecipeInfo[] = [];
   for (const source of sources) {
@@ -73,12 +60,13 @@ export const scanRecipes = (sources: RecipeSource[]): RecipeInfo[] => {
         if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
         const parsed = parseRecipeCall(declaration.initializer);
         if (!parsed) continue;
+        const doc = getLeadingDoc(source.content, statement);
         recipes.push({
           name: declaration.name.text,
           importFrom: source.importFrom,
           variants: parsed.variants,
           ...(parsed.defaultVariants ? { defaultVariants: parsed.defaultVariants } : {}),
-          ...(getLeadingDoc(source.content, statement) ? { doc: getLeadingDoc(source.content, statement) } : {}),
+          ...(doc ? { doc } : {}),
           ...(parsed.base ? { base: parsed.base } : {}),
         });
       }
@@ -90,7 +78,6 @@ export const scanRecipes = (sources: RecipeSource[]): RecipeInfo[] => {
 const isExported = (statement: ts.VariableStatement): boolean =>
   statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
 
-/** Matches `recipe( tv( <ObjectLiteral> ) )` and returns the variant surface, or null for anything else. */
 const parseRecipeCall = (
   initializer: ts.Expression,
 ): { variants: Record<string, string[]>; defaultVariants?: Record<string, string>; base?: string } | null => {
@@ -148,27 +135,12 @@ export interface RecipeDuplicate {
   className: string;
 }
 
-/**
- * Fraction of a recipe's base tokens an inline className must reproduce to count as a duplicate.
- *
- * Requiring *every* token (the original rule) only caught a verbatim copy of the whole base, which is the one
- * form of duplication that essentially never happens: someone re-authoring a look reproduces the gist, not all
- * eight tokens. So the check passed on exactly the near-duplicates it existed to find, and silently — it is an
- * advisory, so nothing went red. A ratio catches those; false positives are cheap here for the same reason.
- */
+// A re-authored look reproduces the gist, not every token, so a ratio (not all tokens) catches near-duplicates.
 const DUPLICATE_TOKEN_RATIO = 0.7;
 
-/** Minimum base tokens for a recipe to be worth fingerprinting at all. */
 const MIN_FINGERPRINT_TOKENS = 3;
 
-/**
- * SSOT advisory: finds JSX `className` string values that hand-rewrite a recipe's base fingerprint instead of
- * consuming the recipe. Only recipes whose base has 3+ distinctive tokens are checked — shorter fingerprints
- * (`grid gap-3` …) are generic utilities and would flood the report with false positives. A className counts as
- * a duplicate once it reproduces {@link DUPLICATE_TOKEN_RATIO} of those tokens, so a near-copy that drops or
- * swaps one still reports. AST-scoped to real `className` attributes, so class strings inside doc-example
- * template literals never match.
- */
+// Shorter fingerprints (`grid gap-3`) are generic utilities that would flood the report with false positives.
 export const findInlineRecipeDuplicates = (
   recipes: RecipeInfo[],
   files: { path: string; content: string }[],
@@ -219,7 +191,6 @@ const stringValuesIn = (node: ts.Node): string[] => {
   return values;
 };
 
-/** The first non-empty line of the JSDoc/line comment immediately preceding the statement, markers stripped. */
 const getLeadingDoc = (fullText: string, node: ts.Node): string | undefined => {
   const ranges = ts.getLeadingCommentRanges(fullText, node.getFullStart());
   if (!ranges?.length) return undefined;

package/repoIdentity.ts

@@ -24,15 +24,8 @@ const readRemoteName = (workspaceRoot: string): string | null => {
   }
 };
 
-/**
- * The repository's own name.
- *
- * Deriving it from the working directory made every generated file that names the repo — the AGENTS.md title, its
- * `- Repo:` line — depend on what each person happened to call the folder they cloned into, so one commit rendered
- * a different guide per developer and the diff never settled. The origin remote is the one identity every clone
- * shares. `AKAN_PUBLIC_REPO_NAME` is deliberately not consulted: that is a deployment namespace (queue prefixes,
- * cache keys, secret paths) which a monorepo hosting several products legitimately points somewhere else.
- */
+// The origin remote, not the clone's folder name, so generated files agree across clones. `AKAN_PUBLIC_REPO_NAME` is a
+// deployment namespace (queue prefixes, cache keys) and deliberately not consulted.
 export const resolveRepoName = (workspaceRoot: string): string => {
   const cached = resolved.get(workspaceRoot);
   if (cached) return cached;

package/routeSourceValidator.ts

@@ -24,15 +24,8 @@ interface ChainStage {
 
 const chainRoots = new Set(["page", "layout", "rootLayout"]);
 
-/**
- * Static enforcement of the `page/` route conventions, split out of `executors.ts` so that importing
- * an executor does not pull `typescript` (+65MB resident) into the module graph. Both validators need
- * a real AST — modifier inspection, `export *` rejection, statement-kind walking and call-expression
- * identity — so `Bun.Transpiler.scan()`, which only reports export names, cannot replace them.
- *
- * Import it dynamically (`await import("./routeSourceValidator")`) so long-lived processes that never
- * validate a route source stay lean.
- */
+// Import dynamically: it pulls in `typescript` (+65MB resident). `Bun.Transpiler.scan()` reports only export names,
+// too little for these checks.
 export class RouteSourceValidator {
   static validateRouteSourceExports(
     source: string,
@@ -104,12 +97,7 @@ export class RouteSourceValidator {
     };
   }
 
-  /**
-   * The default export as a `page()` / `layout()` / `rootLayout()` chain, or null when the module is the legacy
-   * shape. Read off the source for the same reason `devOnly` is: the build enumerates routes without importing
-   * them, and `akan sync` should name a `[projectId]` folder whose page declares no `.param("projectId")` before
-   * the first request does.
-   */
+  // Null for the legacy shape. Read off the source because the build enumerates routes without importing them.
   static #readChain(sourceFile: ts.SourceFile, filePath: string) {
     for (const statement of sourceFile.statements) {
       if (!ts.isExportAssignment(statement) || statement.isExportEquals) continue;
@@ -173,12 +161,8 @@ export class RouteSourceValidator {
       );
   }
 
-  /**
-   * `devOnly` decides whether the route exists in the production build at all, so it is read from the
-   * source rather than from an evaluated module — the build never imports route files to enumerate them.
-   * That is why only a literal is accepted: anything the parser cannot settle would otherwise ship a
-   * route the author believed was excluded.
-   */
+  // Only a literal is accepted: the build reads it without importing the route, and a value the parser cannot settle
+  // would ship a route its author believed excluded.
   static #readDevOnly(sourceFile: ts.SourceFile, filePath: string): boolean {
     for (const statement of sourceFile.statements) {
       if (!ts.isVariableStatement(statement)) continue;
@@ -222,13 +206,7 @@ export class RouteSourceValidator {
     return current;
   }
 
-  /**
-   * Statically enforces that a `_overrides.tsx` route file is a logic-free activation manifest: a plain module
-   * (no `"use client"` — the framework generates the client wrapper) that only imports components and binds them
-   * to slots through a single `export default override({ Modal: BrandModal })`. It must not declare components
-   * inline or run logic — that keeps the override contract a thin binding layer rather than a second place to
-   * author UI. Slot names and value types are validated at compile time by `override`.
-   */
+  // A logic-free manifest: imports plus one `export default override({ ... })`; `override` types the slots.
   static validateOverridesSourceExports(source: string, filePath: string) {
     const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
     const fail = (message: string): never => {
@@ -236,9 +214,8 @@ export class RouteSourceValidator {
     };
     let defaultOverride: ts.ExportAssignment | null = null;
     for (const statement of sourceFile.statements) {
-      // A "use client" directive is unnecessary (the framework wraps the manifest) but harmless if present.
+      //? A "use client" directive is unnecessary (the framework wraps the manifest) but harmless.
       if (ts.isExpressionStatement(statement) && ts.isStringLiteral(statement.expression)) continue;
-      // The manifest imports the app components it binds; imports and type-only decls carry no runtime logic.
       if (ts.isImportDeclaration(statement)) continue;
       if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) continue;
       if (ts.isExportAssignment(statement) && !statement.isExportEquals) {

package/scanInfo.ts

@@ -27,20 +27,13 @@ const serviceFileTypes = [
   "zone",
 ] as const;
 type ServiceFileType = (typeof serviceFileTypes)[number];
-const databaseFileTypes = [
-  "constant",
-  "dictionary",
-  "document",
-  "service",
-  "signal",
-  "store",
-  "template",
-  "unit",
-  "util",
-  "view",
-  "zone",
-] as const;
+const databaseFileTypes = ["constant", "dictionary", "document", ...serviceFileTypes.slice(1)] as const;
 type DatabaseFileType = (typeof databaseFileTypes)[number];
+const uiFileTypes = new Set<DatabaseFileType>(["template", "unit", "util", "view", "zone"]);
+const fileTypeOf = (filename: string) =>
+  databaseFileTypes.find((type) =>
+    filename.endsWith(uiFileTypes.has(type) ? `.${type[0].toUpperCase()}${type.slice(1)}.tsx` : `.${type}.ts`),
+  );
 
 type ModuleKind = "database" | "service" | "scalar";
 
@@ -56,14 +49,11 @@ const moduleUiFileTypes = {
   service: new Set(["Util", "Zone"]),
   scalar: new Set(["Template", "Unit"]),
 } satisfies Record<ModuleKind, Set<string>>;
-const testFilePattern = /\.(test|spec)\.(ts|tsx)$/;
 
-// The dependency scanner needs `typescript` (~65MB resident). Only the scan/sync commands run it, so
-// load it on demand rather than through the module graph of every process that imports scan info.
+// Lazy: the dependency scanner pulls in `typescript` (~65MB resident), which only scan and sync need.
 const createDependencyScanner = async (exec: AppExecutor | LibExecutor | PkgExecutor) =>
   (await import("./dependencyScanner")).TypeScriptDependencyScanner.from(exec);
 
-const isAllowedTestFile = (filename: string) => testFilePattern.test(filename);
 const getScanPath = (exec: AppExecutor | LibExecutor, relativePath: string) =>
   path.posix.join(`${exec.type}s`, exec.name, relativePath.split(path.sep).join("/"));
 async function clearGeneratedRootCapacitorConfigs(exec: AppExecutor | LibExecutor) {
@@ -85,33 +75,21 @@ async function assertScanConvention(exec: AppExecutor | LibExecutor, libRoot: {
   const allowedRootFiles: ReadonlySet<string> = rootAllowedFiles[exec.type];
   const allowedRootDirs: ReadonlySet<string> = rootAllowedDirs[exec.type];
   const { files, dirs } = await exec.getFilesAndDirs(".");
-  files
-    .filter((filename) => !allowedRootFiles.has(filename))
-    .forEach((filename) => {
-      addViolation(filename, `unsupported ${exec.type} root file`);
-    });
-  dirs
-    .filter((dirname) => !allowedRootDirs.has(dirname))
-    .forEach((dirname) => {
-      addViolation(dirname, `unsupported ${exec.type} root folder`);
-    });
+  for (const filename of files)
+    if (!allowedRootFiles.has(filename)) addViolation(filename, `unsupported ${exec.type} root file`);
+  for (const dirname of dirs)
+    if (!allowedRootDirs.has(dirname)) addViolation(dirname, `unsupported ${exec.type} root folder`);
 
-  //* An app validates its page tree in `getPageKeys`, which a lib has no equivalent of — so a lib's own
-  //* routes went unchecked until whichever app opted into them with `syncPageLibs` blew up on the sync.
+  //* A lib has no `getPageKeys`, so its own route files are validated here.
   if (exec.type === "lib")
     for (const { relativePath, reason } of await exec.getPageConventionViolations()) addViolation(relativePath, reason);
 
-  libRoot.files
-    .filter((filename) => !isAllowedLibFacetRootFile(filename))
-    .forEach((filename) => {
+  for (const filename of libRoot.files)
+    if (!isAllowedLibFacetRootFile(filename))
       addViolation(path.join("lib", filename), "unsupported lib facet root file");
-    });
-
-  libRoot.dirs
-    .filter((dirname) => dirname.startsWith("__") && !internalLibDirs.has(dirname))
-    .forEach((dirname) => {
+  for (const dirname of libRoot.dirs)
+    if (dirname.startsWith("__") && !internalLibDirs.has(dirname))
       addViolation(path.join("lib", dirname), "unsupported internal lib folder");
-    });
 
   const databaseDirs = libRoot.dirs.filter((dirname) => !dirname.startsWith("_"));
   const serviceDirs = libRoot.dirs.filter((dirname) => dirname.startsWith("_") && !dirname.startsWith("__"));
@@ -146,43 +124,23 @@ async function validateModuleFiles(
 
   const uiModuleName = moduleName[0].toUpperCase() + moduleName.slice(1);
 
-  files.forEach((filename) => {
-    const filePath = path.join(modulePath, filename);
-    if (filename === "index.ts" || filename === "index.tsx" || isAllowedTestFile(filename)) return;
-    if (filename === `${moduleName}.abstract.md`) return;
-
+  for (const filename of files) {
+    const scanPath = getScanPath(exec, path.join(modulePath, filename));
+    if (filename === "index.ts" || filename === "index.tsx" || /\.(test|spec)\.(ts|tsx)$/.test(filename)) continue;
+    if (filename === `${moduleName}.abstract.md`) continue;
     const uiMatch = filename.match(/^([A-Z][A-Za-z0-9]+)\.([A-Z][A-Za-z0-9]*)\.tsx$/);
-    if (uiMatch) {
-      const fileModuleName = uiMatch[1];
-      const fileType = uiMatch[2];
-      if (fileModuleName !== uiModuleName) {
-        violations.push(
-          `${getScanPath(exec, filePath)}: module name mismatch: expected '${uiModuleName}', got '${fileModuleName}'`,
-        );
-      }
-      if (!moduleUiFileTypes[kind].has(fileType)) {
-        violations.push(`${getScanPath(exec, filePath)}: unsupported ${kind} UI file`);
-      }
-      return;
-    }
-
-    const nonUiMatch = filename.match(/^([a-z][a-zA-Z0-9]*)\.([a-z][a-z0-9]*)\.ts$/);
-    if (nonUiMatch) {
-      const fileModuleName = nonUiMatch[1];
-      const fileType = nonUiMatch[2];
-      if (fileModuleName !== moduleName) {
-        violations.push(
-          `${getScanPath(exec, filePath)}: module name mismatch: expected '${moduleName}', got '${fileModuleName}'`,
-        );
-      }
-      if (!moduleNonUiFileTypes[kind].has(fileType)) {
-        violations.push(`${getScanPath(exec, filePath)}: unsupported ${kind} file`);
-      }
-      return;
+    const match = uiMatch ?? filename.match(/^([a-z][a-zA-Z0-9]*)\.([a-z][a-z0-9]*)\.ts$/);
+    if (!match) {
+      violations.push(`${scanPath}: unsupported module file`);
+      continue;
     }
-
-    violations.push(`${getScanPath(exec, filePath)}: unsupported module file`);
-  });
+    const [, fileModuleName, fileType] = match;
+    const expectedName = uiMatch ? uiModuleName : moduleName;
+    if (fileModuleName !== expectedName)
+      violations.push(`${scanPath}: module name mismatch: expected '${expectedName}', got '${fileModuleName}'`);
+    if (!(uiMatch ? moduleUiFileTypes : moduleNonUiFileTypes)[kind].has(fileType))
+      violations.push(`${scanPath}: unsupported ${kind}${uiMatch ? " UI" : ""} file`);
+  }
 }
 
 class ScanInfo {
@@ -239,51 +197,16 @@ class ScanInfo {
       } else databaseDirs.push(name);
     });
 
+    const collect = async (dir: string, name: string, kind: "databases" | "services" | "scalars") => {
+      for (const filename of await exec.readdir(dir)) {
+        const type = fileTypeOf(filename);
+        if (type) (files[type] as { [key in typeof kind]?: string[] })[kind]?.push(name);
+      }
+    };
     await Promise.all([
-      ...databaseDirs.map(async (name) => {
-        const filenames = await exec.readdir(path.join("lib", name));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".constant.ts")) files.constant.databases.push(name);
-          else if (filename.endsWith(".dictionary.ts")) files.dictionary.databases.push(name);
-          else if (filename.endsWith(".document.ts")) files.document.databases.push(name);
-          else if (filename.endsWith(".service.ts")) files.service.databases.push(name);
-          else if (filename.endsWith(".signal.ts")) files.signal.databases.push(name);
-          else if (filename.endsWith(".store.ts")) files.store.databases.push(name);
-          else if (filename.endsWith(".Template.tsx")) files.template.databases.push(name);
-          else if (filename.endsWith(".Unit.tsx")) files.unit.databases.push(name);
-          else if (filename.endsWith(".Util.tsx")) files.util.databases.push(name);
-          else if (filename.endsWith(".View.tsx")) files.view.databases.push(name);
-          else if (filename.endsWith(".Zone.tsx")) files.zone.databases.push(name);
-        });
-      }),
-      ...serviceDirs.map(async (dirname) => {
-        const name = dirname.slice(1);
-        const filenames = await exec.readdir(path.join("lib", dirname));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".dictionary.ts")) files.dictionary.services.push(name);
-          else if (filename.endsWith(".service.ts")) files.service.services.push(name);
-          else if (filename.endsWith(".signal.ts")) files.signal.services.push(name);
-          else if (filename.endsWith(".store.ts")) files.store.services.push(name);
-          else if (filename.endsWith(".Template.tsx")) files.template.services.push(name);
-          else if (filename.endsWith(".Unit.tsx")) files.unit.services.push(name);
-          else if (filename.endsWith(".Util.tsx")) files.util.services.push(name);
-          else if (filename.endsWith(".View.tsx")) files.view.services.push(name);
-          else if (filename.endsWith(".Zone.tsx")) files.zone.services.push(name);
-        });
-      }),
-      ...scalarDirs.map(async (name) => {
-        const filenames = await exec.readdir(path.join("lib/__scalar", name));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".constant.ts")) files.constant.scalars.push(name);
-          else if (filename.endsWith(".dictionary.ts")) files.dictionary.scalars.push(name);
-          else if (filename.endsWith(".document.ts")) files.document.scalars.push(name);
-          else if (filename.endsWith(".Template.tsx")) files.template.scalars.push(name);
-          else if (filename.endsWith(".Unit.tsx")) files.unit.scalars.push(name);
-          else if (filename.endsWith(".Util.tsx")) files.util.scalars.push(name);
-          else if (filename.endsWith(".View.tsx")) files.view.scalars.push(name);
-          else if (filename.endsWith(".Zone.tsx")) files.zone.scalars.push(name);
-        });
-      }),
+      ...databaseDirs.map((name) => collect(path.join("lib", name), name, "databases")),
+      ...serviceDirs.map((dirname) => collect(path.join("lib", dirname), dirname.slice(1), "services")),
+      ...scalarDirs.map((name) => collect(path.join("lib/__scalar", name), name, "scalars")),
     ]);
     const routes = exec.type === "lib" ? [] : await (exec as AppExecutor).getPageKeys();
     const common = {
@@ -309,35 +232,16 @@ class ScanInfo {
   constructor(scanResult: ScanResult) {
     this.name = scanResult.name;
     this.scanResult = scanResult;
-    Object.entries(scanResult.files).forEach(([_key, value]) => {
-      const key = _key as DatabaseFileType;
-      const { databases, services, scalars } = value as {
-        databases: string[];
-        services?: string[];
-        scalars?: string[];
-      };
-      databases.forEach((modelName) => {
-        const model = this.database.get(modelName) ?? new Set<DatabaseFileType>();
-        model.add(key);
-        this.database.set(modelName, model);
-        this.file[key].all.add(modelName);
-        this.file[key].databases.add(modelName);
-      });
-      services?.forEach((serviceName) => {
-        const service = this.service.get(serviceName) ?? new Set<ServiceFileType>();
-        service.add(key as ServiceFileType);
-        this.service.set(serviceName, service);
-        this.file[key].all.add(serviceName);
-        this.file[key].services.add(serviceName);
-      });
-      scalars?.forEach((scalarName) => {
-        const scalar = this.scalar.get(scalarName) ?? new Set<ScalarFileType>();
-        scalar.add(key as ScalarFileType);
-        this.scalar.set(scalarName, scalar);
-        this.file[key].all.add(scalarName);
-        this.file[key].scalars.add(scalarName);
-      });
-    });
+    const modulesOf = { databases: this.database, services: this.service, scalars: this.scalar } as {
+      [key in "databases" | "services" | "scalars"]: Map<string, Set<DatabaseFileType>>;
+    };
+    for (const [key, groups] of Object.entries(scanResult.files) as [DatabaseFileType, { [kind: string]: string[] }][])
+      for (const kind of ["databases", "services", "scalars"] as const)
+        for (const name of groups[kind] ?? []) {
+          modulesOf[kind].set(name, (modulesOf[kind].get(name) ?? new Set()).add(key));
+          this.file[key].all.add(name);
+          this.file[key][kind].add(name);
+        }
   }
   getScanResult() {
     return this.scanResult;
@@ -351,6 +255,29 @@ class ScanInfo {
   getScalarModules() {
     return [...this.scalar.keys()];
   }
+
+  #sortedLibs: string[] | null = null;
+  protected sortedLibs(libDeps: string[]) {
+    if (this.#sortedLibs) return this.#sortedLibs;
+    const libIndices = LibInfo.getSortedLibIndices();
+    this.#sortedLibs = libDeps.sort((libNameA, libNameB) => {
+      const indexA = libIndices.get(libNameA);
+      const indexB = libIndices.get(libNameB);
+      if (indexA === undefined || indexB === undefined)
+        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
+      return indexA - indexB;
+    });
+    return this.#sortedLibs;
+  }
+  protected sortedLibInfos(libDeps: string[]) {
+    return new Map(
+      this.sortedLibs(libDeps).map((libName) => {
+        const libInfo = LibInfo.libInfos.get(libName);
+        if (!libInfo) throw new Error(`LibInfo not found: ${libName}`);
+        return [libName, libInfo];
+      }),
+    );
+  }
 }
 
 const isAkanFrameworkDependency = (dep: string) => dep === "akanjs" || dep.startsWith("akanjs/");
@@ -362,7 +289,6 @@ export class AppInfo extends ScanInfo {
 
   static appInfos = new Map<string, AppInfo>();
   static async fromExecutor(exec: AppExecutor, options: { refresh?: boolean } = {}) {
-    // cache check
     const existingAppInfo = AppInfo.appInfos.get(exec.name);
     if (existingAppInfo && !options.refresh) return existingAppInfo;
     const scanResult = await ScanInfo.getScanResult(exec);
@@ -408,30 +334,11 @@ export class AppInfo extends ScanInfo {
     return [...libSet];
   }
 
-  #sortedLibs: string[] | null = null;
-  #getSortedLibs() {
-    if (this.#sortedLibs) return this.#sortedLibs;
-    const libIndices = LibInfo.getSortedLibIndices();
-    this.#sortedLibs = this.libDeps.sort((libNameA, libNameB) => {
-      const indexA = libIndices.get(libNameA);
-      const indexB = libIndices.get(libNameB);
-      if (indexA === undefined || indexB === undefined)
-        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
-      return indexA - indexB;
-    });
-    return this.#sortedLibs;
-  }
   getLibs() {
-    return this.#getSortedLibs();
+    return this.sortedLibs(this.libDeps);
   }
   getLibInfos() {
-    return new Map(
-      this.#getSortedLibs().map((libName) => {
-        const libInfo = LibInfo.libInfos.get(libName);
-        if (!libInfo) throw new Error(`LibInfo not found: ${libName}`);
-        return [libName, libInfo];
-      }),
-    );
+    return this.sortedLibInfos(this.libDeps);
   }
 }
 export class LibInfo extends ScanInfo {
@@ -482,36 +389,16 @@ export class LibInfo extends ScanInfo {
     return this.scanResult as LibScanResult;
   }
 
-  #sortedLibs: string[] | null = null;
-  #getSortedLibs() {
-    if (this.#sortedLibs) return this.#sortedLibs;
-    const libs = LibInfo.getSortedLibIndices();
-    this.#sortedLibs = this.scanResult.libDeps.sort((libNameA, libNameB) => {
-      const indexA = libs.get(libNameA);
-      const indexB = libs.get(libNameB);
-      if (indexA === undefined || indexB === undefined)
-        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
-      return indexA - indexB;
-    });
-    return this.#sortedLibs;
-  }
   getLibs() {
-    return this.#getSortedLibs();
+    return this.sortedLibs(this.scanResult.libDeps);
   }
   getLibInfo(libName: string) {
     if (!this.getScanResult().libDeps.includes(libName)) return undefined;
-    const libSet = new Set(this.#getSortedLibs());
-    if (!libSet.has(libName)) throw new Error(`LibInfo is invalid: ${libName}`);
+    if (!this.getLibs().includes(libName)) throw new Error(`LibInfo is invalid: ${libName}`);
     return LibInfo.libInfos.get(libName);
   }
   getLibInfos() {
-    return new Map(
-      this.#getSortedLibs().map((libName) => {
-        const libInfo = LibInfo.libInfos.get(libName);
-        if (!libInfo) throw new Error(`LibInfo not found: ${libName}`);
-        return [libName, libInfo];
-      }),
-    );
+    return this.sortedLibInfos(this.scanResult.libDeps);
   }
 }
 
@@ -542,12 +429,7 @@ export class PkgInfo {
           .join("/");
       })
       .filter((pkg) => pkg !== exec.name);
-    const pkgScanResult = {
-      name: exec.name,
-      pkgDeps,
-      dependencies: [...npmDepSet],
-    };
-    return pkgScanResult;
+    return { name: exec.name, pkgDeps, dependencies: [...npmDepSet] };
   }
 
   static #pkgInfos = new Map<string, PkgInfo>();
@@ -585,23 +467,9 @@ export class WorkspaceInfo {
     const [appNames, libNames, pkgNames] = await Promise.all([exec.getApps(), exec.getLibs(), exec.getPkgs()]);
     // TODO: prevent duplicate scan by resolving the dependency graph
     const [appInfos, libInfos, pkgInfos] = await Promise.all([
-      Promise.all(
-        appNames.map(async (appName) => {
-          const app = AppExecutor.from(exec, appName);
-          return await app.scan();
-        }),
-      ),
-      Promise.all(
-        libNames.map(async (libName) => {
-          const lib = LibExecutor.from(exec, libName);
-          return await lib.scan();
-        }),
-      ),
-      Promise.all(
-        pkgNames.map(async (pkgName) => {
-          return await PkgExecutor.from(exec, pkgName).scan();
-        }),
-      ),
+      Promise.all(appNames.map(async (appName) => await AppExecutor.from(exec, appName).scan())),
+      Promise.all(libNames.map(async (libName) => await LibExecutor.from(exec, libName).scan())),
+      Promise.all(pkgNames.map(async (pkgName) => await PkgExecutor.from(exec, pkgName).scan())),
     ]);
     const workspaceInfo = new WorkspaceInfo(
       new Map(appInfos.map((app) => [app.exec.name, app as AppInfo])),