@akanjs/devkit 3.0.0-alpha.9 → 3.0.0-alpha.90

package/workspaceLayout.test.ts

@@ -1,5 +1,12 @@
 import { describe, expect, test } from "bun:test";
-import { appRootAllowedDirs, appRootAllowedFiles, isScannedAppRootEntry } from "./workspaceLayout";
+import {
+  appRootAllowedDirs,
+  appRootAllowedFiles,
+  isAllowedLibFacetRootFile,
+  isScannedRootEntry,
+  libRootAllowedDirs,
+  libRootAllowedFiles,
+} from "./workspaceLayout";
 
 describe("app root layout allowlist", () => {
   test("admits the scoped agent guides sync writes into every app", () => {
@@ -19,8 +26,53 @@ describe("app root layout allowlist", () => {
   });
 
   test("skips dotfile artifacts the sync glob never sees, but keeps .akan", () => {
-    expect(isScannedAppRootEntry(".DS_Store")).toBe(false);
-    expect(isScannedAppRootEntry(".akan")).toBe(true);
-    expect(isScannedAppRootEntry("lib")).toBe(true);
+    expect(isScannedRootEntry("app", ".DS_Store")).toBe(false);
+    expect(isScannedRootEntry("app", ".akan")).toBe(true);
+    expect(isScannedRootEntry("app", "lib")).toBe(true);
+  });
+});
+
+describe("lib root layout allowlist", () => {
+  test("admits what the libRoot template and scan write", () => {
+    for (const filename of ["AGENTS.md", "akan.config.ts", "akan.lib.json", "client.ts", "index.ts", "server.ts"]) {
+      expect(libRootAllowedFiles.has(filename)).toBe(true);
+    }
+    for (const dirname of ["common", "env", "lib", "page", "plugin", "private", "public", "srvkit", "ui", "webkit"]) {
+      expect(libRootAllowedDirs.has(dirname)).toBe(true);
+    }
+  });
+
+  test("rejects a lib root entry no facet owns", () => {
+    expect(libRootAllowedFiles.has("helper.ts")).toBe(false);
+    expect(libRootAllowedDirs.has("base")).toBe(false);
+  });
+
+  test("rejects the app-only run and mobile entries", () => {
+    for (const filename of ["main.ts", "capacitor.config.ts", "akan.app.json"]) {
+      expect(libRootAllowedFiles.has(filename)).toBe(false);
+    }
+    for (const dirname of [".akan", "android", "ios", "mobile", "script", "secrets"]) {
+      expect(libRootAllowedDirs.has(dirname)).toBe(false);
+    }
+  });
+
+  test("skips dotfile artifacts in a lib root too", () => {
+    expect(isScannedRootEntry("lib", ".gitignore")).toBe(false);
+    expect(isScannedRootEntry("lib", ".akan")).toBe(false);
+    expect(isScannedRootEntry("lib", "ui")).toBe(true);
+  });
+});
+
+describe("lib facet root allowlist", () => {
+  test("admits the generated support facets and a root signal test", () => {
+    expect(isAllowedLibFacetRootFile("cnst.ts")).toBe(true);
+    expect(isAllowedLibFacetRootFile("option.ts")).toBe(true);
+    expect(isAllowedLibFacetRootFile("user.signal.test.ts")).toBe(true);
+    expect(isAllowedLibFacetRootFile("user.signal.spec.ts")).toBe(true);
+  });
+
+  test("rejects a hand-written file beside the barrels", () => {
+    expect(isAllowedLibFacetRootFile("helper.ts")).toBe(false);
+    expect(isAllowedLibFacetRootFile("user.test.ts")).toBe(false);
   });
 });

package/workspaceLayout.ts

@@ -7,6 +7,8 @@
  * 규칙을 추가할 때는 이 파일만 고치고, 루트 AGENTS.md 의 목록도 같이 갱신한다.
  */
 
+export type SysType = "app" | "lib";
+
 export const appRootAllowedFiles = new Set([
   // 스코프 에이전트 가이드 — scan(write) 이 유지하는 색인 + 마커 밖 hand-written 내용 (agentsIndex.ts)
   "AGENTS.md",
@@ -41,6 +43,43 @@ export const appRootAllowedDirs = new Set([
   "webkit",
 ]);
 
+/**
+ * 라이브러리 루트는 앱 루트에서 실행/모바일 전용 항목(`main.ts`, `capacitor.config.ts`, `.akan`,
+ * `android`, `ios`, `mobile`, `script`, `secrets`)을 뺀 집합이다 — 라이브러리는 부팅되지도, 패키징되지도
+ * 않는다. `index.ts` 는 lib 에만 생성되고, `README.md` / `tsconfig.spec.json` 은 라이브러리가 패키지로
+ * 배포되기 때문에 남는다. `public` / `private` 은 syncAssets 가 앱으로 심링크하므로 라이브러리도 가진다.
+ */
+export const libRootAllowedFiles = new Set([
+  "AGENTS.md",
+  "CLAUDE.md",
+  "README.md",
+  "akan.config.ts",
+  "akan.lib.json",
+  "client.ts",
+  "index.ts",
+  "package.json",
+  "server.ts",
+  "tsconfig.json",
+  "tsconfig.spec.json",
+  "tsconfig.tsbuildinfo",
+]);
+
+export const libRootAllowedDirs = new Set([
+  "common",
+  "env",
+  "lib",
+  "page",
+  "plugin",
+  "private",
+  "public",
+  "srvkit",
+  "ui",
+  "webkit",
+]);
+
+export const rootAllowedFiles = { app: appRootAllowedFiles, lib: libRootAllowedFiles } as const;
+export const rootAllowedDirs = { app: appRootAllowedDirs, lib: libRootAllowedDirs } as const;
+
 export const libFacetRootAllowedFiles = new Set([
   "cnst.ts",
   "db.ts",
@@ -53,8 +92,15 @@ export const libFacetRootAllowedFiles = new Set([
   "useServer.ts",
 ]);
 
+/** `<model>.signal.test.ts` — lib 파싯 루트에 놓이는 유일한 비생성 파일 (테스트가 배럴 전체를 부팅한다). */
+const libFacetRootTestPattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(ts|tsx)$/;
+
+export const isAllowedLibFacetRootFile = (filename: string) =>
+  libFacetRootAllowedFiles.has(filename) || libFacetRootTestPattern.test(filename);
+
 /**
- * scanSync 는 앱 루트를 `Bun.Glob("*")` 로 읽어 dotfile 을 아예 보지 못한다. 디렉터리를 직접 읽는
+ * scanSync 는 루트를 `Bun.Glob("*")` 로 읽어 dotfile 을 아예 보지 못한다. 디렉터리를 직접 읽는
  * doctor 가 그 차이만큼 `.DS_Store` 같은 툴 산출물을 에러로 올리므로 같은 기준으로 걸러낸다.
  */
-export const isScannedAppRootEntry = (name: string) => !name.startsWith(".") || appRootAllowedDirs.has(name);
+export const isScannedRootEntry = (type: SysType, name: string) =>
+  !name.startsWith(".") || rootAllowedDirs[type].has(name);

package/builder.ts

@@ -1,164 +0,0 @@
-import { existsSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import path from "node:path";
-import type { Loader } from "bun";
-import type { Executor } from "./executors";
-import { FileSys } from "./fileSys";
-import type { PackageJson } from "./types";
-
-/** Relative paths under these directories are not used as Bun.build entrypoints (Bun does not expand `**` in entrypoint strings; we scan with {@link Bun.Glob}). */
-const SKIP_ENTRY_DIR_SET = new Set(["node_modules", "dist", "build", ".git", ".next"]);
-
-const assetExtensions = [".css", ".md", ".js", ".png", ".ico", ".svg", ".json", ".template"];
-const assetLoader = Object.fromEntries(assetExtensions.map((ext) => [ext, "file" as const])) satisfies Record<
-  string,
-  Loader
->;
-
-type BunBuildConfig = Parameters<typeof Bun.build>[0] & { bundle?: boolean };
-type ExportValue = string | string[] | { [condition: string]: ExportValue };
-
-interface BuildOptions {
-  bundle?: boolean;
-  additionalEntryPoints?: string[];
-}
-
-interface BuilderOptions {
-  executor: Executor;
-  distExecutor: Executor;
-  pkgJson: PackageJson;
-  rootPackageJson: PackageJson;
-}
-export class Builder {
-  #executor: Executor;
-  #distExecutor: Executor;
-  #pkgJson: PackageJson;
-
-  constructor({ executor, distExecutor, pkgJson }: BuilderOptions) {
-    this.#executor = executor;
-    this.#distExecutor = distExecutor;
-    this.#pkgJson = pkgJson;
-  }
-  #globEntrypoints(cwd: string, pattern: string): string[] {
-    const glob = new Bun.Glob(pattern);
-    return Array.from(glob.scanSync({ cwd, onlyFiles: true }))
-      .filter((relativePath) => {
-        const segments = relativePath.split(path.sep);
-        return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-      })
-      .map((rel) => path.join(cwd, rel));
-  }
-  #globFiles(cwd: string, pattern = "**/*.*"): string[] {
-    const glob = new Bun.Glob(pattern);
-    return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path.sep);
-      return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-    });
-  }
-
-  #resolveAdditionalEntrypoints(cwd: string, additionalEntryPoints: string[]): string[] {
-    const out: string[] = [];
-    for (const p of additionalEntryPoints) {
-      if (p.includes("*")) {
-        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path.sep}`) ? p.slice(cwd.length + 1) : p;
-        out.push(...this.#globEntrypoints(cwd, rel));
-      } else out.push(path.isAbsolute(p) ? p : path.join(cwd, p));
-    }
-    return out;
-  }
-  #getBuildOptions({ bundle = false, additionalEntryPoints = [] }: BuildOptions = {}): BunBuildConfig {
-    const cwd = this.#executor.cwdPath;
-    const entrypoints = [
-      ...(bundle ? [path.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}")),
-      ...this.#resolveAdditionalEntrypoints(cwd, additionalEntryPoints),
-    ];
-    return {
-      root: cwd,
-      entrypoints,
-      bundle,
-      packages: "external",
-      splitting: false,
-      target: this.#pkgJson.bun?.platform,
-      format: "esm",
-      outdir: this.#distExecutor.cwdPath,
-      external: ["react", "react-dom"],
-      loader: assetLoader,
-    };
-  }
-  async #copySourceFiles() {
-    const cwd = this.#executor.cwdPath;
-    for (const relativePath of this.#globFiles(cwd)) {
-      if (relativePath === "package.json") continue;
-      const sourcePath = path.join(cwd, relativePath);
-      const targetPath = path.join(this.#distExecutor.cwdPath, relativePath);
-      await mkdir(path.dirname(targetPath), { recursive: true });
-      await Bun.write(targetPath, Bun.file(sourcePath));
-    }
-  }
-  #toPublishedPath(publishedPath: string, { useSource }: { useSource: boolean }) {
-    const hasDotSlash = publishedPath.startsWith("./");
-    const withoutFormatDir = publishedPath.replace(/^(?:\.\/)?(?:esm|cjs)\//, hasDotSlash ? "./" : "");
-    if (!useSource) return withoutFormatDir;
-    if (!hasDotSlash && withoutFormatDir === publishedPath) return publishedPath;
-    const parsed = path.posix.parse(withoutFormatDir);
-    if (![".js", ".mjs", ".cjs"].includes(parsed.ext)) return withoutFormatDir;
-    const withoutExt = path.posix.join(parsed.dir, parsed.name);
-    const sourcePath = withoutExt.startsWith("./") ? withoutExt.slice(2) : withoutExt;
-    const sourceCandidates = [`${sourcePath}.ts`, `${sourcePath}.tsx`];
-    const matchedSource = sourceCandidates.find((candidate) =>
-      existsSync(path.join(this.#executor.cwdPath, candidate)),
-    );
-    if (!matchedSource) return withoutFormatDir;
-    return hasDotSlash ? `./${matchedSource}` : matchedSource;
-  }
-  #normalizeExports(
-    exportsValue: ExportValue | undefined,
-    { useSource }: { useSource: boolean },
-  ): ExportValue | undefined {
-    if (!exportsValue) return exportsValue;
-    if (typeof exportsValue === "string") return this.#toPublishedPath(exportsValue, { useSource });
-    if (Array.isArray(exportsValue))
-      return exportsValue.map((value) => this.#normalizeExports(value, { useSource }) as string);
-    if (typeof exportsValue !== "object") return exportsValue;
-
-    return Object.fromEntries(
-      Object.entries(exportsValue)
-        .filter(([condition]) => condition !== "require")
-        .map(([condition, value]) => [condition, this.#normalizeExports(value, { useSource })])
-        .filter((entry): entry is [string, ExportValue] => entry[1] !== undefined),
-    );
-  }
-  #getPackageJson({ bundle = false }: BuildOptions = {}): PackageJson {
-    const rootEntry = bundle ? "./index.js" : "./index.ts";
-    const normalizedExports = this.#normalizeExports(this.#pkgJson.exports as ExportValue | undefined, {
-      useSource: !bundle,
-    });
-    return {
-      ...this.#pkgJson,
-      type: "module",
-      main: rootEntry,
-      bin: this.#normalizeExports(this.#pkgJson.bin as ExportValue | undefined, { useSource: !bundle }),
-      exports: {
-        ...((typeof normalizedExports === "object" && !Array.isArray(normalizedExports)
-          ? normalizedExports
-          : {}) as Record<string, ExportValue>),
-        ".": {
-          import: rootEntry,
-          types: bundle ? "./index.d.ts" : "./index.ts",
-        },
-      },
-    };
-  }
-  async build(options: BuildOptions = {}) {
-    if (await FileSys.dirExists(this.#distExecutor.cwdPath))
-      await this.#distExecutor.exec(`rm -rf ${this.#distExecutor.cwdPath}`);
-
-    if (options.bundle) {
-      const buildResult = await Bun.build({ ...this.#getBuildOptions(options) });
-      if (!buildResult.success) throw new AggregateError(buildResult.logs, "Bundle failed");
-    } else await this.#copySourceFiles();
-
-    const pkgPackageJson = this.#getPackageJson(options);
-    await this.#distExecutor.setPackageJson(pkgPackageJson);
-  }
-}

package/extractDeps.ts

@@ -1,86 +0,0 @@
-import type { PackageJson } from "./types";
-
-const NODE_NATIVE_MODULE_SET = new Set([
-  "assert",
-  "async_hooks",
-  "buffer",
-  "child_process",
-  "cluster",
-  "console",
-  "constants",
-  "crypto",
-  "dgram",
-  "dns",
-  "domain",
-  "events",
-  "fs",
-  "http",
-  "http2",
-  "https",
-  "inspector",
-  "module",
-  "net",
-  "os",
-  "path",
-  "perf_hooks",
-  "process",
-  "punycode",
-  "querystring",
-  "readline",
-  "repl",
-  "stream",
-  "string_decoder",
-  "timers",
-  "tls",
-  "trace_events",
-  "tty",
-  "url",
-  "util",
-  "v8",
-  "vm",
-  "wasi",
-  "worker_threads",
-  "zlib",
-]);
-
-export const extractDependencies = (
-  filepaths: { path: string; text: string }[],
-  pacakgeJson: PackageJson,
-  defaultDependencies: string[] = [],
-) => {
-  if (!pacakgeJson.dependencies) throw new Error("No dependencies found in package.json");
-  const dependencies = new Set<string>(defaultDependencies);
-
-  const existingDependencies = new Set<string>([
-    ...Object.keys(pacakgeJson.dependencies ?? {}),
-    ...Object.keys(pacakgeJson.devDependencies ?? {}),
-  ]);
-  const versionObj = {
-    ...(pacakgeJson.dependencies ?? {}),
-    ...(pacakgeJson.devDependencies ?? {}),
-  };
-
-  // Look for require statements: require('package-name') or import 'package-name'
-  const requireRegex = /(?:require\s*\(|import\s*(?:[\w\s{},*]*\s+from\s*)?|import\s*\()\s*['"`]([^'"`]+)['"`]/g;
-  for (const { text } of filepaths.filter(({ path }) => path.endsWith(".js") || path.endsWith(".ts"))) {
-    let requireMatch = requireRegex.exec(text);
-    while (requireMatch !== null) {
-      const moduleName = requireMatch[1];
-      if (!moduleName) throw new Error(`No module name found in ${text}`);
-      const moduleNameParts = moduleName.split("/");
-      const subModuleLength = moduleNameParts.length;
-      for (let i = 0; i < subModuleLength; i++) {
-        const libName = moduleNameParts.slice(0, i + 1).join("/");
-        if (!NODE_NATIVE_MODULE_SET.has(libName) && existingDependencies.has(libName)) dependencies.add(libName);
-      }
-      requireMatch = requireRegex.exec(text);
-    }
-  }
-  return Object.fromEntries(
-    [...dependencies].sort().map((dep) => {
-      const version = versionObj[dep];
-      if (!version) throw new Error(`No version found for ${dep}`);
-      return [dep, version];
-    }),
-  );
-};

package/frontendBuild/styleGuard.test.ts

@@ -1,165 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { StyleGuard, type StyleGuardRule } from "./styleGuard";
-
-const guard = new StyleGuard();
-const scan = (content: string, path = "Demo.tsx") => guard.run([{ path, content }]);
-const rules = (content: string): StyleGuardRule[] => scan(content).map((v) => v.rule);
-
-describe("StyleGuard raw-palette", () => {
-  test("flags raw Tailwind palette utilities", () => {
-    expect(rules('<div className="bg-blue-500 text-gray-700" />')).toEqual(["raw-palette", "raw-palette"]);
-  });
-
-  test("flags palette with variant prefix and opacity", () => {
-    expect(rules('<div className="hover:bg-red-500/50" />')).toContain("raw-palette");
-  });
-
-  test("flags numeric neutral but allows bare semantic neutral", () => {
-    expect(rules('<div className="bg-neutral-500" />')).toEqual(["raw-palette"]);
-    expect(scan('<div className="bg-neutral text-neutral-foreground" />')).toHaveLength(0);
-  });
-
-  test("does not flag semantic tokens or black/white", () => {
-    expect(scan('<div className="bg-primary text-muted-foreground border-border" />')).toHaveLength(0);
-    expect(scan('<div className="bg-black text-white bg-white/30 bg-black/50" />')).toHaveLength(0);
-  });
-
-  test("does not flag non-color numeric utilities", () => {
-    expect(scan('<div className="gap-4 mt-2 grid-cols-3 w-500" />')).toHaveLength(0);
-  });
-});
-
-describe("StyleGuard arbitrary-color", () => {
-  test("flags hex and color-function arbitrary values", () => {
-    expect(rules('<div className="bg-[#3b82f6]" />')).toEqual(["arbitrary-color"]);
-    expect(rules('<div className="text-[rgb(0,0,0)]" />')).toEqual(["arbitrary-color"]);
-  });
-
-  test("allows arbitrary CSS variable references", () => {
-    expect(scan('<div className="bg-[--brand] text-[var(--fg)]" />')).toHaveLength(0);
-  });
-});
-
-describe("StyleGuard inline-color", () => {
-  test("flags hardcoded color in style object", () => {
-    expect(rules("<div style={{ color: '#fff', background: 'rgb(0,0,0)' }} />")).toEqual([
-      "inline-color",
-      "inline-color",
-    ]);
-  });
-
-  test("flags color literal inside <style> tag", () => {
-    expect(rules("<style>{`.x { color: #abcdef; }`}</style>")).toEqual(["inline-color"]);
-  });
-
-  test("allows var() references in style object", () => {
-    expect(scan("<div style={{ color: 'var(--primary)', width: '100%' }} />")).toHaveLength(0);
-  });
-});
-
-describe("StyleGuard daisyui-legacy", () => {
-  test("flags high-signal daisyUI compound classes", () => {
-    expect(rules('<button className="btn-primary" />')).toEqual(["daisyui-legacy"]);
-    expect(rules('<span className="badge-success" />')).toEqual(["daisyui-legacy"]);
-    expect(rules('<div className="modal-box card-body" />')).toEqual(["daisyui-legacy", "daisyui-legacy"]);
-  });
-
-  test("does not flag bare ambiguous names that collide with Tailwind", () => {
-    expect(scan('<div className="card input badge btn" />')).toHaveLength(0);
-  });
-});
-
-// The fixtures below must contain a literal `${`. Writing it inside a plain string trips biome's
-// noTemplateCurlyInString, so the placeholder is assembled from `D` — that keeps the rule on for real code
-// instead of scattering suppressions through the fixtures.
-const D = "$";
-const INTERPOLATED = {
-  size: `<div className={\`min-h-[${D}{minHeight}px] flex\`} />`,
-  color: `<div className={\`bg-[${D}{color}] w-full\`} />`,
-  brokenBracket: `<div className={\`min-h-[ w-full${D}{minHeight}px] flex\`} />`,
-  outsideBrackets: `<div className={\`flex gap-2 ${D}{isOpen ? "opacity-50" : ""}\`} />`,
-  styleProp: `<div style={{ minHeight }} className={\`flex ${D}{extra}\`} />`,
-};
-
-describe("StyleGuard interpolated-arbitrary", () => {
-  test("flags an arbitrary value assembled from a runtime expression", () => {
-    expect(rules(INTERPOLATED.size)).toEqual(["interpolated-arbitrary"]);
-    expect(rules(INTERPOLATED.color)).toEqual(["interpolated-arbitrary"]);
-  });
-
-  test("flags the broken-bracket typo that swallows the next class", () => {
-    expect(rules(INTERPOLATED.brokenBracket)).toEqual(["interpolated-arbitrary"]);
-  });
-
-  test("allows a literal arbitrary value, and interpolation outside brackets", () => {
-    expect(scan('<div className="min-h-[300px] flex" />')).toHaveLength(0);
-    expect(scan(INTERPOLATED.outsideBrackets)).toHaveLength(0);
-    expect(scan(INTERPOLATED.styleProp)).toHaveLength(0);
-  });
-});
-
-describe("StyleGuard violation shape", () => {
-  test("reports 1-based line and trimmed snippet with a suggestion", () => {
-    const content = ['<div className="ok" />', '  <div className="bg-blue-500" />'].join("\n");
-    const [v] = scan(content);
-    expect(v.line).toBe(2);
-    expect(v.snippet).toBe('<div className="bg-blue-500" />');
-    expect(v.severity).toBe("error");
-    expect(v.suggestion.length).toBeGreaterThan(0);
-  });
-});
-
-describe("StyleGuard comment handling", () => {
-  test("does not flag class names inside line or block comments", () => {
-    expect(scan('// iconClassName="btn-primary bg-blue-500"')).toHaveLength(0);
-    expect(scan("/** legacy: toggle-accent / bg-red-500 */")).toHaveLength(0);
-    expect(scan("{/* <div className='bg-blue-500' /> */}")).toHaveLength(0);
-  });
-
-  test("still flags real code on a line that also contains a string with //", () => {
-    expect(rules('<a href="https://x.io" className="bg-blue-500" />')).toEqual(["raw-palette"]);
-  });
-});
-
-describe("StyleGuard escape hatch", () => {
-  test("styleguard-disable-next-line suppresses the following line only", () => {
-    const content = [
-      "// styleguard-disable-next-line raw-palette",
-      '<div className="bg-blue-500" />',
-      '<div className="bg-red-500" />',
-    ].join("\n");
-    const found = scan(content);
-    expect(found).toHaveLength(1);
-    expect(found[0].line).toBe(3);
-  });
-
-  test("file-level styleguard-disable suppresses the named rule everywhere", () => {
-    const content = ["// styleguard-disable raw-palette", '<div className="bg-blue-500 bg-[#fff]" />'].join("\n");
-    // raw-palette suppressed, arbitrary-color still reported.
-    expect(rules(content)).toEqual(["arbitrary-color"]);
-  });
-
-  test("bare styleguard-disable suppresses all rules in the file", () => {
-    const content = ["/* styleguard-disable */", '<div className="bg-blue-500 btn-primary bg-[#fff]" />'].join("\n");
-    expect(scan(content)).toHaveLength(0);
-  });
-});
-
-describe("StyleGuard.countNamedComponentClasses", () => {
-  test("counts named classes declared inside @layer components", () => {
-    const css = `
-      @layer components {
-        .foo { color: var(--primary); }
-        .bar-baz { padding: 1rem; }
-      }
-      .outside { color: red; }
-    `;
-    const metric = StyleGuard.countNamedComponentClasses(css);
-    expect(metric.count).toBe(2);
-    expect(metric.names).toEqual(["bar-baz", "foo"]);
-  });
-
-  test("returns zero when no component layer exists", () => {
-    expect(StyleGuard.countNamedComponentClasses(".a { color: red; }").count).toBe(0);
-  });
-});