@akanjs/devkit 3.1.1-rc.9 → 3.1.2-rc.0

package/envSeed.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { EnvSeed } from "./envSeed";
+import { tempDirs, writeText } from "./testHelpers";
+
+const makeEnvDir = tempDirs("akan-env-seed-");
+const templates = path.resolve(import.meta.dir, "../cli/templates");
+const template = async (file: string) => await readFile(path.join(templates, file), "utf8");
+
+const selector = (side: "server" | "client", names: string[]) =>
+  `${names.map((name) => `import { env as ${name} } from "./env.${side}.${name}";`).join("\n")}\n\nexport const env = { ${names.join(", ")} };\n`;
+
+const seededIn = async (envDir: string) =>
+  Object.fromEntries((await new EnvSeed(envDir).missing()).map(({ fileName, content }) => [fileName, content]));
+
+describe("EnvSeed", () => {
+  test("names each environment file the selectors import and the testing one, of those missing", async () => {
+    const envDir = await makeEnvDir();
+    await writeText(path.join(envDir, "env.server.ts"), selector("server", ["debug", "local"]));
+    await writeText(path.join(envDir, "env.client.ts"), selector("client", ["local", "staging"]));
+    await writeText(path.join(envDir, "env.server.debug.ts"), "export const env = { kept: true };\n");
+
+    expect(Object.keys(await seededIn(envDir))).toEqual([
+      "env.client.local.ts",
+      "env.client.staging.ts",
+      "env.server.local.ts",
+      "env.server.testing.ts",
+    ]);
+  });
+
+  test("passes over the generated type, the tracked example and a build profile", async () => {
+    const envDir = await makeEnvDir();
+    await writeText(
+      path.join(envDir, "env.server.ts"),
+      [
+        'import { libEnv } from "./env.server.type";',
+        'import { env as example } from "./env.server.example";',
+        'import { env as desktop } from "./env.server.debug.desktop";',
+        "",
+        "export const env = { ...libEnv, ...example, ...desktop };",
+        "",
+      ].join("\n"),
+    );
+
+    expect(Object.keys(await seededIn(envDir))).toEqual(["env.server.testing.ts"]);
+  });
+
+  test("writes what the app scaffold writes when the folder has no example", async () => {
+    const envDir = await makeEnvDir();
+    await writeText(path.join(envDir, "env.server.ts"), selector("server", ["local", "testing"]));
+    await writeText(path.join(envDir, "env.client.ts"), selector("client", ["local"]));
+    await writeText(path.join(envDir, "env.client.type.ts"), "export type AppClientEnv = Record<never, never>;\n");
+
+    expect(await seededIn(envDir)).toEqual({
+      "env.client.local.ts": await template("app/env/env.client.local.ts.template"),
+      "env.server.local.ts": await template("app/env/env.server.local.ts.template"),
+      "env.server.testing.ts": await template("app/env/env.server.testing.ts.template"),
+    });
+  });
+
+  test("copies the side's tracked example into each of its files", async () => {
+    const envDir = await makeEnvDir();
+    const example =
+      'import type { ModulesOptions } from "../lib/option";\n\nexport const env: ModulesOptions = { port: 1 };\n';
+    await writeText(path.join(envDir, "env.server.ts"), selector("server", ["local"]));
+    await writeText(path.join(envDir, "env.server.example.ts"), example);
+
+    expect(await seededIn(envDir)).toEqual({ "env.server.local.ts": example, "env.server.testing.ts": example });
+  });
+
+  test("leaves a client env untyped when the folder has no env.client.type.ts to type it", async () => {
+    const envDir = await makeEnvDir();
+    await writeText(path.join(envDir, "env.client.ts"), selector("client", ["local"]));
+
+    expect((await seededIn(envDir))["env.client.local.ts"]).toBe("export const env = {};\n");
+  });
+
+  test("gives a lib its testing env from the example the lib scaffold tracks", async () => {
+    const envDir = await makeEnvDir();
+    await writeText(
+      path.join(envDir, "env.server.example.ts"),
+      await template("libRoot/env/env.server.example.ts.template"),
+    );
+
+    expect(await seededIn(envDir)).toEqual({
+      "env.server.testing.ts": await template("libRoot/env/env.server.testing.ts.template"),
+    });
+  });
+});

