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

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: {
@@ -128,6 +127,49 @@ describe("Executor filesystem helpers", () => {
     expect(await readFile(path.join(root, "local/docker-compose.yaml"), "utf8")).toBe("custom");
   });
 
+  test("hands every scaffolded TypeScript file to the formatter, and nothing else", async () => {
+    // A template emits identifiers it cannot sort — `import { fetch, Task, usePage }` is right for a model
+    // named Task and wrong for Zoo — and unsorted imports fail `biome check`. So the scaffold is formatted
+    // on the way out, or it is red for most model names whatever the template says.
+    const root = await makeTempRoot();
+    const exec = new Executor("fixture", root);
+    const formatted: string[] = [];
+    exec.getLinter = () =>
+      ({
+        fixFiles: async (filePaths: string[]) => {
+          formatted.push(...filePaths);
+          return { fixed: [] };
+        },
+      }) as unknown as ReturnType<Executor["getLinter"]>;
+
+    await exec.applyTemplate({
+      basePath: "apps/demo/page/task",
+      template: "crudSinglePage",
+      dict: { model: "task", appName: "demo" },
+    });
+
+    expect(formatted).toEqual([path.join(root, "apps/demo/page/task/_index.tsx")]);
+  });
+
+  test("a formatter that cannot run does not fail the scaffold", async () => {
+    // `create-akan-workspace` scaffolds before `bun install`, so there is no local Biome binary and often
+    // no config above the target. An unformatted file is a lint fix; a failed scaffold is not.
+    const root = await makeTempRoot();
+    const exec = new Executor("fixture", root);
+    exec.getLinter = () => {
+      throw new Error("biome.json not found");
+    };
+
+    const created = await exec.applyTemplate({
+      basePath: "apps/demo/page/task",
+      template: "crudSinglePage",
+      dict: { model: "task", appName: "demo" },
+    });
+
+    expect(created).toHaveLength(1);
+    expect(await readFile(path.join(root, "apps/demo/page/task/_index.tsx"), "utf8")).toContain("Task.Zone.Card");
+  });
+
   test("applies hidden files and directories from CLI templates", async () => {
     const root = await makeTempRoot();
     const exec = new Executor("fixture", root);
@@ -204,6 +246,7 @@ describe("Workspace and app executor environment contracts", () => {
       serveDomain: "example.com",
       env: "local",
       portOffset: 10,
+      workspaceId: undefined,
     });
 
     delete process.env.AKAN_PUBLIC_REPO_NAME;
@@ -234,6 +277,7 @@ describe("Workspace and app executor environment contracts", () => {
       serveDomain: "file.example.com",
       env: "develop",
       portOffset: 7,
+      workspaceId: undefined,
     });
   });
 
@@ -622,6 +666,64 @@ describe("Workspace and app executor environment contracts", () => {
     });
   });
 
