@akanjs/devkit 3.0.0-alpha.15 → 3.0.0-alpha.17

package/README.ko.md

@@ -56,7 +56,7 @@ await runner.build();
 
 ## 요구사항
 
-- [Bun](https://bun.sh) `>=1.3.13`
+- [Bun](https://bun.sh) `>=1.4.0`
 - TypeScript
 - Optional peer는 Capacitor integration처럼 해당 기능을 사용할 때만 필요합니다.
 

package/README.md

@@ -60,7 +60,7 @@ defaults, the shares they derive from `AKAN_MEMORY_LIMIT`, and what a small cont
 
 ## Requirements
 
-- [Bun](https://bun.sh) `>=1.3.13`
+- [Bun](https://bun.sh) `>=1.4.0`
 - TypeScript
 - Optional peers are only needed for the features that use them, such as Capacitor integration.
 

package/akanConfig/akanConfig.test.ts

@@ -19,7 +19,6 @@ const packageJson: PackageJson = {
     react: "19.0.0",
     "react-dom": "19.0.0",
     "react-server-dom-webpack": "19.0.0",
-    sharp: "1.0.0",
     "@external/runtime": "2.0.0",
   },
 };
@@ -144,8 +143,6 @@ describe("AkanAppConfig", () => {
         react: "19.0.0",
         "react-dom": "19.0.0",
         "react-server-dom-webpack": "19.0.0",
-        croner: akanPackageJson.peerDependencies?.croner,
-        sharp: "1.0.0",
         "@external/runtime": "2.0.0",
       },
     });
@@ -184,8 +181,6 @@ describe("AkanAppConfig", () => {
       react: runtimeDependencies.react,
       "react-dom": runtimeDependencies["react-dom"],
       "react-server-dom-webpack": runtimeDependencies["react-server-dom-webpack"],
-      croner: runtimeDependencies.croner,
-      sharp: runtimeDependencies.sharp,
     });
   });
 
