@akanjs/devkit 3.1.1-rc.15 → 3.1.1-rc.16

package/workflow/types.ts

@@ -49,6 +49,14 @@ export interface AddEnumFieldInput extends PrimitiveTargetInput {
 
 export interface AddMutationInput extends PrimitiveTargetInput {
   mutation: string | null;
+  guards?: string[] | null;
+  withCalls?: string[] | null;
+  afterCalls?: string[] | null;
+}
+
+export interface CreateInteractionInput {
+  app: string | null;
+  interaction: string | null;
 }
 
 export interface AddSliceInput extends PrimitiveTargetInput {
@@ -94,6 +102,7 @@ export interface WorkflowSpec {
   predictedChanges: readonly WorkflowPredictedChange[];
   validation: readonly WorkflowValidation[];
   completionCriteria: readonly string[];
+  replacesRules?: readonly string[];
 }
 
 export interface WorkflowDiagnostic {
@@ -382,6 +391,13 @@ export interface PrimitiveWriteReport {
   nextActions: PrimitiveNextAction[];
 }
 
+export interface ScaffoldFile {
+  path: string;
+  content: string;
+  action: "create" | "modify";
+  reason: string;
+}
+
 export type PrimitiveFileMap = Record<string, { filename: string; content: string }>;
 
 export interface WorkflowApplyReport {
@@ -482,4 +498,5 @@ export interface WorkflowPrimitiveOperations {
   addEnumField: (input: AddEnumFieldInput) => Promise<PrimitiveWriteReport>;
   addMutation: (input: AddMutationInput) => Promise<PrimitiveWriteReport>;
   addSlice: (input: AddSliceInput) => Promise<PrimitiveWriteReport>;
+  createInteraction: (input: CreateInteractionInput) => Promise<PrimitiveWriteReport>;
 }

package/workspaceLayout.ts

@@ -7,6 +7,7 @@ export const appRootAllowedFiles = new Set([
   "AGENTS.md",
   "CLAUDE.md",
   "akan.app.json",
+  "akan.baseline.json",
   "akan.config.ts",
   "client.ts",
   "main.ts",
@@ -38,6 +39,7 @@ export const libRootAllowedFiles = new Set([
   "AGENTS.md",
   "CLAUDE.md",
   "README.md",
+  "akan.baseline.json",
   "akan.config.ts",
   "akan.lib.json",
   "client.ts",

package/writePath.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test } from "bun:test";
+import ts from "typescript";
+import { WritePath } from "./writePath";
+
+const pathIn = (body: string, enters?: (fn: ts.SignatureDeclaration) => boolean) => {
+  const sourceFile = ts.createSourceFile("a.ts", `async function run() {\n${body}\n}`, ts.ScriptTarget.Latest, true);
+  const fn = sourceFile.statements[0];
+  if (!fn || !ts.isFunctionDeclaration(fn) || !fn.body) throw new Error("fixture has no function body");
+  const isWrite = (call: ts.CallExpression) => /^write/.test(call.expression.getText(sourceFile));
+  const path = new WritePath(isWrite, { enters });
+  const calls = path.along(fn.body);
+  return { labels: calls.map((call) => path.labelOf(call, sourceFile)), count: path.countOf(calls) };
+};
+const writesIn = (body: string, enters?: (fn: ts.SignatureDeclaration) => boolean) =>
+  pathIn(body, enters).labels.map((label) => label.replace(" (per item)", ""));
+
+describe("WritePath", () => {
+  test("adds up writes in sequence, nested callbacks and logical operands included", () => {
+    expect(
+      writesIn("await writeA();\nawait Promise.all(ids.map((id) => writeB(id)));\nok && (await writeC());"),
+    ).toEqual(["writeA", "writeB", "writeC"]);
+  });
+
+  test("counts only the busiest of exclusive branches", () => {
+    expect(writesIn("if (x) await writeA();\nelse await writeB();")).toEqual(["writeA"]);
+    expect(writesIn("await (x ? writeA() : Promise.all([writeB(), writeC()]));")).toEqual(["writeB", "writeC"]);
+    expect(
+      writesIn(
+        "switch (x) {\n  case 1:\n    await writeA();\n    break;\n  default:\n    await writeB();\n    await writeC();\n}",
+      ),
+    ).toEqual(["writeB", "writeC"]);
+  });
+
+  test("reads an if that returns as the else of the statements after it", () => {
+    expect(
+      writesIn("await writeA();\nif (x) {\n  await writeB();\n  return;\n}\nawait writeC();\nawait writeD();"),
+    ).toEqual(["writeA", "writeC", "writeD"]);
+    expect(writesIn("if (x) await writeB();\nawait writeC();")).toEqual(["writeB", "writeC"]);
+  });
+
+  test("reads every branch that returns as exclusive of the statements after it, however it is nested", () => {
+    const countIn = (body: string) => pathIn(body).count;
+    expect(
+      countIn(
+        "if (x) {\n  await writeA();\n  return;\n} else if (y) {\n  await writeB();\n  return;\n}\nawait writeC();",
+      ),
+    ).toBe(1);
+    expect(countIn('switch (x) {\n  case "a":\n    await writeA();\n    return;\n}\nawait writeC();')).toBe(1);
+    expect(countIn("if (x) {\n  if (y) {\n    await writeA();\n    return;\n  }\n}\nawait writeC();")).toBe(1);
+    expect(writesIn("try {\n  await writeA();\n  return;\n} catch {\n  await writeB();\n}")).toEqual([
+      "writeA",
+      "writeB",
+    ]);
+  });
+
+  test("runs a switch clause without break on into the next one", () => {
+    expect(
+      writesIn("switch (x) {\n  case 1:\n    await writeA();\n  case 2:\n    await writeB();\n    break;\n}"),
+    ).toEqual(["writeA", "writeB"]);
+  });
+
+  test("counts a write in a loop or a per-element callback as two, but not the list it loops over", () => {
+    expect(pathIn("for (const id of ids) await writeA(id);")).toEqual({ labels: ["writeA (per item)"], count: 2 });
+    expect(pathIn("for (const id of await writeA()) read(id);")).toEqual({ labels: ["writeA"], count: 1 });
+    expect(pathIn("while (await more()) await writeA();")).toEqual({ labels: ["writeA (per item)"], count: 2 });
+    expect(pathIn("await Promise.all(ids.map((id) => writeA(id)));")).toEqual({
+      labels: ["writeA (per item)"],
+      count: 2,
+    });
+    expect(pathIn("await read().then(() => writeA());")).toEqual({ labels: ["writeA"], count: 1 });
+    expect(pathIn("for (let i = 0; i < ids.length; i++) await writeA(ids[i]);")).toEqual({
+      labels: ["writeA (per item)"],
+      count: 2,
+    });
+    expect(pathIn("while (queue.length) await writeA(queue.shift());")).toEqual({
+      labels: ["writeA (per item)"],
+      count: 2,
+    });
+  });
+
+  test("counts a retry or a poll as one write, and a loop that returns on its write as one", () => {
+    expect(pathIn("for (let i = 0; i < 3; i++) {\n  try {\n    await writeA();\n    return;\n  } catch {}\n}")).toEqual(
+      {
+        labels: ["writeA"],
+        count: 1,
+      },
+    );
+    expect(pathIn("let ok = false;\nwhile (!ok) ok = await writeA();")).toEqual({ labels: ["writeA"], count: 1 });
+    expect(pathIn("for (const id of ids)\n  if (id) {\n    await writeA(id);\n    return;\n  }")).toEqual({
+      labels: ["writeA"],
+      count: 1,
+    });
+  });
+
+  test("weighs a branch writing per item above one writing once", () => {
+    expect(pathIn("if (x) await writeA();\nelse for (const id of ids) await writeB(id);")).toEqual({
+      labels: ["writeB (per item)"],
+      count: 2,
+    });
+  });
+
+  test("leaves out a nested function the caller does not enter", () => {
+    const body = "await writeA();\nids.map((id) => writeB(id));\nsetTimeout(() => writeC(), 0);";
+    const entersMapOnly = (fn: ts.SignatureDeclaration) =>
+      ts.isCallExpression(fn.parent) && fn.parent.expression.getText().endsWith(".map");
+
+    expect(writesIn(body, entersMapOnly)).toEqual(["writeA", "writeB"]);
+  });
+});

package/writePath.ts

@@ -0,0 +1,219 @@
+import ts from "typescript";
+
+interface Flow {
+  through: ts.CallExpression[] | null;
+  exit: ts.CallExpression[] | null;
+  jump: ts.CallExpression[] | null;
+}
+
+//? Exclusive branches never run together, so only the busiest one counts, a branch that returns included; a write in
+//? a loop over items or a per-element callback runs once per item, so it counts as two.
+export class WritePath {
+  static readonly #perElement = new Set([
+    "map",
+    "flatMap",
+    "forEach",
+    "filter",
+    "reduce",
+    "some",
+    "every",
+    "find",
+    "findIndex",
+  ]);
+  readonly #matches: (call: ts.CallExpression) => boolean;
+  readonly #enters: (fn: ts.SignatureDeclaration) => boolean;
+  readonly #repeated = new WeakSet<ts.CallExpression>();
+
+  constructor(
+    matches: (call: ts.CallExpression) => boolean,
+    { enters = () => true }: { enters?: (fn: ts.SignatureDeclaration) => boolean } = {},
+  ) {
+    this.#matches = matches;
+    this.#enters = enters;
+  }
+
+  along(node: ts.Node): ts.CallExpression[] {
+    if (ts.isFunctionLike(node) && !this.#enters(node)) return [];
+    if (WritePath.isPerElementCallback(node)) return this.#repeat(this.#children(node));
+    if (WritePath.#isFlowStatement(node)) return this.#busiestOf(this.#flowOf(node));
+    if (ts.isConditionalExpression(node))
+      return [...this.along(node.condition), ...this.#busier(this.along(node.whenTrue), this.along(node.whenFalse))];
+    const own = ts.isCallExpression(node) && this.#matches(node) ? [node] : [];
+    return [...own, ...this.#children(node)];
+  }
+
+  isRepeated(call: ts.CallExpression) {
+    return this.#repeated.has(call);
+  }
+
+  countOf(calls: ts.CallExpression[]) {
+    return calls.reduce((count, call) => count + (this.isRepeated(call) ? 2 : 1), 0);
+  }
+
+  labelOf(call: ts.CallExpression, sourceFile: ts.SourceFile) {
+    const callee = call.expression.getText(sourceFile);
+    return this.isRepeated(call) ? `${callee} (per item)` : callee;
+  }
+
+  static isPerElementCallback(node: ts.Node) {
+    const call = node.parent;
+    return (
+      (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
+      !!call &&
+      ts.isCallExpression(call) &&
+      call.arguments.some((arg) => arg === node) &&
+      ts.isPropertyAccessExpression(call.expression) &&
+      WritePath.#perElement.has(call.expression.name.text)
+    );
+  }
+
+  #children(node: ts.Node) {
+    const children: ts.Node[] = [];
+    ts.forEachChild(node, (child) => {
+      children.push(child);
+    });
+    return children.flatMap((child) => this.along(child));
+  }
+
+  #repeat(calls: ts.CallExpression[]) {
+    for (const call of calls) this.#repeated.add(call);
+    return calls;
+  }
+
+  #flowOf(node: ts.Statement): Flow {
+    if (ts.isBlock(node)) return this.#sequenceOf(node.statements);
+    if (ts.isReturnStatement(node) || ts.isThrowStatement(node))
+      return { through: null, exit: node.expression ? this.along(node.expression) : [], jump: null };
+    if (ts.isBreakStatement(node) || ts.isContinueStatement(node)) return { through: null, exit: null, jump: [] };
+    if (ts.isLabeledStatement(node)) return this.#flowOf(node.statement);
+    if (ts.isIfStatement(node))
+      return WritePath.#prefixed(
+        this.along(node.expression),
+        this.#merged(
+          this.#flowOf(node.thenStatement),
+          node.elseStatement ? this.#flowOf(node.elseStatement) : WritePath.#onward([]),
+        ),
+      );
+    if (ts.isSwitchStatement(node)) return WritePath.#prefixed(this.along(node.expression), this.#switchOf(node));
+    if (ts.isTryStatement(node)) return this.#tryOf(node);
+    if (ts.isForOfStatement(node) || ts.isForInStatement(node))
+      return this.#loopOf(this.along(node.expression), [], node.statement, true);
+    if (ts.isForStatement(node))
+      return this.#loopOf(
+        node.initializer ? this.along(node.initializer) : [],
+        [node.condition, node.incrementor].flatMap((part) => (part ? this.along(part) : [])),
+        node.statement,
+        WritePath.#walksItems(node.condition),
+      );
+    if (ts.isWhileStatement(node) || ts.isDoStatement(node))
+      return this.#loopOf([], this.along(node.expression), node.statement, WritePath.#walksItems(node.expression));
+    return WritePath.#onward(this.along(node));
+  }
+
+  #sequenceOf(statements: readonly ts.Statement[]): Flow {
+    let through: ts.CallExpression[] | null = [];
+    let exit: ts.CallExpression[] | null = null;
+    let jump: ts.CallExpression[] | null = null;
+    for (const statement of statements) {
+      if (through === null) break;
+      const flow = this.#flowOf(statement);
+      if (flow.exit) exit = this.#busierOf(exit, [...through, ...flow.exit]);
+      if (flow.jump) jump = this.#busierOf(jump, [...through, ...flow.jump]);
+      through = flow.through && [...through, ...flow.through];
+    }
+    return { through, exit, jump };
+  }
+
+  //? A clause without `break` runs on into the next one; `break` leaves the switch and goes on after it.
+  #switchOf(node: ts.SwitchStatement): Flow {
+    const hasDefault = node.caseBlock.clauses.some(ts.isDefaultClause);
+    let flow: Flow = { through: hasDefault ? null : [], exit: null, jump: null };
+    let fallen: ts.CallExpression[] | null = null;
+    for (const clause of node.caseBlock.clauses) {
+      const entry = fallen && this.countOf(fallen) > 0 ? fallen : [];
+      const own = WritePath.#prefixed(entry, this.#sequenceOf(clause.statements));
+      flow = this.#merged(flow, { through: own.jump, exit: own.exit, jump: null });
+      fallen = own.through;
+    }
+    return this.#merged(flow, { through: fallen, exit: null, jump: null });
+  }
+
+  //? A catch runs after whatever the try sent before it threw, so both count; a finally follows every path.
+  #tryOf(node: ts.TryStatement): Flow {
+    const tried = this.#flowOf(node.tryBlock);
+    const sent = this.#busiestOf(tried);
+    const caught = node.catchClause
+      ? WritePath.#prefixed(sent, this.#flowOf(node.catchClause.block))
+      : { through: null, exit: sent, jump: null };
+    const flow = this.#merged(tried, caught);
+    if (!node.finallyBlock) return flow;
+    const after = this.#busiestOf(this.#flowOf(node.finallyBlock));
+    return {
+      through: flow.through && [...flow.through, ...after],
+      exit: flow.exit && [...flow.exit, ...after],
+      jump: flow.jump && [...flow.jump, ...after],
+    };
+  }
+
+  //? An iteration that leaves the function sends its writes once; one that goes on repeats them for a loop over items.
+  #loopOf(once: ts.CallExpression[], everyTurn: ts.CallExpression[], body: ts.Statement, isPerItem: boolean): Flow {
+    const flow = this.#flowOf(body);
+    const turn = [...everyTurn, ...(this.#busierOf(flow.through, flow.jump) ?? [])];
+    const repeated = isPerItem ? this.#repeat(turn) : turn;
+    return { through: [...once, ...repeated], exit: flow.exit && [...once, ...flow.exit], jump: null };
+  }
+
+  #merged(a: Flow, b: Flow): Flow {
+    return {
+      through: this.#busierOf(a.through, b.through),
+      exit: this.#busierOf(a.exit, b.exit),
+      jump: this.#busierOf(a.jump, b.jump),
+    };
+  }
+
+  #busiestOf({ through, exit, jump }: Flow) {
+    return this.#busierOf(this.#busierOf(through, exit), jump) ?? [];
+  }
+
+  #busierOf(a: ts.CallExpression[] | null, b: ts.CallExpression[] | null) {
+    return a && b ? this.#busier(a, b) : (a ?? b);
+  }
+
+  static #onward(calls: ts.CallExpression[]): Flow {
+    return { through: calls, exit: null, jump: null };
+  }
+
+  static #prefixed(calls: ts.CallExpression[], { through, exit, jump }: Flow): Flow {
+    return {
+      through: through && [...calls, ...through],
+      exit: exit && [...calls, ...exit],
+      jump: jump && [...calls, ...jump],
+    };
+  }
+
+  static #isFlowStatement(node: ts.Node): node is ts.Statement {
+    return (
+      ts.isBlock(node) ||
+      ts.isIfStatement(node) ||
+      ts.isSwitchStatement(node) ||
+      ts.isTryStatement(node) ||
+      ts.isLabeledStatement(node) ||
+      ts.isReturnStatement(node) ||
+      ts.isThrowStatement(node) ||
+      ts.isBreakStatement(node) ||
+      ts.isContinueStatement(node) ||
+      ts.isIterationStatement(node, false)
+    );
+  }
+
+  //? A loop bound by `xs.length` or asking a call for more (`while (await next())`) walks items; a bound it counts
+  //? itself (`i < 3`, `!ok`) is a retry or a poll, which sends one write however many times it tries.
+  static #walksItems(node: ts.Node | undefined): boolean {
+    if (!node) return false;
+    if (ts.isCallExpression(node)) return true;
+    if (ts.isPropertyAccessExpression(node) && ["length", "size"].includes(node.name.text)) return true;
+    return !!ts.forEachChild(node, (child) => WritePath.#walksItems(child) || undefined);
+  }
+
+  #busier = (a: ts.CallExpression[], b: ts.CallExpression[]) => (this.countOf(b) > this.countOf(a) ? b : a);
+}