+  describe("root layout source validation during page key discovery", () => {
+    const makeRouteValidationApp = async (appName: string, config: string, files: Record<string, string>) => {
+      const root = await makeTempRoot();
+      process.env.AKAN_PUBLIC_REPO_NAME = "repo";
+      process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
+      process.env.AKAN_PUBLIC_ENV = "local";
+      await writeJson(path.join(root, "package.json"), rootPackageJson());
+      await mkdir(path.join(root, "apps", appName), { recursive: true });
+      await writeFile(path.join(root, `apps/${appName}/akan.config.ts`), config);
+      for (const [file, source] of Object.entries(files)) {
+        const filePath = path.join(root, `apps/${appName}/page`, file);
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await writeFile(filePath, source);
+      }
+      const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
+      return AppExecutor.from(workspace, appName);
+    };
+    const wsConnectLayout = [
+      "export const wsConnect = false;",
+      "export default function Layout({ children }) { return children; }",
+      "",
+    ].join("\n");
+
+    test("accepts wsConnect on a configured base-path root layout", async () => {
+      process.env.AKAN_PUBLIC_BASE_PATHS = "web,admin";
+      const app = await makeRouteValidationApp(
+        "base-path-root-ws",
+        [
+          "export default {",
+          '  routes: [{ basePath: "web", domains: {} }, { basePath: "admin", domains: {} }],',
+          "};",
+          "",
+        ].join("\n"),
+        { "admin/_layout.tsx": wsConnectLayout },
+      );
+
+      await expect(app.getPageKeys({ refresh: true })).resolves.toEqual(["./admin/_layout.tsx"]);
+    });
+
+    test("rejects wsConnect on a nested layout", async () => {
+      const app = await makeRouteValidationApp(
+        "nested-layout-ws",
+        'export default { routes: [{ basePath: "admin", domains: {} }] };\n',
+        { "admin/users/_layout.tsx": wsConnectLayout },
+      );
+
+      await expect(app.getPageKeys({ refresh: true })).rejects.toThrow(/unsupported export "wsConnect"/);
+    });
+
+    test("accepts wsConnect on a grouped root layout", async () => {
+      const app = await makeRouteValidationApp("grouped-root-ws", "export default {};\n", {
+        "(docs)/_layout.tsx": wsConnectLayout,
+      });
+
+      await expect(app.getPageKeys({ refresh: true })).resolves.toEqual(["./(docs)/_layout.tsx"]);
+    });
+  });
+
   test("accepts metadata route exports during page key discovery", async () => {
     const root = await makeTempRoot();
     process.env.AKAN_PUBLIC_REPO_NAME = "repo";
@@ -760,6 +862,29 @@ describe("Workspace and app executor environment contracts", () => {
     expect(offsetMinimalStart.env.AKAN_PUBLIC_CLIENT_PORT).toBe("8286");
     expect(offsetMinimalStart.env.AKAN_PUBLIC_SERVER_PORT).toBe("8286");
   });
+
+  test("pins the start command to development so an ambient NODE_ENV cannot pick the production router", async () => {
+    const root = await makeTempRoot();
+    process.env.AKAN_PUBLIC_REPO_NAME = "repo";
+    process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
+    process.env.AKAN_PUBLIC_ENV = "local";
+    await writeJson(path.join(root, "package.json"), rootPackageJson());
+    await mkdir(path.join(root, "apps/ambient"), { recursive: true });
+    await writeFile(path.join(root, "apps/ambient/akan.config.ts"), "export default {};\n");
+
+    const originalNodeEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = "production";
+    try {
+      const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
+      const started = await AppExecutor.from(workspace, "ambient").prepareCommand("start");
+      expect(started.env.NODE_ENV).toBe("development");
+      // The builder runs in this process and bakes NODE_ENV into the dev bundles it emits.
+      expect(process.env.NODE_ENV).toBe("development");
+    } finally {
+      if (originalNodeEnv === undefined) delete process.env.NODE_ENV;
+      else process.env.NODE_ENV = originalNodeEnv;
+    }
+  });
 });
 
 describe("PkgExecutor package generation", () => {
@@ -773,7 +898,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" });
@@ -783,12 +908,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

@@ -23,6 +23,7 @@ import { pathToFileURL } from "node:url";
 import type { AkanPlugin, AkanSyncContext, PluginRuntimeContext } from "akanjs";
 import {
   capitalize,
+  getPageSourceFileViolation,
   isRouteSourceFile,
   Logger,
   parseRouteModuleKey,
@@ -39,6 +40,8 @@ import {
   upsertAgentBlock,
 } from "./agentsIndex";
 import { AkanAppConfig, AkanLibConfig, decreaseBuildNum, increaseBuildNum } from "./akanConfig";
+import { getRootBoundarySegments, isRootBoundarySegments } from "./artifact/implicitRootLayout";
+import { CodegenLock } from "./codegenLock";
 import { FileSys } from "./fileSys";
 import { getDirname } from "./getDirname";
 import { Linter } from "./linter";
@@ -233,7 +236,7 @@ export class Executor {
         );
       });
       proc.on("exit", (code, signal) => {
-        if (!!code || signal)
+        if (code || signal)
           reject(
             new CommandExecutionError({
               command,
@@ -342,7 +345,7 @@ export class Executor {
         );
       });
       proc.on("exit", (code, signal) => {
-        if (!!code || signal)
+        if (code || signal)
           reject(
             new CommandExecutionError({
               command: modulePath,
@@ -430,7 +433,9 @@ export class Executor {
     const writePath = this.getPath(filePath);
     const dir = path.dirname(writePath);
     if (!(await FileSys.dirExists(dir))) await mkdir(dir, { recursive: true });
-    let contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+    //? Biome formats every tracked .json and always ends a file with a newline, so a JSON write without one
+    //? loses a byte to `akan lint` and takes it back on the next `akan sync` — a permanent one-line git diff.
+    let contentStr = typeof content === "string" ? content : `${JSON.stringify(content, null, 2)}\n`;
 
     if (await FileSys.fileExists(writePath)) {
       const currentContent = await FileSys.readText(writePath);
@@ -686,7 +691,30 @@ export class Executor {
         Object.entries(options.dict ?? {}).map(([key, value]) => [capitalize(key), capitalize(value)]),
       ),
     };
-    return this._applyTemplate({ ...options, dict });
+    const fileContents = await this._applyTemplate({ ...options, dict });
+    await this.#formatAppliedTemplate(fileContents);
+    return fileContents;
+  }
+
+  /**
+   * A template emits identifiers it cannot sort. `import { fetch, Task, usePage }` is correctly ordered for
+   * a model named Task and wrong for one named Zoo, and `organizeImports` fails `biome check` — so a
+   * scaffold that is not formatted on the way out is red for most model names, whatever the template says.
+   *
+   * Best-effort: `create-akan-workspace` scaffolds before `bun install`, so there is no local Biome binary
+   * and often no config above the target yet. An unformatted file is a lint fix; a failed scaffold is not.
+   */
+  async #formatAppliedTemplate(fileContents: FileContent[]) {
+    const filePaths = fileContents
+      .map((fileContent) => fileContent.filePath)
+      .filter((filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx"));
+    if (filePaths.length === 0) return;
+    try {
+      const { fixed } = await this.getLinter().fixFiles(filePaths);
+      if (fixed.length > 0) this.logger.verbose(`Formatted ${fixed.length} scaffolded file(s)`);
+    } catch (err) {
+      this.logger.verbose(`Skipped formatting scaffolded files: ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
   // Async so `typescript` (~65MB resident) is loaded only by the commands that actually typecheck,
   // not by every process that imports an executor. `typeCheckAsync` below runs in a subprocess and
@@ -909,9 +937,30 @@ export class WorkspaceExecutor extends Executor {
     return await getDirs(basePath);
   }
   async commit(message: string, { init = false, add = true }: { init?: boolean; add?: boolean } = {}) {
-    if (init) await this.exec(`git init --quiet`);
-    if (add) await this.exec(`git add .`);
-    await this.exec(`git commit --quiet -m "${message}"`);
+    if (init) await this.spawn("git", ["init", "--quiet"]);
+    if (add) await this.spawn("git", ["add", "."]);
+    // Argument vector, not a shell string: a message carrying a double quote breaks the interpolated form.
+    await this.spawn("git", ["commit", "--quiet", "-m", message]);
+  }
+  /** `git commit` exits non-zero on an empty index, so a re-runnable caller has to ask first. */
+  async hasChanges() {
+    return !!(await this.spawn("git", ["status", "--porcelain"])).trim();
+  }
+  /**
+   * Workspace-relative paths git knows about, sorted. `untracked` adds files that exist but are not
+   * committed yet, still honoring `.gitignore` — which is what a freshly copied library looks like.
+   *
+   * Reading the file set from git is what keeps generated barrels, the `page/**` and `public/libs`
+   * symlinks, env values and the lockfile out of it without any caller restating that list.
+   */
+  async listGitFiles(paths: string[], { untracked = false }: { untracked?: boolean } = {}) {
+    if (!paths.length) return [];
+    const mode = untracked ? ["--cached", "--others", "--exclude-standard"] : ["--cached"];
+    const stdout = await this.spawn("git", ["ls-files", "-z", ...mode, "--", ...paths]);
+    return stdout
+      .split("\0")
+      .filter((file) => !!file)
+      .sort();
   }
   async #getDirHasFile(basePath: string, targetFilename: string) {
     const AVOID_DIRS = ["node_modules", "dist", "public", "webkit"];
@@ -1006,6 +1055,16 @@ export class SysExecutor extends Executor {
     const path = this.type === "app" ? `apps/${this.name}/lib` : `libs/${this.name}/lib`;
     return await this.workspace.getDirInModule(path, this.name);
   }
+  async getPageConventionViolations(): Promise<{ relativePath: string; reason: string }[]> {
+    if (!(await this.exists("page"))) return [];
+    const violations: { relativePath: string; reason: string }[] = [];
+    for (const entry of await this.getAllFiles("**/*", { cwd: this.getPath("page") })) {
+      const relativePath = entry.split(path.sep).join("/");
+      const reason = getPageSourceFileViolation(relativePath);
+      if (reason) violations.push({ relativePath: `page/${relativePath}`, reason });
+    }
+    return violations;
+  }
 
   #scanInfo: AppInfo | LibInfo | null = null;
   hasScanInfo() {
@@ -1078,18 +1137,22 @@ export class SysExecutor extends Executor {
         : await LibInfo.fromExecutor(this as unknown as LibExecutor, {
             refresh,
           });
-    if (write) {
-      await Promise.all(this.#getScanTemplateTasks(scanInfo));
-      await this.writeJson(`akan.${this.type}.json`, scanInfo.getScanResult());
-      if (this.type === "lib") this.#updateDependencies(scanInfo);
+    //* `writeLib` regenerates every dependency lib's barrels, and each mounting app's `akan start`
+    //* regenerates the same ones — so this region races the other dev servers in the workspace and the
+    //* builders that watch what it writes.
+    if (write)
+      await CodegenLock.run(this.workspace.workspaceRoot, `scan:${this.name}`, async () => {
+        await Promise.all(this.#getScanTemplateTasks(scanInfo));
+        await this.writeJson(`akan.${this.type}.json`, scanInfo.getScanResult());
+        if (this.type === "lib") this.#updateDependencies(scanInfo);
 
-      if (writeLib) {
-        const libInfos = [...scanInfo.getLibInfos().values()];
-        await this.#updateDependencies(scanInfo);
-        await Promise.all(libInfos.flatMap((libInfo) => libInfo.exec.#getScanTemplateTasks(libInfo)));
-      }
-      await this.syncAgentsIndex(scanInfo);
-    }
+        if (writeLib) {
+          const libInfos = [...scanInfo.getLibInfos().values()];
+          await this.#updateDependencies(scanInfo);
+          await Promise.all(libInfos.flatMap((libInfo) => libInfo.exec.#getScanTemplateTasks(libInfo)));
+        }
+        await this.syncAgentsIndex(scanInfo);
+      });
     this.#scanInfo = scanInfo;
     return scanInfo;
   }
@@ -1347,6 +1410,8 @@ export class AppExecutor extends SysExecutor {
     const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
     const routeEnv = {
       AKAN_PUBLIC_BASE_PATHS: [...akanConfig.basePaths].join(","),
+      AKAN_PUBLIC_API_PREFIX: akanConfig.api.prefix,
+      AKAN_PUBLIC_WS_PREFIX: akanConfig.api.websocketPrefix,
       AKAN_DATABASE_MODE: databaseMode,
     };
     Object.assign(process.env, routeEnv);
@@ -1355,15 +1420,30 @@ export class AppExecutor extends SysExecutor {
       //* generated against and typechecked. Drop the cache so the build phases re-read it without them.
       this.#excludeDevOnlyPages = true;
       this.#pageKeys = null;
-      if (await this.exists(this.dist.cwdPath)) await this.dist.exec(`rm -rf ${this.dist.cwdPath}`);
+      await this.dist.removeDir(this.dist.cwdPath);
       await Promise.all([this.dist.mkdir("private"), this.dist.mkdir("public")]);
       //* Lib assets are symlinks in the app dir (see syncAssets). dist is the docker build context and the
       //* release tarball root, neither of which follows a link out of itself, so materialize them here.
+      //* `public/` has exactly one reader — the web router's catch-all — so an api-only build leaves it out.
       await Promise.all([
         this.cp("private", `${this.dist.cwdPath}/private`, { dereference: true }),
-        this.cp("public", `${this.dist.cwdPath}/public`, { dereference: true }),
+        ...(akanConfig.web.ssr ? [this.cp("public", `${this.dist.cwdPath}/public`, { dereference: true })] : []),
       ]);
-    } else await this.removeDir(".akan");
+    } else {
+      await this.removeDir(".akan");
+      //? `web` is a build declaration: `akan start` keeps the full dev surface because the incremental
+      //? builder is also the file watcher, so switching it off would take server-code HMR with it.
+      if (!akanConfig.web.ssr || !akanConfig.web.csr)
+        this.logger.verbose(
+          `akan.config.ts disables web.${!akanConfig.web.ssr ? "ssr" : "csr"}; \`akan start\` still serves it, \`akan build\` will not`,
+        );
+    }
+    //? `akan start` is the dev server, and it must say so rather than inherit an answer. Bun auto-loads the
+    //? workspace `.env`, so NODE_ENV=production can reach this process without ever being exported in a shell —
+    //? and a dev server that believes it is production serves from the production route cache, whose every
+    //? route throws because a dev artifact carries no routes manifest. Written into `process.env` and not only
+    //? into the child env because the builder runs here and bakes NODE_ENV into the bundles it emits.
+    if (type === "start") process.env.NODE_ENV = "development";
     const devPort = type === "start" ? (await this.getDevPort()).toString() : undefined;
     const env = this.getCommandEnv({
       AKAN_COMMAND_TYPE: type,
@@ -1452,7 +1532,8 @@ export class AppExecutor extends SysExecutor {
           );
         }
         if (!owner) owners.set(routeId, { absPath, fromLib });
-        const isRootLayout = parsed.kind === "layout" && parsed.moduleSegments.at(-1) === "_layout";
+        const layoutSegments = getRootBoundarySegments(key);
+        const isRootLayout = layoutSegments !== null && isRootBoundarySegments(layoutSegments, akanConfig.basePaths);
         const routeSource = await Bun.file(absPath).text();
         const validator = await AppExecutor.#getRouteSourceValidator();
         if (parsed.kind === "overrides") validator.validateOverridesSourceExports(routeSource, absPath);
@@ -1701,7 +1782,7 @@ export class LibExecutor extends SysExecutor {
   #akanConfig: AkanLibConfig | null = null;
   override async getConfig({ refresh }: { refresh?: boolean } = {}) {
     if (this.#akanConfig && !refresh) return this.#akanConfig;
-    this.#akanConfig = await AkanLibConfig.from(this);
+    this.#akanConfig = await AkanLibConfig.from(this, { bustImportCache: refresh });
     return this.#akanConfig;
   }
 }
@@ -1807,7 +1888,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/fileEditor.ts

@@ -1,23 +1,23 @@
 export class FileEditor {
-  private filePath: string;
-  private content: string;
+  #filePath: string;
+  #content: string;
 
   private constructor(filePath: string, content: string) {
-    this.filePath = filePath;
-    this.content = content;
+    this.#filePath = filePath;
+    this.#content = content;
   }
 
   static async create(filePath: string): Promise<FileEditor> {
     try {
       const content = await Bun.file(filePath).text();
       return new FileEditor(filePath, content);
-    } catch (error) {
+    } catch (_error) {
       throw new Error(`Failed to read file: ${filePath}`);
     }
   }
 
   find(pattern: string | RegExp): number {
-    const lines = this.content.split("\n");
+    const lines = this.#content.split("\n");
     const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
 
     for (let i = 0; i < lines.length; i++) {
@@ -30,7 +30,7 @@ export class FileEditor {
   }
 
   findAll(pattern: string | RegExp): number[] {
-    const lines = this.content.split("\n");
+    const lines = this.#content.split("\n");
     const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
     const matches: number[] = [];
 
@@ -50,9 +50,9 @@ export class FileEditor {
       throw new Error(`Pattern not found: ${pattern}`);
     }
 
-    const lines = this.content.split("\n");
+    const lines = this.#content.split("\n");
     lines.splice(lineIndex + 1, 0, data);
-    this.content = lines.join("\n");
+    this.#content = lines.join("\n");
 
     return this;
   }
@@ -64,43 +64,43 @@ export class FileEditor {
       throw new Error(`Pattern not found: ${pattern}`);
     }
 
-    const lines = this.content.split("\n");
+    const lines = this.#content.split("\n");
     lines.splice(lineIndex, 0, data);
-    this.content = lines.join("\n");
+    this.#content = lines.join("\n");
 
     return this;
   }
 
   replace(pattern: string | RegExp, replacement: string): this {
     const regex = typeof pattern === "string" ? new RegExp(pattern, "g") : pattern;
-    this.content = this.content.replace(regex, replacement);
+    this.#content = this.#content.replace(regex, replacement);
     return this;
   }
 
   append(data: string): this {
-    this.content += `\n${data}`;
+    this.#content += `\n${data}`;
     return this;
   }
 
   prepend(data: string): this {
-    this.content = `${data}\n${this.content}`;
+    this.#content = `${data}\n${this.#content}`;
     return this;
   }
 
   async save(): Promise<void> {
     try {
-      await Bun.write(this.filePath, this.content);
-    } catch (error) {
-      throw new Error(`Failed to save file: ${this.filePath}`);
+      await Bun.write(this.#filePath, this.#content);
+    } catch (_error) {
+      throw new Error(`Failed to save file: ${this.#filePath}`);
     }
   }
 
   getContent(): string {
-    return this.content;
+    return this.#content;
   }
 
   setContent(content: string): this {
-    this.content = content;
+    this.#content = content;
     return this;
   }
 }

package/fileSys.ts

@@ -1,4 +1,4 @@
-import { lstat, stat } from "node:fs/promises";
+import { lstat, rename, rm, stat } from "node:fs/promises";
 import { Logger } from "akanjs/common";
 
 export class FileSys {
@@ -39,6 +39,24 @@ export class FileSys {
   static async writeText(path: string, content: string) {
     return await Bun.file(path).write(content);
   }
+  /**
+   * Replaces a file in one `rename`, so a concurrent reader sees either the old bytes or the new ones.
+   * Generated barrels are written by every dev server watching the same `libs/` tree while those same
+   * servers' watchers are reading them, and a half-written barrel reads back as a user edit.
+   *
+   * The temp file is a sibling because `rename` is only atomic within a filesystem, and it lands in a
+   * watched directory — the `.tmp` suffix is what `HmrChangeClassifier` ignores it by.
+   */
+  static async writeTextAtomic(filePath: string, content: string) {
+    const temp = `${filePath}.${process.pid}.${Date.now().toString(36)}.tmp`;
+    try {
+      await Bun.write(temp, content);
+      await rename(temp, filePath);
+    } catch (error) {
+      await rm(temp, { force: true }).catch(() => undefined);
+      throw error;
+    }
+  }
   static async writeJson(path: string, content: object) {
     return await Bun.file(path).write(`${JSON.stringify(content, null, 2)}\n`);
   }

package/formSetterScanner.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from "bun:test";
+import ts from "typescript";
+import { FormSetterScanner } from "./formSetterScanner";
+import type { SourceFileInfo } from "./qualityScanner";
+
+const fileOf = (file: string, content: string): SourceFileInfo => ({
+  file,
+  absolutePath: `/tmp/${file}`,
+  content,
+  sourceFile: ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX),
+});
+
+const scan = (content: string) =>
+  new FormSetterScanner().scan([fileOf("apps/demo/lib/task/Task.Template.tsx", content)]);
+
+describe("FormSetterScanner", () => {
+  test("a setter passed by reference publishes, so nothing is reported", () => {
+    expect(
+      scan(`export const General = () => (
+  <Field.Text value={taskForm.title} onChange={st.do.setTitleOnTask} />
+);
+`),
+    ).toEqual([]);
+  });
+
+  test("every wrapper shape is counted once per field, whatever the wrapper was for", () => {
+    const warnings = scan(`export const General = () => (
+  <>
+    <Field.Text onChange={st.do.setTitleOnTask} />
+    <Field.ToggleSelect onChange={(type) => { st.do.setTypeOnTask(type); }} />
+    <Field.Phone onChange={(phone) => st.do.setPhoneOnTask(formatPhone(phone))} />
+    <Field.Parent
+      onChange={(project) => {
+        st.do.setProjectOnTask(project);
+        if (project) st.do.addMembersOnTask(project.members ?? []);
+      }}
+    />
+  </>
+);
+`);
+
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]?.rule).toBe("akan.agent.unpublished-form-setter");
+    expect(warnings[0]?.scope).toBe("agent");
+    expect(warnings[0]?.message).toContain("setPhoneOnTask, setProjectOnTask, setTypeOnTask");
+    expect(warnings[0]?.locations).toHaveLength(3);
+  });
+
+  test("a nested path write is unannotatable by design and is not counted", () => {
+    expect(
+      scan(`export const Rows = ({ idx }: { idx: number }) => (
+  <Field.Text onChange={(title) => st.do.writeOnTask(\`payments.\${idx}.title\`, title)} />
+);
+`),
+    ).toEqual([]);
+  });
+
+  test("a zero-parameter handler is a button setting a constant, not a form control", () => {
+    expect(
+      scan(`export const Actions = () => (
+  <Button onClick={() => st.do.setStatusOnTask("done")}>Done</Button>
+);
+`),
+    ).toEqual([]);
+  });
+
+  test("a non-setter action behind a wrapper is somebody else's rule", () => {
+    expect(
+      scan(`export const Filters = () => (
+  <Select onChange={(ids) => st.do.setQueryArgsOfTaskInSelf(ids)} />
+);
+`),
+    ).toEqual([]);
+  });
+
+  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([]);
+  });
+});