package/envSeed.ts

@@ -0,0 +1,68 @@
+import path from "node:path";
+import { FileSys } from "./fileSys";
+
+export interface EnvSeedFile {
+  fileName: string;
+  content: string;
+}
+
+//? These files are gitignored for the secrets they hold, so a fresh clone has none of them.
+export class EnvSeed {
+  static readonly #server = `import type { ModulesOptions } from "../lib/option";
+
+export const env: ModulesOptions = {};
+`;
+  static readonly #testingServer = `import type { ModulesOptions } from "../lib/option";
+import { libEnv } from "./env.server.type";
+
+export const env: ModulesOptions = {
+  ...libEnv,
+};
+`;
+  static readonly #client = `import type { AppClientEnv } from "./env.client.type";
+
+export const env: AppClientEnv = {};
+`;
+  static readonly #untypedClient = "export const env = {};\n";
+  static readonly #selectors = ["env.server.ts", "env.client.ts"];
+  //? `type` is generated and `example` tracked; a dotted name (`debug.desktop`) is a build profile no selector imports.
+  static readonly #selectedPattern = /^\.\/(env\.(?:server|client)\.(?!(?:type|example)$)[\w-]+)$/;
+  //? A lib's server.ts and the signal test runtime import it by name, whatever the selector imports.
+  static readonly #testing = "env.server.testing.ts";
+
+  readonly #envDir: string;
+  constructor(envDir: string) {
+    this.#envDir = envDir;
+  }
+
+  async missing(): Promise<EnvSeedFile[]> {
+    const wanted = [...new Set([EnvSeed.#testing, ...(await this.#selected())])].sort();
+    const exists = await Promise.all(wanted.map((fileName) => FileSys.fileExists(path.join(this.#envDir, fileName))));
+    const missing = wanted.filter((_, idx) => !exists[idx]);
+    return await Promise.all(missing.map(async (fileName) => ({ fileName, content: await this.#contentOf(fileName) })));
+  }
+
+  async #selected() {
+    const transpiler = new Bun.Transpiler({ loader: "ts" });
+    const selected = await Promise.all(
+      EnvSeed.#selectors.map(async (selector) => {
+        const file = path.join(this.#envDir, selector);
+        if (!(await FileSys.fileExists(file))) return [];
+        return transpiler
+          .scan(await FileSys.readText(file))
+          .imports.flatMap(({ path: specifier }) => specifier.match(EnvSeed.#selectedPattern)?.[1] ?? [])
+          .map((name) => `${name}.ts`);
+      }),
+    );
+    return selected.flat();
+  }
+
+  async #contentOf(fileName: string) {
+    const side = fileName.startsWith("env.client.") ? "client" : "server";
+    const example = path.join(this.#envDir, `env.${side}.example.ts`);
+    if (await FileSys.fileExists(example)) return await FileSys.readText(example);
+    if (side === "server") return fileName === EnvSeed.#testing ? EnvSeed.#testingServer : EnvSeed.#server;
+    const typed = await FileSys.fileExists(path.join(this.#envDir, "env.client.type.ts"));
+    return typed ? EnvSeed.#client : EnvSeed.#untypedClient;
+  }
+}

package/executors.test.ts

@@ -275,10 +275,6 @@ describe("Executor filesystem helpers", () => {
       "Akan workspace agent guide",
     );
     expect(await readFile(path.join(root, "workspace/AGENTS.md"), "utf8")).toContain("sample Agent Guide");
-    expect(await readFile(path.join(root, "workspace/docs/AI-DEVELOPMENT.md"), "utf8")).toContain(
-      "AI Development Guide",
-    );
-    expect(await readFile(path.join(root, "workspace/docs/GENERATED.md"), "utf8")).toContain("Generated Akan Files");
     // Rules live in the package's base config, so a framework release reaches an existing workspace on `bun update`.
     expect(await readFile(path.join(root, "workspace/biome.json"), "utf8")).toContain(
       '"extends": ["@akanjs/devkit/biome.base.json"]',
@@ -380,6 +376,23 @@ describe("Workspace and app executor environment contracts", () => {
     });
   });
 
+  test("a workspace with no .env, as a fresh clone has, runs local unless the shell names an environment", async () => {
+    const root = await makeTempRoot();
+    delete process.env.AKAN_PUBLIC_ENV;
+
+    WorkspaceExecutor.defaultCloneToLocalEnv(root);
+    expect(WorkspaceExecutor.getBaseDevEnv(path.join(root, ".env")).env).toBe("local");
+
+    process.env.AKAN_PUBLIC_ENV = "main";
+    WorkspaceExecutor.defaultCloneToLocalEnv(root);
+    expect(process.env.AKAN_PUBLIC_ENV).toBe("main");
+
+    delete process.env.AKAN_PUBLIC_ENV;
+    await writeFile(path.join(root, ".env"), "AKAN_PUBLIC_REPO_NAME=repo\n");
+    WorkspaceExecutor.defaultCloneToLocalEnv(root);
+    expect(WorkspaceExecutor.getBaseDevEnv(path.join(root, ".env")).env).toBe("debug");
+  });
+
   test("a build or tunnel for a real environment refuses a defaulted value, and a local one takes it", () => {
     const baseDevEnv = {
       repoName: "fixture-repo",
@@ -1309,7 +1322,8 @@ const createScannableLib = async (
   await writeJson(path.join(libDir, "tsconfig.json"), { compilerOptions: { target: "ESNext", paths: {} } });
   await writeText(path.join(libDir, "akan.config.ts"), config);
   await mkdir(path.join(libDir, "lib", "__scalar"), { recursive: true });
-  for (const [file, content] of Object.entries(files)) await writeText(path.join(libDir, file), content);
+  const libFiles = { "env/env.server.testing.ts": "export const env = {};\n", ...files };
+  for (const [file, content] of Object.entries(libFiles)) await writeText(path.join(libDir, file), content);
   return { ...temp, libDir };
 };
 

package/executors.ts

@@ -44,11 +44,13 @@ import {
 import { AkanAppConfig, AkanLibConfig, AkanWorkspaceConfig, decreaseBuildNum, increaseBuildNum } from "./akanConfig";
 import { getRootBoundarySegments, isRootBoundarySegments } from "./artifact/implicitRootLayout";
 import { CodegenLock } from "./codegenLock";
+import { EnvSeed } from "./envSeed";
 import { FileSys, getDirname } from "./fileSys";
 import { JsonFormatter } from "./jsonFormatter";
 import { Linter } from "./linter";
 import { ManifestDependencies } from "./manifestDependencies";
 import { resolveRepoName } from "./repoIdentity";
+import type { RouteSourceInfo } from "./routeSourceValidator";
 import { AppInfo, isAkanFrameworkDependency, LibInfo, PkgInfo, WorkspaceInfo } from "./scanInfo";
 import { Spinner } from "./spinner";
 // Type-only: `getTypeChecker` loads it on demand to keep `typescript` out of the resident module graph.
@@ -66,6 +68,12 @@ export interface PageRoot {
   keyPrefix: string;
 }
 
+export interface AppRouteSource {
+  key: string;
+  absPath: string;
+  info: RouteSourceInfo;
+}
+
 export interface WrittenFileContent extends FileContent {
   written: boolean;
 }
@@ -422,11 +430,13 @@ export class Executor {
       targetPath,
       scanInfo,
       overwrite = true,
+      dryRun = false,
     }: {
       templatePath: string;
       targetPath: string;
       scanInfo?: AppInfo | LibInfo | null;
       overwrite?: boolean;
+      dryRun?: boolean;
     },
     dict: { [key: string]: string } = {},
     options: { [key: string]: unknown } = {},
@@ -449,6 +459,7 @@ export class Executor {
       const filename = typeof result === "object" ? result.filename : path.basename(targetPath).replace(".js", ".ts");
       const content = typeof result === "object" ? result.content : result;
       const convertedTargetPath = convertPath(`${path.dirname(targetPath)}/${filename}`);
+      if (dryRun) return { filePath: this.getPath(convertedTargetPath), content, written: false };
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       return this.writeFile(convertedTargetPath, content, { overwrite });
     } else if (targetPath.endsWith(".template")) {
@@ -458,11 +469,13 @@ export class Executor {
         (data, [key, value]) => data.replace(new RegExp(`<%= ${key} %>`, "g"), value),
         content,
       );
+      if (dryRun) return { filePath: this.getPath(convertedTargetPath), content: convertedContent, written: false };
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       return this.writeFile(convertedTargetPath, convertedContent, { overwrite });
     } else if (staticTemplateFileExtensions.has(path.extname(targetPath).toLowerCase())) {
       const convertedTargetPath = convertPath(targetPath);
       const writePath = this.getPath(convertedTargetPath);
+      if (dryRun) return { filePath: writePath, content: "", written: false };
       if (!overwrite && (await FileSys.fileExists(writePath)))
         return { filePath: writePath, content: "", written: false };
       const dirname = path.dirname(writePath);
@@ -479,6 +492,7 @@ export class Executor {
     dict = {},
     options = {},
     overwrite = true,
+    dryRun = false,
   }: {
     basePath: string;
     template: string;
@@ -486,6 +500,7 @@ export class Executor {
     dict?: { [key: string]: string };
     options?: { [key: string]: unknown };
     overwrite?: boolean;
+    dryRun?: boolean;
   }): Promise<WrittenFileContent[]> {
     const templateRoot = await this.#resolveTemplateRoot();
     const templatePath = `${templateRoot}${template ? `/${template}` : ""}`;
@@ -496,6 +511,7 @@ export class Executor {
           targetPath: path.join(basePath, path.basename(templatePath)),
           scanInfo,
           overwrite,
+          dryRun,
         },
         dict,
         options,
@@ -514,6 +530,7 @@ export class Executor {
                   targetPath: path.join(basePath, subdir),
                   scanInfo,
                   overwrite,
+                  dryRun,
                 },
                 dict,
                 options,
@@ -526,6 +543,7 @@ export class Executor {
                 scanInfo,
                 dict,
                 overwrite,
+                dryRun,
                 options,
               });
           }),
@@ -551,14 +569,15 @@ export class Executor {
     dict?: { [key: string]: string };
     options?: { [key: string]: unknown };
     overwrite?: boolean;
+    dryRun?: boolean;
   }): Promise<FileContent[]> {
     const fileContents = await this._applyTemplate({ ...options, dict: withCapitalizedDict(options.dict) });
     await this.#formatAppliedTemplate(fileContents.filter((fileContent) => fileContent.written));
     return fileContents;
   }
 
-  // A template cannot sort the identifiers it emits (`Task` vs `Zoo`). Best-effort: `create-akan-workspace`
-  // scaffolds before `bun install`, with no local Biome binary yet.
+  // Best-effort: `create-akan-workspace` scaffolds before `bun install`, with no local Biome binary yet, so a
+  // template emits Biome's form itself (`templates/biomeForm.ts`).
   async #formatAppliedTemplate(fileContents: FileContent[]) {
     const filePaths = fileContents
       .map((fileContent) => fileContent.filePath)
@@ -705,6 +724,10 @@ export class WorkspaceExecutor extends Executor {
       defaulted,
     };
   }
+  //? A clone has no `.env` (gitignored for its secrets): it runs local, as a new workspace and env.server.ts do, not debug.
+  static defaultCloneToLocalEnv(workspaceRoot: string) {
+    if (!existsSync(path.join(workspaceRoot, ".env"))) process.env.AKAN_PUBLIC_ENV ??= "local";
+  }
   //? A build or tunnel for a real environment carries these into an image, a bundle or a host name it dials.
   static assertDeployableEnv(baseDevEnv: BaseDevEnv, environment: string, purpose: string) {
     const defaulted = environment === "local" ? [] : (baseDevEnv.defaulted ?? []);
@@ -797,11 +820,19 @@ export class WorkspaceExecutor extends Executor {
     };
     return await getDirs(basePath);
   }
-  async commit(message: string, { init = false, add = true }: { init?: boolean; add?: boolean } = {}) {
+  async commit(
+    message: string,
+    {
+      init = false,
+      add = true,
+      identity,
+    }: { init?: boolean; add?: boolean; identity?: { name: string; email: string } } = {},
+  ) {
     if (init) await this.spawn("git", ["init", "--quiet"]);
     if (add) await this.spawn("git", ["add", "."]);
+    const author = identity ? ["-c", `user.name=${identity.name}`, "-c", `user.email=${identity.email}`] : [];
     // Argument vector, not a shell string: a message carrying a double quote breaks the interpolated form.
-    await this.spawn("git", ["commit", "--quiet", "-m", message]);
+    await this.spawn("git", [...author, "commit", "--quiet", "-m", message]);
   }
   /** `git commit` exits non-zero on an empty index, so a re-runnable caller has to ask first. */
   async hasChanges() {
@@ -916,8 +947,23 @@ export class SysExecutor extends Executor {
     if (!this.hasScanInfo() && !allowEmpty) throw new Error("Scan info is not available");
     return this.#scanInfo as AllowEmpty extends true ? AppInfo | LibInfo | null : AppInfo | LibInfo;
   }
+  async #seedEnvFiles(): Promise<FileContent[]> {
+    const envDir = path.join(this.cwdPath, "env");
+    const missing = await new EnvSeed(envDir).missing();
+    if (!missing.length) return [];
+    const written = await Promise.all(
+      missing.map(({ fileName, content }) =>
+        this.writeFile(path.join(envDir, fileName), content, { overwrite: false, silent: true }),
+      ),
+    );
+    this.logger.info(
+      `${missing.map(({ fileName }) => `env/${fileName}`).join(", ")} were missing (gitignored, so a clone has none) and now hold local defaults: put this machine's values in them, or fetch the team's with \`akan download-env\`.`,
+    );
+    return written;
+  }
   #getScanTemplateTasks(scanInfo: AppInfo | LibInfo): (Promise<FileContent[]> | null)[] {
     return [
+      this.#seedEnvFiles(),
       this._applyTemplate({ basePath: "env", template: "env", scanInfo }),
       this._applyTemplate({ basePath: "lib", template: "lib", scanInfo }),
       this._applyTemplate({ basePath: ".", template: "server.ts", scanInfo }),
@@ -1278,6 +1324,7 @@ export class AppExecutor extends SysExecutor {
   }
 
   #pageKeys: string[] | null = null;
+  #routeSources: AppRouteSource[] = [];
   #excludeDevOnlyPages = false;
   async getPageKeys({ refresh }: { refresh?: boolean } = {}): Promise<string[]> {
     if (this.#pageKeys && !refresh) return this.#pageKeys;
@@ -1288,6 +1335,7 @@ export class AppExecutor extends SysExecutor {
     const devOnlyKeys = new Set<string>();
     const devOnlyDirs: string[] = [];
     const pageRoots = await this.getPageRoots();
+    const routeSources: AppRouteSource[] = [];
     const libKeyPrefixes = pageRoots.map((root) => root.keyPrefix).filter(Boolean);
     for (const root of pageRoots) {
       if (!(await FileSys.dirExists(root.dir))) continue;
@@ -1333,6 +1381,7 @@ export class AppExecutor extends SysExecutor {
             rootLayout: isRootLayout,
             pattern: parsed.pattern,
           });
+          routeSources.push({ key, absPath, info });
           if (info.devOnly) {
             devOnlyKeys.add(key);
             //* A dev-only layout takes its whole subtree, or its pages would ship without their chrome.
@@ -1343,9 +1392,15 @@ export class AppExecutor extends SysExecutor {
       }
     }
     pageKeys.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    this.#routeSources = routeSources.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
     this.#pageKeys = this.#excludeDevOnlyPages ? this.#dropDevOnlyPages(pageKeys, devOnlyKeys, devOnlyDirs) : pageKeys;
     return this.#pageKeys;
   }
+  /** Each page and layout file `getPageKeys` read, with what its chain declares; overrides files are not listed. */
+  async getRouteSources({ refresh }: { refresh?: boolean } = {}): Promise<AppRouteSource[]> {
+    await this.getPageKeys({ refresh });
+    return this.#routeSources;
+  }
   #dropDevOnlyPages(pageKeys: string[], devOnlyKeys: Set<string>, devOnlyDirs: string[]): string[] {
     if (!devOnlyKeys.size) return pageKeys;
     const isDevOnly = (key: string) => devOnlyKeys.has(key) || devOnlyDirs.some((dir) => key.startsWith(dir));

package/fileSys.test.ts

@@ -1,7 +1,9 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, spyOn, test } from "bun:test";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { getDirname } from "./fileSys";
+import { FileSys, getDirname } from "./fileSys";
 
 describe("getDirname", () => {
   test("converts file URLs to filesystem paths", () => {
@@ -19,3 +21,29 @@ describe("getDirname", () => {
     expect(dirname).toBe("C:\\Users\\ken78\\.bun\\install\\global\\node_modules\\@akanjs\\devkit");
   });
 });
+
+describe("FileSys.ensurePrivateDir", () => {
+  //? macOS refuses even the owner a chmod of a folder flagged user-immutable; Linux needs root for the same.
+  test.skipIf(process.platform !== "darwin")(
+    "warns instead of throwing when the folder's mode cannot be changed",
+    () => {
+      const root = mkdtempSync(path.join(tmpdir(), "akan-private-dir-"));
+      const dir = path.join(root, "locked");
+      mkdirSync(dir);
+      chmodSync(dir, 0o755);
+      Bun.spawnSync(["chflags", "uchg", dir]);
+      const warn = spyOn(FileSys.logger, "warn").mockImplementation(() => undefined);
+      try {
+        expect(FileSys.ensurePrivateDir(dir)).toBe(dir);
+        expect(statSync(dir).mode & 0o777).toBe(0o755);
+        expect(warn.mock.calls.map(([line]) => String(line))).toEqual([
+          expect.stringContaining(`${dir} stays at mode 755`),
+        ]);
+      } finally {
+        warn.mockRestore();
+        Bun.spawnSync(["chflags", "nouchg", dir]);
+        rmSync(root, { recursive: true, force: true });
+      }
+    },
+  );
+});

package/fileSys.ts

@@ -1,3 +1,4 @@
+import { chmodSync, mkdirSync, statSync } from "node:fs";
 import { lstat, rename, rm, stat } from "node:fs/promises";
 import nodePath from "node:path";
 import { fileURLToPath } from "node:url";
@@ -70,6 +71,19 @@ export class FileSys {
       }
     }
   }
+  //? `mkdir`'s mode only applies to a directory it creates, so one an older build made is tightened here.
+  static ensurePrivateDir(dir: string) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (process.platform === "win32") return dir;
+    const { mode, uid } = statSync(dir);
+    if ((mode & 0o077) === 0 || uid !== process.getuid?.()) return dir;
+    try {
+      chmodSync(dir, 0o700);
+    } catch (error) {
+      FileSys.logger.warn(`${dir} stays at mode ${(mode & 0o777).toString(8)}: ${(error as Error).message}`);
+    }
+    return dir;
+  }
   static async writeJson(path: string, content: object) {
     return await Bun.file(path).write(`${JSON.stringify(content, null, 2)}\n`);
   }

package/formSetterScanner.test.ts

@@ -10,8 +10,26 @@ const fileOf = (file: string, content: string): SourceFileInfo => ({
   sourceFile: ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX),
 });
 