package/writePlacementScanner.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test";
+import ts from "typescript";
+import type { SourceFileInfo } from "./qualityScanner";
+import { SignalMutationIndex } from "./signalMutationIndex";
+import { WritePlacementScanner } from "./writePlacementScanner";
+import { WritingActionIndex } from "./writingActionIndex";
+
+const fileOf = (file: string, content: string): SourceFileInfo => ({
+  file,
+  absolutePath: `/repo/${file}`,
+  content,
+  sourceFile: ts.createSourceFile(
+    file,
+    content,
+    ts.ScriptTarget.Latest,
+    true,
+    file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+  ),
+});
+
+const index = new WritingActionIndex(
+  new SignalMutationIndex([
+    fileOf(
+      "apps/demo/lib/court/court.signal.ts",
+      `export class CourtEndpoint extends endpoint(srv.court, ({ query, mutation }) => ({
+  skipNvrOnCourt: mutation(cnst.Court, { guards: [User] }).param("courtId", ID).exec(() => null),
+  courtCount: query(Int, { guards: [User] }).exec(() => 0),
+})) {}
+`,
+    ),
+  ]),
+  [
+    fileOf(
+      "apps/demo/lib/court/court.store.ts",
+      `import { fetch, sig } from "../useClient";
+export class CourtStore extends store(sig.court, () => ({})) {
+  async skipNvrOnCourt(courtId: string) {
+    this.setCourt(await fetch.skipNvrOnCourt(courtId));
+  }
+  setPicked(courtId: string) {
+    this.set({ picked: courtId });
+  }
+}
+`,
+    ),
+  ],
+);
+
+const scan = (file: string, body: string) => {
+  const content = `"use client";\nimport { fetch as api, st } from "@apps/demo/client";\n\n${body}\n`;
+  return new WritePlacementScanner(index).scan(
+    file,
+    `apps/demo/${file}`,
+    fileOf(`apps/demo/${file}`, content).sourceFile,
+  );
+};
+
+describe("WritePlacementScanner", () => {
+  test("names every server write a ui/ or webkit/ file sends, by call or by reference, under any import name", () => {
+    expect(
+      scan(
+        "webkit/useSkip.tsx",
+        "export const useSkip = (courtId: string) => ({\n  skip: () => st.do.skipNvrOnCourt(courtId),\n  bound: st.do.skipNvrOnCourt,\n  count: () => api.courtCount(),\n  direct: () => api.skipNvrOnCourt(courtId),\n});",
+      ),
+    ).toEqual({ line: 5, writes: ["st.do.skipNvrOnCourt", "st.do.skipNvrOnCourt", "api.skipNvrOnCourt"] });
+  });
+
+  test("lets a module component call a writing action, and a ui/ file set client state, but not a fetch mutation", () => {
+    expect(
+      scan("lib/court/Court.Zone.tsx", "export const Skip = ({ id }: { id: string }) => st.do.skipNvrOnCourt(id);"),
+    ).toBeNull();
+    expect(scan("ui/Pick.tsx", "export const Pick = ({ id }: { id: string }) => st.do.setPicked(id);")).toBeNull();
+    expect(
+      scan("lib/court/Court.Zone.tsx", "export const Skip = ({ id }: { id: string }) => api.skipNvrOnCourt(id);"),
+    ).toEqual({ line: 4, writes: ["api.skipNvrOnCourt"] });
+  });
+});