@@ -198,9 +193,6 @@ describe("AkanAppConfig", () => {
     const multipleConfig = new AkanAppConfig(app, [], packageJson, { defaultDatabaseMode: "multiple" }, baseDevEnv);
     const clusterConfig = new AkanAppConfig(app, [], packageJson, { defaultDatabaseMode: "cluster" }, baseDevEnv);
 
-    expect(singleConfig.getProductionPackageJson().dependencies).toMatchObject({
-      croner: runtimeDependencies.croner,
-    });
     expect(singleConfig.getProductionPackageJson().dependencies).not.toHaveProperty("ioredis");
     expect(singleConfig.getProductionPackageJson().dependencies).not.toHaveProperty("bullmq");
     expect(singleConfig.getProductionPackageJson().dependencies).not.toHaveProperty("@libsql/client");
@@ -210,7 +202,6 @@ describe("AkanAppConfig", () => {
     expect(multipleConfig.getProductionPackageJson().dependencies).toMatchObject({
       "@libsql/client": runtimeDependencies["@libsql/client"],
       bullmq: runtimeDependencies.bullmq,
-      croner: runtimeDependencies.croner,
       ioredis: runtimeDependencies.ioredis,
       protobufjs: runtimeDependencies.protobufjs,
     });
@@ -218,7 +209,6 @@ describe("AkanAppConfig", () => {
 
     expect(clusterConfig.getProductionPackageJson().dependencies).toMatchObject({
       bullmq: runtimeDependencies.bullmq,
-      croner: runtimeDependencies.croner,
       ioredis: runtimeDependencies.ioredis,
       postgres: runtimeDependencies.postgres,
       protobufjs: runtimeDependencies.protobufjs,

package/akanConfig/akanConfig.ts

@@ -50,8 +50,6 @@ const DEFAULT_OPTIMIZE_IMPORTS = [
 ];
 const WORKSPACE_BARREL_FACETS = ["ui", "webkit", "common", "client", "server"] as const;
 const SSR_RUNTIME_PACKAGES = ["react", "react-dom", "react-server-dom-webpack"] as const;
-const NATIVE_RUNTIME_PACKAGES = ["sharp"] as const;
-const DEFAULT_BACKEND_RUNTIME_PACKAGES = ["croner"] as const;
 // The firebase client (push tokens) and the Capacitor toolchain — `@capacitor/cli` (`npx cap`),
 // `@capacitor/assets` (`npx @capacitor/assets`) plus the `@capacitor/core`/`ios`/`android` runtime
 // and native-platform packages that `npx cap add`/`sync` resolve from the workspace node_modules.
@@ -92,8 +90,6 @@ const DATABASE_MODE_RUNTIME_PACKAGES = {
 } satisfies Record<DatabaseMode, readonly string[]>;
 const AKAN_RUNTIME_PACKAGES = new Set<string>([
   ...SSR_RUNTIME_PACKAGES,
-  ...NATIVE_RUNTIME_PACKAGES,
-  ...DEFAULT_BACKEND_RUNTIME_PACKAGES,
   ...MOBILE_RUNTIME_PACKAGES,
   ...Object.values(DATABASE_MODE_RUNTIME_PACKAGES).flat(),
 ]);
@@ -428,13 +424,7 @@ CMD [${command.map((c) => `"${c}"`).join(",")}]`;
     return akanPackageJson.dependencies?.[lib] ?? akanPackageJson.peerDependencies?.[lib];
   }
   #getProductionRuntimePackages() {
-    return [
-      ...this.externalLibs,
-      ...SSR_RUNTIME_PACKAGES,
-      ...NATIVE_RUNTIME_PACKAGES,
-      ...DEFAULT_BACKEND_RUNTIME_PACKAGES,
-      ...this.getDatabaseModeRuntimePackages(),
-    ];
+    return [...this.externalLibs, ...SSR_RUNTIME_PACKAGES, ...this.getDatabaseModeRuntimePackages()];
   }
   getDatabaseModeRuntimePackages(databaseMode: DatabaseMode = this.defaultDatabaseMode) {
     return [...DATABASE_MODE_RUNTIME_PACKAGES[databaseMode]];

package/applicationBuildRunner.test.ts

@@ -4,7 +4,7 @@ import { AKAN_OPTIONAL_BACKEND_EXTERNALS } from "./applicationBuildRunner";
 describe("ApplicationBuildRunner", () => {
   test("externalizes Akan optional backend dependencies", () => {
     expect(AKAN_OPTIONAL_BACKEND_EXTERNALS).toEqual(
-      expect.arrayContaining(["@libsql/client", "bullmq", "croner", "ioredis", "postgres", "protobufjs"]),
+      expect.arrayContaining(["@libsql/client", "bullmq", "ioredis", "postgres", "protobufjs"]),
     );
   });
 });

package/applicationBuildRunner.ts

@@ -56,7 +56,6 @@ const SSR_RENDER_EXTERNALS = [
 export const AKAN_OPTIONAL_BACKEND_EXTERNALS = [
   "@libsql/client",
   "bullmq",
-  "croner",
   "ioredis",
   "postgres",
   "protobufjs",

package/biome.base.json

@@ -174,6 +174,10 @@
       "includes": ["{apps,libs}/**/*.signal.ts"],
       "plugins": ["./node_modules/@akanjs/devkit/lint/no-redeclare-predefined-endpoint.grit"]
     },
+    {
+      "includes": ["{apps,libs}/**/*.Util.tsx", "{apps,libs}/**/*.Zone.tsx"],
+      "plugins": ["./node_modules/@akanjs/devkit/lint/no-model-type-in-util-zone.grit"]
+    },
     {
       "includes": [
         "**/ui/**/*.ts",

package/executors.test.ts

@@ -31,7 +31,6 @@ const rootPackageJson = (extra: Partial<PackageJson> = {}): PackageJson => ({
     react: "19.0.0",
     "react-dom": "19.0.0",
     "react-server-dom-webpack": "19.0.0",
-    sharp: "1.0.0",
     lodash: "4.0.0",
   },
   devDependencies: {
@@ -796,7 +795,7 @@ describe("PkgExecutor package generation", () => {
       exports: { "./extra": { import: "./extra.ts" } },
       peerDependencies: { react: "19.0.0" },
       peerDependenciesMeta: { react: { optional: true } },
-      optionalDependencies: { sharp: "1.0.0" },
+      optionalDependencies: { "@sample/native": "1.0.0" },
     });
 
     const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
@@ -806,12 +805,12 @@ describe("PkgExecutor package generation", () => {
     expect(distPackageJson).toMatchObject({
       name: "@sample/tool",
       type: "module",
-      engines: { bun: ">=1.3.13" },
+      engines: { bun: ">=1.4.0" },
       dependencies: { lodash: "4.0.0" },
       devDependencies: { typescript: "6.0.0" },
       peerDependencies: { react: "19.0.0" },
       peerDependenciesMeta: { react: { optional: true } },
-      optionalDependencies: { sharp: "1.0.0" },
+      optionalDependencies: { "@sample/native": "1.0.0" },
     });
     expect(distPackageJson.exports?.["."]).toEqual({
       import: "./index.ts",

package/executors.ts

@@ -1813,7 +1813,7 @@ export class PkgExecutor extends Executor {
           default: "./index.ts",
         },
       },
-      engines: { bun: ">=1.3.13" },
+      engines: { bun: ">=1.4.0" },
       ...dependencyMaps,
     };
     await Promise.all([this.dist.writeJson("package.json", distPkgJson), this.writeJson("package.json", distPkgJson)]);

package/frontendBuild/buildRouteClient.test.ts

@@ -82,16 +82,42 @@ describe("route client store bootstrap", () => {
   });
 
   test("bundles akan fetch into production SSR client chunks", () => {
-    expect(RouteClientBuilder.resolveSsrClientExternalOptions("start")).toMatchObject({
+    expect(RouteClientBuilder.resolveSsrClientBundleOptions("start")).toMatchObject({
       external: expect.arrayContaining(["akanjs/fetch"]),
       externalSubpaths: ["akanjs/fetch"],
     });
 
-    expect(RouteClientBuilder.resolveSsrClientExternalOptions("build")).toEqual({
+    expect(RouteClientBuilder.resolveSsrClientBundleOptions("build")).toEqual({
+      target: "bun",
       external: ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "react/jsx-dev-runtime"],
     });
   });
 
+  test("targets the server so SSR client chunks never resolve a browser export condition", async () => {
+    const root = await makeTempRoot();
+    const pkgDir = path.join(root, "node_modules/dom-conditioned-pkg");
+    await write(
+      path.join(pkgDir, "package.json"),
+      JSON.stringify({
+        name: "dom-conditioned-pkg",
+        type: "module",
+        exports: { ".": { browser: "./index.dom.js", default: "./index.js" } },
+      }),
+    );
+    await write(path.join(pkgDir, "index.dom.js"), 'export const element = document.createElement("i");\n');
+    await write(path.join(pkgDir, "index.js"), "export const element = null;\n");
+    const entry = path.join(root, "entry.ts");
+    await write(entry, 'export { element } from "dom-conditioned-pkg";\n');
+
+    for (const command of ["start", "build"] as const) {
+      const { target } = RouteClientBuilder.resolveSsrClientBundleOptions(command);
+      const built = await Bun.build({ entrypoints: [entry], target, format: "esm" });
+
+      expect(built.success).toBe(true);
+      expect(await built.outputs[0].text()).not.toContain("document.createElement");
+    }
+  });
+
   test("rewrites SSR external imports to runtime aliases", () => {
     const source = [
       'import React, { useState } from "react";',

package/frontendBuild/clientBuildTypes.ts

@@ -55,6 +55,8 @@ export interface BuildClientResult {
   rscClientUrl: string;
 }
 
+export type ClientBundleTarget = "browser" | "bun";
+
 export const CLIENT_BUNDLE_NAMING = {
   entry: "[name]-[hash].[ext]",
   chunk: "chunks/[hash].[ext]",
@@ -79,6 +81,8 @@ export interface BundleClientEntriesOptions {
 }
 
 export interface BundleClientEntriesInternalOptions extends BundleClientEntriesOptions {
+  /** Module-resolution target. `"bun"` for the server-executed `client-ssr` bundle, `"browser"` otherwise. */
+  target?: ClientBundleTarget;
   external?: readonly string[];
   externalSubpaths?: readonly string[];
   externalAliases?: Partial<Record<string, string>>;

package/frontendBuild/clientEntriesBundler.ts

@@ -7,6 +7,7 @@ import {
   type BundleClientEntriesInternalOptions,
   type BundleClientEntriesResult,
   CLIENT_BUNDLE_NAMING,
+  type ClientBundleTarget,
   type ClientManifest,
   type MetafileOutput,
   type OpaqueEntryAliases,
@@ -25,6 +26,7 @@ export class ClientEntriesBundler {
   #externalSubpaths: readonly string[];
   #externalAliases: Partial<Record<string, string>>;
   #command: "build" | "start";
+  #target: ClientBundleTarget;
   #outputSubdir: string;
   #reactFastRefresh: boolean;
   #artifactDir: string;
@@ -47,6 +49,7 @@ export class ClientEntriesBundler {
     this.#externalSubpaths = options.externalSubpaths ?? [];
     this.#externalAliases = options.externalAliases ?? {};
     this.#command = options.command ?? "start";
+    this.#target = options.target ?? "browser";
     this.#outputSubdir = options.outputSubdir ?? "client";
     this.#reactFastRefresh = options.reactFastRefresh ?? false;
     this.#artifactDir = `${this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath}/.akan/artifact`;
@@ -61,7 +64,7 @@ export class ClientEntriesBundler {
       entrypoints: this.#opaqueEntries.entries,
       outdir: this.#outdir,
       splitting: true,
-      target: "browser",
+      target: this.#target,
       format: "esm",
       naming: CLIENT_BUNDLE_NAMING,
       metafile: true,

package/frontendBuild/routeClientBuilder.ts

@@ -4,7 +4,7 @@ import type { BaseBuildArtifact, ClientManifest, SsrManifest } from "akanjs/serv
 import type { App } from "../commandDecorators";
 import { createBarrelImportsPlugin } from "../transforms/barrelImportsPlugin";
 import { toClientReferencePath } from "../transforms/rscUseClientTransform";
-import type { ClientEntryDiscovery } from "./clientBuildTypes";
+import type { ClientBundleTarget, ClientEntryDiscovery } from "./clientBuildTypes";
 import { ClientEntriesBundler } from "./clientEntriesBundler";
 import { GraphClientEntryDiscovery } from "./clientEntryDiscovery";
 import { VENDOR_SPECIFIERS } from "./vendorSpecifiers";
@@ -163,12 +163,11 @@ export class RouteClientBuilder {
   }
 
   async #buildSsrBundle(bootstrapEntries: BootstrapEntries) {
-    const externalOptions = RouteClientBuilder.resolveSsrClientExternalOptions(this.#command);
     return new ClientEntriesBundler({
       app: this.#app,
       entries: bootstrapEntries.buildEntries,
       plugins: [await createBarrelImportsPlugin(this.#app)],
-      ...externalOptions,
+      ...RouteClientBuilder.resolveSsrClientBundleOptions(this.#command),
       outputSubdir: "client-ssr",
       command: this.#command,
     }).bundle();
@@ -239,20 +238,28 @@ export class RouteClientBuilder {
     return { [Bun.resolveSync("akanjs/fetch", serverEntry)]: "akanjs/fetch" };
   }
 
-  static resolveSsrClientExternalOptions(command: "build" | "start"): {
+  /**
+   * `target: "bun"` is load-bearing: these chunks are `await import()`-ed by the SSR renderer, so a dependency
+   * resolved through its `browser` export condition can touch `document` at module scope and throw mid-render,
+   * degrading the whole document to client rendering. Bun's `conditions` only adds to the target's defaults —
+   * `browser` still wins — so the target itself has to say server.
+   */
+  static resolveSsrClientBundleOptions(command: "build" | "start"): {
+    target: ClientBundleTarget;
     external: readonly string[];
     externalSubpaths?: readonly string[];
     externalAliases?: Record<string, string>;
   } {
     if (command === "start") {
       return {
+        target: "bun",
         external: SSR_CLIENT_EXTERNALS,
         externalSubpaths: ["akanjs/fetch"],
         externalAliases: RouteClientBuilder.resolveSsrClientRuntimeAliases(),
       };
     }
 
-    return { external: SSR_CLIENT_ALIAS_EXTERNALS };
+    return { target: "bun", external: SSR_CLIENT_ALIAS_EXTERNALS };
   }
 
   static resolveAkanServerEntry(): string {

package/frontendBuild/ssrBaseArtifactBuilder.ts

@@ -110,7 +110,7 @@ export class SsrBaseArtifactBuilder {
     const ssrBundle = await new ClientEntriesBundler({
       app: this.#app,
       entries: [rscSegmentOutletEntry],
-      ...RouteClientBuilder.resolveSsrClientExternalOptions(this.#command),
+      ...RouteClientBuilder.resolveSsrClientBundleOptions(this.#command),
       outputSubdir: "client-ssr",
       command: this.#command,
     }).bundle();

package/getCredentials.ts

@@ -1,5 +1,3 @@
-import yaml from "js-yaml";
-
 import type { AppExecutor } from "./executors";
 import { FileSys } from "./fileSys";
 
@@ -12,7 +10,7 @@ interface Secret {
 
 export const getCredentials = async (app: AppExecutor, environment: string): Promise<AppSecret> => {
   const content = await FileSys.readText(`${app.workspace.workspaceRoot}/infra/app/values/${app.name}-secret.yaml`);
-  const secret = yaml.load(content) as Secret;
+  const secret = Bun.YAML.parse(content) as Secret;
   const appSecret = secret[environment];
   if (!appSecret) throw new Error(`No secret found for ${app.name} in ${environment}`);
   return appSecret;

package/lint/no-model-type-in-util-zone.grit

@@ -0,0 +1,16 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+TsReferenceType() as $ref where {
+  $ref <: r"cnst\.[A-Za-z_$][A-Za-z0-9_$]*",
+  not $ref <: within TsIndexedAccessType() as $indexed where {
+    $indexed <: r"cnst\.[A-Za-z_$][A-Za-z0-9_$]*\[.value.\][\s\S]*"
+  },
+  not $ref <: within TsReferenceType() as $wrapper where {
+    $wrapper <: r"(?:Client|Server)(?:Init|View|Edit)<[\s\S]*"
+  },
+  register_diagnostic(
+    span = $ref,
+    message = "Util and Zone are client components, so a cnst model type here is a class instance crossing the server boundary. Take an id instead (bannerId: string), or hand server data across as ClientInit / ClientView. An enum union such as cnst.AdminRole['value'] is allowed."
+  )
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.0.0-alpha.15",
+  "version": "3.0.0-alpha.17",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -14,7 +14,7 @@
     "directory": "pkgs/@akanjs/devkit"
   },
   "engines": {
-    "bun": ">=1.3.13"
+    "bun": ">=1.4.0"
   },
   "exports": {
     ".": {
@@ -45,7 +45,7 @@
     "@langchain/openai": "^1.4.6",
     "@tailwindcss/node": "^4.3.0",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "3.0.0-alpha.15",
+    "akanjs": "3.0.0-alpha.17",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "dayjs": "^1.11.20",
@@ -53,7 +53,6 @@
     "fonteditor-core": "^2.6.3",
     "ignore": "^7.0.5",
     "ink": "^6.8.0",
-    "js-yaml": "^4.1.1",
     "ora": "^9.4.0",
     "ssh2": "^1.17.0",
     "subset-font": "^2.5.0",

package/qualityScanner.test.ts

@@ -193,175 +193,6 @@ const signalOf = (entries: string) =>
     "",
   ].join("\n");
 
-describe("AkanQualityScanner mcp rules", () => {
-  test("flags an exposed endpoint whose dictionary entry carries no desc", async () => {
-    const root = await makeWorkspace({
-      "libs/shared/lib/post/post.signal.ts": [
-        `import { endpoint } from "akanjs/signal";`,
-        `export class PostEndpoint extends endpoint(srv.post, ({ query }) => ({`,
-        `  publishPost: query(Boolean, { guards: [Admin], mcp: { expose: true } }).exec(() => true),`,
-        `  archivePost: query(Boolean, { guards: [Admin], mcp: { expose: true } }).exec(() => true),`,
-        `  quietPost: query(Boolean, { guards: [Admin] }).exec(() => true),`,
-        `})) {}`,
-        "",
-      ].join("\n"),
-      "libs/shared/lib/post/post.dictionary.ts": [
-        `export const dictionary = modelDictionary(["en", "ko"]).endpoint((fn) => ({`,
-        `  publishPost: fn(["Publish", "게시"]).desc(["Publishes a post", "글을 게시합니다"]),`,
-        `  archivePost: fn(["Archive", "보관"]).arg((t) => ({`,
-        `    postId: t(["Post", "글"]).desc(["Post to archive", "보관할 글"]),`,
-        `  })),`,
-        `}));`,
-        "",
-      ].join("\n"),
-    });
-
-    const warnings = rulesOf(await new AkanQualityScanner().scan(root), "akan.mcp.missing-description");
-
-    // `archivePost` describes only its argument, which says nothing about when to reach for the tool.
-    expect(warnings).toHaveLength(1);
-    expect(warnings[0]?.message).toContain("archivePost");
-    expect(warnings[0]?.line).toBe(4);
-    expect(warnings[0]?.fix).toContain(".desc(");
-  });
-
-  test("accepts a slice described on its own entry or on the endpoint it generates", async () => {
-    const root = await makeWorkspace({
-      "libs/shared/lib/post/post.signal.ts": signalOf(
-        [
-          `  inPublic: init({ mcp: { expose: true } }).exec(function () { return this.postService.queryInPublic(); }),`,
-          `  inTag: init({ mcp: { expose: true } }).exec(function () { return this.postService.queryInTag(); }),`,
-          `  inDraft: init({ mcp: { expose: true } }).exec(function () { return this.postService.queryInDraft(); }),`,
-        ].join("\n"),
-      ),
-      "libs/shared/lib/post/post.dictionary.ts": [
-        `export const dictionary = modelDictionary(["en", "ko"])`,
-        `  .slice((fn) => ({`,
-        `    inPublic: fn(["In Public", "공개"]).desc(["Public posts", "공개된 글"]),`,
-        `    inTag: fn(["In Tag", "태그"]),`,
-        `    inDraft: fn(["In Draft", "초안"]),`,
-        `  }))`,
-        `  .endpoint((fn) => ({`,
-        `    postListInTag: fn(["Post List In Tag", "태그별 글"]).desc(["Posts under a tag", "태그에 속한 글"]),`,
-        `  }));`,
-        "",
-      ].join("\n"),
-    });
-
-    const warnings = rulesOf(await new AkanQualityScanner().scan(root), "akan.mcp.missing-description");
-
-    expect(warnings).toHaveLength(1);
-    expect(warnings[0]?.message).toContain("inDraft");
-  });
-
-  test("flags an exposure that declares no guards, whatever the slice call declared", async () => {
-    const root = await makeWorkspace({
-      "libs/shared/lib/post/post.signal.ts": signalOf(
-        [
-          `  inPublic: init({ guards: [Public], mcp: { expose: true } }).exec(function () { return this.postService.queryInPublic(); }),`,
-          `  inTag: init({ mcp: { expose: true } }).exec(function () { return this.postService.queryInTag(); }),`,
-          `  inDraft: init({ ...sharedOption, mcp: { expose: true } }).exec(function () { return this.postService.queryInDraft(); }),`,
-        ].join("\n"),
-      ),
-      "libs/shared/lib/post/post.dictionary.ts": `export const dictionary = modelDictionary(["en", "ko"]);\n`,
-    });
-
-    const warnings = rulesOf(await new AkanQualityScanner().scan(root), "akan.mcp.unguarded-exposure");
-
-    // `inPublic` decided; `inDraft` may have inherited a `guards` from the spread, so it is unreadable, not missing.
-    expect(warnings).toHaveLength(1);
-    expect(warnings[0]?.message).toContain("inTag");
-    expect(warnings[0]?.fix).toContain("guards: [Public]");
-  });
-
-  test("stays silent on a module that exposes nothing to MCP", async () => {
-    const root = await makeWorkspace({
-      "libs/shared/lib/post/post.signal.ts": signalOf(
-        `  inPublic: init().exec(function () { return this.postService.queryInPublic(); }),`,
-      ),
-      "libs/shared/lib/post/post.dictionary.ts": `export const dictionary = modelDictionary(["en", "ko"]);\n`,
-    });
-
-    expect(rulesOf(await new AkanQualityScanner().scan(root), "akan.mcp.missing-description")).toHaveLength(0);
-  });
-});
-
-describe("AkanQualityScanner agent rules", () => {
-  const storeOf = (body: string) =>
-    [
-      `import { store } from "akanjs/store";`,
-      `export class PostStore extends store(sig.post, () => ({})) {`,
-      body,
-      `}`,
-      "",
-    ].join("\n");
-
-  test("flags only the actions whose endpoint description would be the wrong one", async () => {
-    const root = await makeWorkspace({
-      "libs/shared/lib/post/post.store.ts": storeOf(
-        [
-          // Named after the endpoint it calls, so it already reads as that endpoint's `.desc()`.
-          `  async publishPost(id: string) { await fetch.publishPost(id); }`,
-          // Renamed: the store name is the verb a user would say, the endpoint name is the verb the API has.
-          `  async archive(id: string) { await fetch.archivePost(id); }`,
-          // Two endpoints behind one action, so neither one's description covers it.
-          `  async publishAndTag(id: string) { await fetch.publishPost(id); await fetch.tagPost(id); }`,
-          // Never leaves the client, so it is not published and its description would be read by nobody.
-          `  toggleDraft() { this.set({ draft: !this.get().draft }); }`,
-        ].join("\n"),
-      ),
-      "libs/shared/lib/post/post.dictionary.ts": `export const dictionary = modelDictionary(["en", "ko"]);\n`,
-    });
-
-    const warnings = rulesOf(await new AkanQualityScanner().scan(root), "akan.agent.missing-store-description");
-
-    expect(warnings.map((warning) => warning.message)).toHaveLength(2);
-    expect(warnings[0]?.message).toContain("archive");
-    expect(warnings[0]?.message).toContain("archivePost()");
-    expect(warnings[1]?.message).toContain("publishAndTag");
-    expect(warnings[0]?.fix).toContain(".store()");
-  });
-
-  test("accepts an action described on its own store entry or on a same-named endpoint", async () => {
-    const root = await makeWorkspace({
-      "libs/shared/lib/post/post.store.ts": storeOf(
-        [
-          `  async archive(id: string) { await fetch.archivePost(id); }`,
-          `  async logout() { await fetch.signoutUser(); }`,
-          `  async retire(id: string) { await fetch.archivePost(id); }`,
-        ].join("\n"),
-      ),
-      "libs/shared/lib/post/post.dictionary.ts": [
-        `export const dictionary = modelDictionary(["en", "ko"])`,
-        `  .endpoint((fn) => ({`,
-        // Not the endpoint it calls — an entry under the action's own name describes the action.
-        `    logout: fn(["Log Out", "로그아웃"]).desc(["Ends the session", "세션을 종료합니다"]),`,
-        `  }))`,
-        `  .store((t) => ({`,
-        `    archive: t(["Archive", "보관"]).desc(["Files the post away", "글을 보관합니다"]),`,
-        `    retire: t(["Retire", "폐기"]),`,
-        `  }));`,
-        "",
-      ].join("\n"),
-    });
-
-    const warnings = rulesOf(await new AkanQualityScanner().scan(root), "akan.agent.missing-store-description");
-
-    // `retire` has an entry but no `.desc()`, which is a label and not a sentence an agent can act on.
-    expect(warnings).toHaveLength(1);
-    expect(warnings[0]?.message).toContain("retire");
-  });
-
-  test("stays quiet on a store with no custom actions, which is most of them", async () => {
-    const root = await makeWorkspace({
-      "libs/shared/lib/post/post.store.ts": storeOf(`  // action`),
-      "libs/shared/lib/post/post.dictionary.ts": `export const dictionary = modelDictionary(["en", "ko"]);\n`,
-    });
-
-    expect(rulesOf(await new AkanQualityScanner().scan(root), "akan.agent.missing-store-description")).toHaveLength(0);
-  });
-});
-
 describe("AkanQualityScanner layout rules", () => {
   test("flags an unknown app root file but not a facet entrypoint", async () => {
     const root = await makeWorkspace({

package/qualityScanner.ts

@@ -5,13 +5,11 @@ import { RESERVED_ROUTE_CONFIG_EXPORTS } from "akanjs/common";
 import ignore from "ignore";
 import ts from "typescript";
 import { AbstractDoc } from "./abstractDoc";
-import { McpScanner } from "./mcpScanner";
 import { formatSsrBalance, type SsrBalanceEntry, SsrScanner } from "./ssrScanner";
-import { StoreScanner } from "./storeScanner";
 import { appRootAllowedFiles, libFacetRootAllowedFiles } from "./workspaceLayout";
 
 type QualitySeverity = "warning";
-type QualityScope = "global" | "file" | "convention" | "layout" | "ssr" | "mcp" | "agent";
+type QualityScope = "global" | "file" | "convention" | "layout" | "ssr";
 
 export interface QualityWarning {
   rule: string;
@@ -146,12 +144,6 @@ const RULE_FIXES: Record<string, string> = {
     "Add a <Model>.Unit.tsx for list/card rendering and a <Model>.View.tsx for the detail surface, then have the Zone delegate to them.",
   "akan.ssr.template-client-state":
     "Bind the field to the store instead: `value={xForm.field}` with `onChange={st.do.setFieldOnX}`.",
-  "akan.mcp.missing-description":
-    "Add `.desc([en, ko])` to this entry in the module's dictionary — for a slice, either on the slice entry or on the `<model>List<Slice>` endpoint it generates. Describe when to reach for it, not what it is named.",
-  "akan.agent.missing-store-description":
-    "Add the action to the module dictionary's `.store()` stage with a `.desc([en, ko])` saying what it does for the user — not what the endpoint it calls does. That stage is optional everywhere else: an action named after its endpoint already reads as that endpoint's description.",
-  "akan.mcp.unguarded-exposure":
-    "Name the guards in the same option object as `mcp`: `init({ guards: [SignedIn], mcp: { expose: true } })`. Write `guards: [Public]` if anonymous reads are the intent — the access is the same, but only one of the two is a decision. The `slice()` call's guards map reaches the root slice and base CRUD, never a named slice.",
 };
 
 function getRuleFix(rule: string): string | undefined {
@@ -182,8 +174,6 @@ export class AkanQualityScanner {
       ...sourceFiles.flatMap((sourceFile) => this.#scanLayoutQuality(sourceFile)),
       ...abstractFiles.flatMap((abstractFile) => this.#scanAbstractQuality(abstractFile)),
       ...ssr.warnings,
-      ...new McpScanner().scan(sourceFiles),
-      ...new StoreScanner().scan(sourceFiles),
     ];
 
     return {

package/transforms/externalizeFrameworkPlugin.ts

@@ -65,7 +65,6 @@ const DEFAULT_EXCLUDE_PREFIX = ["@akanjs/cli/", "@akanjs/devkit/"];
 const OPTIONAL_BACKEND_EXTERNAL_EXACT = new Set<string>([
   "@libsql/client",
   "bullmq",
-  "croner",
   "ioredis",
   "postgres",
   "protobufjs",

package/mcpScanner.ts

@@ -1,217 +0,0 @@
-import path from "node:path";
-import ts from "typescript";
-import type { QualityWarning, SourceFileInfo } from "./qualityScanner";
-
-interface ExposedDeclaration {
-  name: string;
-  kind: "endpoint" | "slice";
-  line: number;
-  /** `unknown` when the option object holds a spread, where a `guards` key may arrive from somewhere unreadable. */
-  guards: "declared" | "missing" | "unknown";
-}
-
-/**
- * Checks the two things about an MCP exposure that source alone can answer: that it carries a description an agent
- * can act on, and that somebody decided who may call it.
- *
- * A tool's name and argument names are the only other thing a model sees, and neither says what the tool is for
- * or when to reach for it. An undescribed tool is not merely undocumented — it is a tool the model will either
- * skip or call wrongly, so this rides with the exposure decision rather than with general dictionary hygiene.
- *
- * Guards are here because the omission is *syntactic*: the `guards` key sits in the same option literal as
- * `mcp: { expose: true }`, and a named slice inherits nothing from the `slice()` call's own guards map. So the
- * shape that publishes an unguarded read without anyone writing it down is visible in the file, with no resolved
- * types needed — which is what makes it worth checking here rather than only in a boot log.
- *
- * The generated CRUD a slice opts in through `mcp: { get: true }` is checked by neither rule: none of those
- * entries has text of its own to leave out, so each borrows the model's — the `.of()` label as a title, the model
- * `.desc()` appended to the framework's "Get X" as a description — and each takes the `slice()` guards map, which
- * is the one place those guards do reach.
- *
- * It reads source, so it finds `mcp: { expose: true }` only where an author writes it as a literal inside the
- * `slice(` / `endpoint(` call — an option hoisted to a `const`, or an `expose: flag`, is invisible to it. Right
- * for a warning that must not fire on something it merely failed to resolve, but it makes a clean scan "nothing
- * obviously wrong" rather than "everything exposed is described and guarded". The complete answer is the boot log:
- * `McpRouter.report()` holds the resolved catalogue and names every published entry with no description and every
- * one with no guards, generated entries included — and the refusals, which turn on a resolved return type and so
- * are the one class this file could never see.
- */
-export class McpScanner {
-  scan(sourceFiles: SourceFileInfo[]): QualityWarning[] {
-    const dictionaries = new Map(
-      sourceFiles
-        .filter((sourceFile) => sourceFile.file.endsWith(".dictionary.ts"))
-        .map((sourceFile) => [path.dirname(sourceFile.file), sourceFile]),
-    );
-    return sourceFiles
-      .filter((sourceFile) => sourceFile.file.endsWith(".signal.ts"))
-      .flatMap((sourceFile) => this.#scanSignal(sourceFile, dictionaries.get(path.dirname(sourceFile.file))));
-  }
-
-  #scanSignal(signal: SourceFileInfo, dictionary: SourceFileInfo | undefined): QualityWarning[] {
-    const exposed = McpScanner.#exposedDeclarations(signal);
-    if (!exposed.length) return [];
-    const refName = path.basename(signal.file, ".signal.ts").replace(/^_+/, "");
-    const described = dictionary ? McpScanner.#describedEntries(dictionary) : new Map<string, Set<string>>();
-    return [
-      ...exposed
-        .filter(({ name, kind }) => !McpScanner.#isDescribed(described, refName, name, kind))
-        .map(({ name, kind, line }) => ({
-          rule: "akan.mcp.missing-description",
-          scope: "mcp" as const,
-          severity: "warning" as const,
-          file: signal.file,
-          line,
-          message: `MCP-exposed ${kind} "${name}" has no dictionary .desc(); an agent sees its name and nothing else.`,
-        })),
-      ...exposed
-        .filter(({ guards }) => guards === "missing")
-        .map(({ name, kind, line }) => ({
-          rule: "akan.mcp.unguarded-exposure",
-          scope: "mcp" as const,
-          severity: "warning" as const,
-          file: signal.file,
-          line,
-          message: `MCP-exposed ${kind} "${name}" declares no guards; a slice's guards map never reaches a named slice.`,
-        })),
-    ];
-  }
-
-  static #isDescribed(described: Map<string, Set<string>>, refName: string, name: string, kind: string) {
-    if (described.get(kind)?.has(name)) return true;
-    // A slice may instead be described through the endpoint it generates, which is how a dictionary that wants
-    // separate wording for the list reads (`bannerListInPublic`).
-    return kind === "slice" && !!described.get("endpoint")?.has(`${refName}List${McpScanner.#capitalize(name)}`);
-  }
-
-  /** Names declared with `mcp: { expose: true }`, keyed by whether they sit in the slice or endpoint builder. */
-  static #exposedDeclarations(signal: SourceFileInfo): ExposedDeclaration[] {
-    const found: ExposedDeclaration[] = [];
-    const visit = (node: ts.Node) => {
-      if (McpScanner.#isExposeOption(node)) {
-        const declaration = McpScanner.#enclosingDeclaration(node, signal.sourceFile);
-        if (declaration) found.push(declaration);
-      }
-      ts.forEachChild(node, visit);
-    };
-    visit(signal.sourceFile);
-    return found;
-  }
-
-  static #isExposeOption(node: ts.Node) {
-    if (!ts.isPropertyAssignment(node) || McpScanner.#propertyName(node) !== "mcp") return false;
-    if (!ts.isObjectLiteralExpression(node.initializer)) return false;
-    return node.initializer.properties.some(
-      (property) =>
-        ts.isPropertyAssignment(property) &&
-        McpScanner.#propertyName(property) === "expose" &&
-        property.initializer.kind === ts.SyntaxKind.TrueKeyword,
-    );
-  }
-
-  /**
-   * The name is the property holding the builder chain the option sits in — `inCategory: init({ mcp })…` or
-   * `echoTitle: builder.query(String, { mcp })…` — and the kind is the factory that property is declared inside.
-   * Reading the kind from the factory rather than from the chain's first identifier keeps it right when a slice
-   * callback names its parameter something other than `init`.
-   */
-  static #enclosingDeclaration(option: ts.Node, sourceFile: ts.SourceFile): ExposedDeclaration | null {
-    let declaration: ts.PropertyAssignment | null = null;
-    for (let node = option.parent; node; node = node.parent) {
-      if (!declaration && ts.isPropertyAssignment(node)) {
-        declaration = node;
-        continue;
-      }
-      const kind = McpScanner.#factoryKind(node);
-      if (!kind || !declaration) continue;
-      const name = McpScanner.#propertyName(declaration);
-      if (!name) return null;
-      const line = sourceFile.getLineAndCharacterOfPosition(declaration.getStart(sourceFile)).line + 1;
-      return { name, kind, line, guards: McpScanner.#guardState(option) };
-    }
-    return null;
-  }
-
-  /**
-   * Read off the literal the `mcp` option sits in, which is the same literal `guards` belongs to — `init({ guards,
-   * mcp })`, `query(cnst.X, { guards, mcp })`. A spread in there makes the answer unreadable rather than missing,
-   * and a warning that fires on what it merely failed to resolve is worse than one that stays quiet.
-   */
-  static #guardState(option: ts.Node): ExposedDeclaration["guards"] {
-    const options = option.parent;
-    if (!ts.isObjectLiteralExpression(options)) return "unknown";
-    if (options.properties.some((property) => ts.isSpreadAssignment(property))) return "unknown";
-    return options.properties.some(
-      (property) => ts.isPropertyAssignment(property) && McpScanner.#propertyName(property) === "guards",
-    )
-      ? "declared"
-      : "missing";
-  }
-
-  static #factoryKind(node: ts.Node): ExposedDeclaration["kind"] | null {
-    if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) return null;
-    const factory = node.expression.text;
-    return factory === "slice" || factory === "endpoint" ? factory : null;
-  }
-
-  /** Entry names that carry a `.desc()`, per dictionary stage. */
-  static #describedEntries(dictionary: SourceFileInfo): Map<string, Set<string>> {
-    const described = new Map<string, Set<string>>();
-    const visit = (node: ts.Node) => {
-      const stage = McpScanner.#dictionaryStage(node);
-      if (stage) {
-        for (const [name, chain] of McpScanner.#stageEntries(node as ts.CallExpression)) {
-          if (!chain.has("desc")) continue;
-          const names = described.get(stage) ?? new Set<string>();
-          names.add(name);
-          described.set(stage, names);
-        }
-      }
-      ts.forEachChild(node, visit);
-    };
-    visit(dictionary.sourceFile);
-    return described;
-  }
-
-  static #dictionaryStage(node: ts.Node) {
-    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) return null;
-    const stage = node.expression.name.text;
-    return stage === "endpoint" || stage === "slice" ? stage : null;
-  }
-
-  static #stageEntries(stage: ts.CallExpression): Array<[string, Set<string>]> {
-    const callback = stage.arguments[0];
-    if (!callback || !ts.isArrowFunction(callback)) return [];
-    const body = ts.isParenthesizedExpression(callback.body) ? callback.body.expression : callback.body;
-    if (!ts.isObjectLiteralExpression(body)) return [];
-    return body.properties.flatMap((property) => {
-      if (!ts.isPropertyAssignment(property)) return [];
-      const name = McpScanner.#propertyName(property);
-      return name ? [[name, McpScanner.#chainCalls(property.initializer)] as [string, Set<string>]] : [];
-    });
-  }
-
-  /**
-   * Only the calls on the entry's own chain. A nested `.arg((t) => ({ x: t([…]).desc([…]) }))` describes an
-   * argument, not the entry, so a subtree walk would read every entry as described.
-   */
-  static #chainCalls(expression: ts.Expression): Set<string> {
-    const calls = new Set<string>();
-    let current: ts.Node = expression;
-    while (ts.isCallExpression(current) || ts.isPropertyAccessExpression(current)) {
-      if (ts.isPropertyAccessExpression(current)) calls.add(current.name.text);
-      current = current.expression;
-    }
-    return calls;
-  }
-
-  static #propertyName(property: ts.PropertyAssignment) {
-    const { name } = property;
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
-    return null;
-  }
-
-  static #capitalize(value: string) {
-    return value.charAt(0).toUpperCase() + value.slice(1);
-  }
-}

package/storeScanner.ts

@@ -1,173 +0,0 @@
-import path from "node:path";
-import ts from "typescript";
-import type { QualityWarning, SourceFileInfo } from "./qualityScanner";
-
-interface CustomAction {
-  name: string;
-  line: number;
-  /** The endpoints this action calls as `fetch.<name>`. Empty means it never leaves the client. */
-  fetched: string[];
-}
-
-/**
- * Checks that a store action an agent can reach says what it does, in the one place this codebase lets it.
- *
- * A store is the surface an in-page agent drives — it reads state through `st.use.*` and acts through `st.do.*` —
- * and an action's name and argument types are the only other thing it sees. Unlike a signal, a store has no
- * builder metadata and no room for prose: the house rules ban JSDoc, and every string a person reads goes through
- * `l()`. So the dictionary's `.store()` stage is the only legal channel for the sentence, and this is the check
- * that it exists where it is actually needed.
- *
- * Three kinds of action are deliberately quiet, because a warning nobody should act on teaches people to ignore
- * the rest:
- *
- *  - **Generated actions** (`createX`, `setFieldOnX`, `initXInY`, …) are not in the file at all. Their wording is
- *    derived from the model's own labels, so there is nothing for an author to write.
- *  - **An action that calls no `fetch.*`** stays on the client and is not published, so its description would be
- *    read by nobody.
- *  - **An action named after the endpoint it calls** already reads as that endpoint's `.desc()`. That is most of
- *    them, and not by accident — the naming rule is that `st.do.X` reads the same as `fetch.X`.
- *
- * What is left is the case where inheriting would be *wrong* rather than merely absent: nine `getSummaryListIn*`
- * actions that all call one `summaryListInPeriod`, where the difference between them is the whole point of having
- * nine; or `logout` over `signoutUser`, where the store name is the verb a user would say and the endpoint name is
- * the verb the API has. Those are the ones a person has to write.
- *
- * It reads source, so an action that reaches its endpoint through anything but a literal `fetch.<name>` — a
- * destructured `fetch`, a helper, a computed key — reads as calling none and stays quiet. Right for a warning that
- * must not fire on what it merely failed to resolve.
- */
-export class StoreScanner {
-  scan(sourceFiles: SourceFileInfo[]): QualityWarning[] {
-    const dictionaries = new Map(
-      sourceFiles
-        .filter((sourceFile) => sourceFile.file.endsWith(".dictionary.ts"))
-        .map((sourceFile) => [path.dirname(sourceFile.file), sourceFile]),
-    );
-    return sourceFiles
-      .filter((sourceFile) => sourceFile.file.endsWith(".store.ts"))
-      .flatMap((sourceFile) => this.#scanStore(sourceFile, dictionaries.get(path.dirname(sourceFile.file))));
-  }
-
-  #scanStore(store: SourceFileInfo, dictionary: SourceFileInfo | undefined): QualityWarning[] {
-    const actions = StoreScanner.#customActions(store);
-    if (!actions.length) return [];
-    const described = dictionary ? StoreScanner.#describedEntries(dictionary) : new Map<string, Set<string>>();
-    return actions
-      .filter(({ name, fetched }) => fetched.length && !fetched.includes(name))
-      .filter(({ name }) => !described.get("store")?.has(name) && !described.get("endpoint")?.has(name))
-      .map(({ name, line, fetched }) => ({
-        rule: "akan.agent.missing-store-description",
-        scope: "agent" as const,
-        severity: "warning" as const,
-        file: store.file,
-        line,
-        message: `Store action "${name}" calls ${fetched.map((key) => `${key}()`).join(", ")} under a different name and has no dictionary .store() entry, so an agent reading it has the name and nothing else.`,
-      }));
-  }
-
-  /** Methods written in the store class body. Generated actions never appear here, which is why they are exempt. */
-  static #customActions(store: SourceFileInfo): CustomAction[] {
-    const actions: CustomAction[] = [];
-    const visit = (node: ts.Node) => {
-      if (ts.isClassDeclaration(node) && StoreScanner.#extendsStore(node)) {
-        for (const member of node.members) {
-          // A getter computes rather than dispatches, and a static helper is not on `st.do` at all.
-          if (!ts.isMethodDeclaration(member)) continue;
-          if (member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword)) continue;
-          const name = StoreScanner.#memberName(member);
-          if (!name) continue;
-          const line = store.sourceFile.getLineAndCharacterOfPosition(member.getStart(store.sourceFile)).line + 1;
-          actions.push({ name, line, fetched: StoreScanner.#fetchedEndpoints(member) });
-        }
-      }
-      ts.forEachChild(node, visit);
-    };
-    visit(store.sourceFile);
-    return actions;
-  }
-
-  static #extendsStore(node: ts.ClassDeclaration) {
-    return !!node.heritageClauses?.some((clause) =>
-      clause.types.some((type) => ts.isCallExpression(type.expression) && StoreScanner.#isStoreCall(type.expression)),
-    );
-  }
-
-  static #isStoreCall(expression: ts.CallExpression) {
-    return ts.isIdentifier(expression.expression) && expression.expression.text === "store";
-  }
-
-  /** The `fetch.<name>` calls inside one action, which is what says whether it is reachable past the client. */
-  static #fetchedEndpoints(member: ts.MethodDeclaration): string[] {
-    const fetched = new Set<string>();
-    const visit = (node: ts.Node) => {
-      if (
-        ts.isCallExpression(node) &&
-        ts.isPropertyAccessExpression(node.expression) &&
-        ts.isIdentifier(node.expression.expression) &&
-        node.expression.expression.text === "fetch"
-      )
-        fetched.add(node.expression.name.text);
-      ts.forEachChild(node, visit);
-    };
-    visit(member);
-    return [...fetched];
-  }
-
-  /** Entry names that carry a `.desc()`, per dictionary stage. */
-  static #describedEntries(dictionary: SourceFileInfo): Map<string, Set<string>> {
-    const described = new Map<string, Set<string>>();
-    const visit = (node: ts.Node) => {
-      const stage = StoreScanner.#dictionaryStage(node);
-      if (stage) {
-        for (const [name, chain] of StoreScanner.#stageEntries(node as ts.CallExpression)) {
-          if (!chain.has("desc")) continue;
-          const names = described.get(stage) ?? new Set<string>();
-          names.add(name);
-          described.set(stage, names);
-        }
-      }
-      ts.forEachChild(node, visit);
-    };
-    visit(dictionary.sourceFile);
-    return described;
-  }
-
-  static #dictionaryStage(node: ts.Node) {
-    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) return null;
-    const stage = node.expression.name.text;
-    return stage === "store" || stage === "endpoint" ? stage : null;
-  }
-
-  static #stageEntries(stage: ts.CallExpression): Array<[string, Set<string>]> {
-    const callback = stage.arguments[0];
-    if (!callback || !ts.isArrowFunction(callback)) return [];
-    const body = ts.isParenthesizedExpression(callback.body) ? callback.body.expression : callback.body;
-    if (!ts.isObjectLiteralExpression(body)) return [];
-    return body.properties.flatMap((property) => {
-      if (!ts.isPropertyAssignment(property)) return [];
-      const name = StoreScanner.#memberName(property);
-      return name ? [[name, StoreScanner.#chainCalls(property.initializer)] as [string, Set<string>]] : [];
-    });
-  }
-
-  /**
-   * Only the calls on the entry's own chain. A nested `.arg((t) => ({ x: t([…]).desc([…]) }))` describes an
-   * argument, not the entry, so a subtree walk would read every entry as described.
-   */
-  static #chainCalls(expression: ts.Expression): Set<string> {
-    const calls = new Set<string>();
-    let current: ts.Node = expression;
-    while (ts.isCallExpression(current) || ts.isPropertyAccessExpression(current)) {
-      if (ts.isPropertyAccessExpression(current)) calls.add(current.name.text);
-      current = current.expression;
-    }
-    return calls;
-  }
-
-  static #memberName(member: ts.MethodDeclaration | ts.PropertyAssignment) {
-    const { name } = member;
-    if (!name || (!ts.isIdentifier(name) && !ts.isStringLiteral(name))) return null;
-    return name.text;
-  }
-}