+const taskConstant = fileOf(
+  "apps/demo/lib/task/task.constant.ts",
+  `export class TaskInput extends via((field) => ({
+  title: field(String),
+  type: field(String),
+  phone: field(String),
+  project: field(Project).optional(),
+  members: field([User]),
+})) {}
+
+export class TaskObject extends via(TaskInput, (field) => {
+  return { status: field(String) };
+}) {}
+
+export class TaskInsight extends via(Task, (field) => ({ onSale: field(Int) })) {}
+`,
+);
+
 const scan = (content: string) =>
-  new FormSetterScanner().scan([fileOf("apps/demo/lib/task/Task.Template.tsx", content)]);
+  new FormSetterScanner().scan([taskConstant, fileOf("apps/demo/lib/task/Task.Template.tsx", content)]);
 
 describe("FormSetterScanner", () => {
   test("a setter passed by reference publishes, so nothing is reported", () => {
@@ -73,6 +91,31 @@ describe("FormSetterScanner", () => {
     ).toEqual([]);
   });
 
+  test("a slice setter is not a field setter, though its name reads set…On…", () => {
+    expect(
+      scan(`export const Filters = () => (
+  <Select onChange={(page) => st.do.setPageOfTaskOnSale(page)} />
+);
+`),
+    ).toEqual([]);
+  });
+
+  test("a field is known from its model's constant, so another model's setter is not counted", () => {
+    expect(
+      scan(`export const General = () => (
+  <>
+    <Field.Text onChange={(title) => st.do.setTitleOnProject(title)} />
+    <Field.Text onChange={(onSale) => st.do.setOnSaleOnTask(onSale)} />
+  </>
+);
+`),
+    ).toEqual([]);
+    expect(
+      scan(`export const General = () => <Field.Text onChange={(status) => st.do.setStatusOnTask(status)} />;\n`)[0]
+        ?.message,
+    ).toContain("setStatusOnTask");
+  });
+
   test("only .tsx is scanned", () => {
     const content = `export const set = (v: string) => <X onChange={(t) => st.do.setTitleOnTask(t)} />;\n`;
     expect(new FormSetterScanner().scan([fileOf("apps/demo/lib/task/task.store.ts", content)])).toEqual([]);

package/formSetterScanner.ts

@@ -1,3 +1,4 @@
+import { capitalize, formSetterNames } from "akanjs/common";
 import ts from "typescript";
 import type { QualityWarning, SourceFileInfo } from "./qualityScanner";
 
@@ -5,17 +6,61 @@ import type { QualityWarning, SourceFileInfo } from "./qualityScanner";
 // forwarding wrappers; this counts every field left unpublished whatever the reason. A zero-parameter handler is a
 // button setting a constant, not a form control, so it is not counted.
 export class FormSetterScanner {
-  static #fieldSetter = /^set[A-Za-z0-9_$]*On[A-Za-z0-9_$]*$/;
+  static #constantPath = /(?:^|\/)lib\/([^_/][^/]*)\/\1\.constant\.ts$/;
+  static #baseFields = ["id", "createdAt", "updatedAt", "removedAt"];
 
   scan(sourceFiles: SourceFileInfo[]): QualityWarning[] {
-    return sourceFiles.filter((sourceFile) => sourceFile.file.endsWith(".tsx")).flatMap((f) => this.#scanFile(f));
+    const fieldSetters = FormSetterScanner.#fieldSettersOf(sourceFiles);
+    return sourceFiles
+      .filter((sourceFile) => sourceFile.file.endsWith(".tsx"))
+      .flatMap((f) => this.#scanFile(f, fieldSetters));
   }
 
-  #scanFile({ file, sourceFile }: SourceFileInfo): QualityWarning[] {
+  // Built forward from the constants: matching `set…On…` also caught slice setters such as `setPageOfProductOnSale`.
+  static #fieldSettersOf(sourceFiles: SourceFileInfo[]) {
+    const setters = new Set<string>();
+    for (const { file, sourceFile } of sourceFiles) {
+      const refName = FormSetterScanner.#constantPath.exec(file)?.[1];
+      if (!refName) continue;
+      const className = capitalize(refName);
+      const fullModelClasses = new Set([`${className}Input`, `${className}Object`, `Light${className}`, className]);
+      const keys = new Set(FormSetterScanner.#baseFields);
+      for (const statement of sourceFile.statements)
+        if (ts.isClassDeclaration(statement) && statement.name && fullModelClasses.has(statement.name.text))
+          for (const key of FormSetterScanner.#viaFieldKeysOf(statement)) keys.add(key);
+      for (const key of keys) setters.add(formSetterNames(className, key).setFieldOnModel);
+    }
+    return setters;
+  }
+
+  static #viaFieldKeysOf(declaration: ts.ClassDeclaration): string[] {
+    const via = declaration.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]
+      ?.expression;
+    if (!via || !ts.isCallExpression(via)) return [];
+    return via.arguments.flatMap((argument) => {
+      if (!ts.isArrowFunction(argument) && !ts.isFunctionExpression(argument)) return [];
+      const fields = FormSetterScanner.#returnedObjectOf(argument.body);
+      return (fields?.properties ?? []).flatMap((property) =>
+        property.name && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name))
+          ? [property.name.text]
+          : [],
+      );
+    });
+  }
+
+  static #returnedObjectOf(body: ts.ConciseBody): ts.ObjectLiteralExpression | null {
+    let expression: ts.Node | undefined = body;
+    if (ts.isBlock(body)) expression = body.statements.find(ts.isReturnStatement)?.expression;
+    while (expression && (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression)))
+      expression = expression.expression;
+    return expression && ts.isObjectLiteralExpression(expression) ? expression : null;
+  }
+
+  #scanFile({ file, sourceFile }: SourceFileInfo, fieldSetters: Set<string>): QualityWarning[] {
     const wrapped: { setter: string; line: number }[] = [];
     const visit = (node: ts.Node) => {
       if (ts.isJsxAttribute(node)) {
-        const setter = FormSetterScanner.#wrappedSetterOf(node);
+        const setter = FormSetterScanner.#wrappedSetterOf(node, fieldSetters);
         if (setter) wrapped.push({ setter, line: FormSetterScanner.#lineOf(sourceFile, node) });
       }
       ts.forEachChild(node, visit);
@@ -40,17 +85,17 @@ export class FormSetterScanner {
   }
 
   /** The setter a handler prop writes behind a wrapper, or null when it is passed by reference or absent. */
-  static #wrappedSetterOf(attribute: ts.JsxAttribute): string | null {
+  static #wrappedSetterOf(attribute: ts.JsxAttribute, fieldSetters: Set<string>): string | null {
     if (!ts.isIdentifier(attribute.name) || !/^on[A-Z]/.test(attribute.name.text)) return null;
     const initializer = attribute.initializer;
     if (!initializer || !ts.isJsxExpression(initializer) || !initializer.expression) return null;
     const handler = initializer.expression;
     if (!ts.isArrowFunction(handler) && !ts.isFunctionExpression(handler)) return null;
     if (!handler.parameters.length) return null;
-    return FormSetterScanner.#setterCallIn(handler.body);
+    return FormSetterScanner.#setterCallIn(handler.body, fieldSetters);
   }
 
-  static #setterCallIn(node: ts.Node): string | null {
+  static #setterCallIn(node: ts.Node, fieldSetters: Set<string>): string | null {
     let found: string | null = null;
     const visit = (current: ts.Node) => {
       if (found) return;
@@ -61,7 +106,7 @@ export class FormSetterScanner {
           ts.isIdentifier(expression.expression) &&
           expression.expression.text === "st" &&
           expression.name.text === "do" &&
-          FormSetterScanner.#fieldSetter.test(name.text)
+          fieldSetters.has(name.text)
         ) {
           found = name.text;
           return;