package/writePlacementScanner.ts

@@ -0,0 +1,50 @@
+import ts from "typescript";
+import { StoreAccessScanner } from "./storeAccessScanner";
+import type { WritingActionIndex } from "./writingActionIndex";
+
+export interface WritePlacement {
+  line: number;
+  writes: string[];
+}
+
+//* A write leaves the browser through one store action, started by one module component: an agent, a test or another
+//* screen reaches it through the store, and `ui/` / `webkit/` stay free of any one model.
+export class WritePlacementScanner {
+  readonly #index: WritingActionIndex;
+
+  constructor(index: WritingActionIndex) {
+    this.#index = index;
+  }
+
+  scan(file: string, workspaceFile: string, sourceFile: ts.SourceFile): WritePlacement | null {
+    const fetchNames = StoreAccessScanner.localNamesOf(sourceFile, "fetch");
+    const stNames = file.startsWith("lib/") ? new Set<string>() : StoreAccessScanner.stNamesOf(sourceFile);
+    if (!fetchNames.size && !stNames.size) return null;
+    const sites: ts.PropertyAccessExpression[] = [];
+    const visit = (node: ts.Node) => {
+      if (ts.isPropertyAccessExpression(node) && this.#isWrite(node, workspaceFile, fetchNames, stNames))
+        sites.push(node);
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    const first = sites[0];
+    if (!first) return null;
+    return {
+      line: sourceFile.getLineAndCharacterOfPosition(first.getStart(sourceFile)).line + 1,
+      writes: sites.map((site) => site.getText(sourceFile)),
+    };
+  }
+
+  #isWrite(access: ts.PropertyAccessExpression, workspaceFile: string, fetchNames: Set<string>, stNames: Set<string>) {
+    const owner = access.expression;
+    if (ts.isIdentifier(owner) && fetchNames.has(owner.text))
+      return this.#index.isMutation(workspaceFile, access.name.text);
+    return (
+      ts.isPropertyAccessExpression(owner) &&
+      owner.name.text === "do" &&
+      ts.isIdentifier(owner.expression) &&
+      stNames.has(owner.expression.text) &&
+      this.#index.isWritingAction(access.name.text)
+    );
+  }
+}

package/writingActionIndex.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test";
+import ts from "typescript";
+import type { SourceFileInfo } from "./qualityScanner";
+import { SignalMutationIndex } from "./signalMutationIndex";
+import { WritingActionIndex } from "./writingActionIndex";
+
+const fileOf = (file: string, content: string): SourceFileInfo => ({
+  file,
+  absolutePath: `/repo/${file}`,
+  content,
+  sourceFile: ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS),
+});
+
+const signals = [
+  fileOf(
+    "apps/demo/lib/court/court.signal.ts",
+    `export class CourtSlice extends slice(srv.court, { guards: { root: Admin, cru: User } }, () => ({})) {}
+export class CourtEndpoint extends endpoint(srv.court, ({ query, mutation }) => ({
+  courtCount: query(Int, { guards: [User] }).exec(() => 0),
+})) {}
+`,
+  ),
+  fileOf(
+    "libs/shared/lib/push/push.signal.ts",
+    `export class PushEndpoint extends endpoint(srv.push, ({ mutation }) => ({
+  pushPcCommand: mutation(Boolean, { guards: [User] }).param("courtId", ID).exec(() => true),
+})) {}
+`,
+  ),
+];
+
+const courtStore = fileOf(
+  "apps/demo/lib/court/court.store.ts",
+  `import { fetch, sig } from "../useClient";
+export class CourtStore extends store(sig.court, () => ({})) {
+  async countCourts() {
+    this.set({ count: await fetch.courtCount() });
+  }
+  async openCourt(courtId: string) {
+    const root = this as unknown as RootStore;
+    await root.restartPc(courtId);
+  }
+  async refreshAfterOpen(courtId: string) {
+    await this.openCourt(courtId);
+    await this.countCourts();
+  }
+}
+`,
+);
+const pcStore = fileOf(
+  "apps/demo/lib/_pc/pc.store.ts",
+  `import { fetch, sig } from "../useClient";
+export class PcStore extends store(sig.pc, () => ({})) {
+  async restartPc(courtId: string) {
+    await PcStore.sendRestart(courtId);
+  }
+  static async sendRestart(courtId: string) {
+    await fetch.pushPcCommand(courtId);
+  }
+}
+`,
+);
+
+const indexOf = (storeFiles: SourceFileInfo[]) => new WritingActionIndex(new SignalMutationIndex(signals), storeFiles);
+
+describe("WritingActionIndex", () => {
+  test("holds the generated actions that send a mutation for a model with a slice, not its form setters", () => {
+    const index = indexOf([courtStore, pcStore]);
+    for (const name of [
+      "createCourt",
+      "updateCourt",
+      "removeCourt",
+      "mergeCourt",
+      "createCourtInForm",
+      "updateCourtInForm",
+      "submitCourt",
+    ])
+      expect(index.isWritingAction(name)).toBe(true);
+    for (const name of ["setNameOnCourt", "writeOnCourt", "uploadImageOnCourt", "newCourt", "editCourt", "viewCourt"])
+      expect(index.isWritingAction(name)).toBe(false);
+    expect(index.isWritingAction("createPc")).toBe(false);
+  });
+
+  test("follows writes through a static helper, the RootStore alias and a sibling action to a fixed point", () => {
+    const index = indexOf([courtStore, pcStore]);
+
+    expect(index.isWritingAction("restartPc")).toBe(true);
+    expect(index.isWritingAction("openCourt")).toBe(true);
+    expect(index.isWritingAction("refreshAfterOpen")).toBe(true);
+    expect(index.isWritingAction("countCourts")).toBe(false);
+  });
+
+  test("knows no action of a store it was not given", () => {
+    const index = indexOf([courtStore]);
+
+    expect(index.isWritingAction("restartPc")).toBe(false);
+    expect(index.isWritingAction("openCourt")).toBe(false);
+  });
+});

package/writingActionIndex.ts

@@ -0,0 +1,63 @@
+import type ts from "typescript";
+import type { SourceFileInfo } from "./qualityScanner";
+import type { SignalMutationIndex } from "./signalMutationIndex";
+import { type StoreCallTarget, type StoreMethod, StoreSource } from "./storeSource";
+
+//? Stores merge into one root, so an action name means one action wherever it is called from.
+export class WritingActionIndex {
+  readonly #mutations: SignalMutationIndex;
+  readonly #actions = new Set<string>();
+  readonly #statics = new Set<string>();
+
+  constructor(mutations: SignalMutationIndex, storeFiles: Pick<SourceFileInfo, "file" | "sourceFile">[]) {
+    this.#mutations = mutations;
+    const sources = storeFiles.map((storeFile) => new StoreSource(storeFile));
+    for (const source of sources)
+      for (const { refName } of source.stores) {
+        const generated = refName ? StoreSource.generatedWritesOf(refName) : [];
+        if (generated[0] && mutations.isMutation(source.file, generated[0]))
+          for (const name of generated) this.#actions.add(name);
+      }
+    const methods = sources.flatMap((source) =>
+      source.methods.map((method) => ({ file: source.file, method, targets: source.targetsIn(method) })),
+    );
+    let grew = true;
+    while (grew) {
+      grew = false;
+      for (const { file, method, targets } of methods) {
+        if (this.#holds(method) || !targets.some((target) => this.#writes(file, target))) continue;
+        if (method.isStatic) this.#statics.add(`${method.store}.${method.name}`);
+        else this.#actions.add(method.name);
+        grew = true;
+      }
+    }
+  }
+
+  isWritingAction(name: string) {
+    return this.#actions.has(name);
+  }
+
+  isMutation(consumerFile: string, name: string) {
+    return this.#mutations.isMutation(consumerFile, name);
+  }
+
+  writeOf(source: StoreSource, method: StoreMethod, call: ts.CallExpression): StoreCallTarget | null {
+    const target = source.targetOf(method, call);
+    if (!target || !this.#writes(source.file, target)) return null;
+    const isSelf =
+      target.kind !== "fetch" &&
+      target.name === method.name &&
+      (target.kind === "static" ? method.isStatic && target.store === method.store : !method.isStatic);
+    return isSelf ? null : target;
+  }
+
+  #holds(method: StoreMethod) {
+    return method.isStatic ? this.#statics.has(`${method.store}.${method.name}`) : this.#actions.has(method.name);
+  }
+
+  #writes(file: string, target: StoreCallTarget) {
+    if (target.kind === "fetch") return this.#mutations.isMutation(file, target.name);
+    if (target.kind === "action") return this.#actions.has(target.name);
+    return this.#statics.has(`${target.store}.${target.name}`);
+  }
+}