@akanjs/devkit 3.1.2-rc.4 → 3.2.0-rc.1

package/gitRevision.ts

@@ -43,8 +43,12 @@ export class GitRevision {
     };
   }
 
-  async filesAt(sha: string, isWanted: (file: string) => boolean): Promise<Map<string, string>> {
-    const listed = await this.#git(["ls-tree", "-r", "-z", "--name-only", sha, "--", ...systemPaths]);
+  async filesAt(
+    sha: string,
+    isWanted: (file: string) => boolean,
+    paths: string[] = systemPaths,
+  ): Promise<Map<string, string>> {
+    const listed = await this.#git(["ls-tree", "-r", "-z", "--name-only", sha, "--", ...paths]);
     if (listed === null) throw new Error(`git ls-tree failed for ${sha}`);
     const files = listed.split("\0").filter((file) => file && isWanted(file));
     const texts = new Map<string, string>();

package/incrementalBuilder/builderGraphPayloads.ts

@@ -0,0 +1,60 @@
+import type { App } from "@akanjs/devkit/commandDecorators";
+import { FrameworkGraph } from "@akanjs/devkit/frameworkGraph";
+import { GitRevision } from "@akanjs/devkit/gitRevision";
+import { WorkspaceGraph } from "@akanjs/devkit/workspaceGraph";
+import type { BuildChangesPayload, BuilderGraphReq, BuildFrameworkPayload, BuildGraphPayload } from "akanjs/server";
+
+export class BuilderGraphPayloads {
+  readonly #app: App;
+  readonly #generation: () => number;
+  #graph: { generation: number; payload: BuildGraphPayload } | null = null;
+  #changes: { key: string; payload: Promise<BuildChangesPayload> } | null = null;
+
+  constructor(app: App, generation: () => number) {
+    this.#app = app;
+    this.#generation = generation;
+  }
+
+  touched(files: string[]) {
+    FrameworkGraph.touched(this.#app.workspace.workspaceRoot, files);
+  }
+
+  async of(msg: BuilderGraphReq): Promise<BuildGraphPayload | BuildChangesPayload | BuildFrameworkPayload> {
+    if (msg.framework) return await this.#framework();
+    return msg.changes ? await this.#changesSince(msg.changes.since) : await this.#workspaceGraph();
+  }
+
+  async #workspaceGraph(): Promise<BuildGraphPayload> {
+    const generation = this.#generation();
+    if (this.#graph?.generation !== generation) {
+      const { workspace } = this.#app;
+      const graph = WorkspaceGraph.visibleTo(await WorkspaceGraph.build(workspace), this.#app.name);
+      this.#graph = { generation, payload: { workspaceRoot: workspace.workspaceRoot, graph } };
+    }
+    return this.#graph.payload;
+  }
+
+  async #framework(): Promise<BuildFrameworkPayload> {
+    const { workspaceRoot } = this.#app.workspace;
+    return { workspaceRoot, framework: await FrameworkGraph.cached(workspaceRoot) };
+  }
+
+  async #changesSince(since: string | null): Promise<BuildChangesPayload> {
+    const { workspace, name } = this.#app;
+    const { workspaceRoot } = workspace;
+    const forkPoint = await new GitRevision(workspaceRoot).forkPointOf(since);
+    if (forkPoint.error !== undefined) return { workspaceRoot, changes: { error: forkPoint.error } };
+    const key = `${this.#generation()}:${forkPoint.sha}`;
+    if (this.#changes?.key !== key) {
+      const payload = WorkspaceGraph.changesAt(workspace, forkPoint.sha).then((changes) => ({
+        workspaceRoot,
+        changes: WorkspaceGraph.changesVisibleTo(changes, name),
+      }));
+      payload.catch(() => {
+        if (this.#changes?.payload === payload) this.#changes = null;
+      });
+      this.#changes = { key, payload };
+    }
+    return await this.#changes.payload;
+  }
+}

package/incrementalBuilder/incrementalBuilder.proc.test.ts

@@ -218,7 +218,11 @@ process.send({ type: "build-batch-result", data: { generation, errors: {}, artif
     const graph = answerTo(5);
     if (!("graph" in graph)) throw new Error("build-graph answered with changes");
     expect(graph.workspaceRoot).toBe(root);
-    expect(graph.graph.nodes.map((node) => node.id).sort()).toEqual(["model:apps/demo:memo", "model:libs/shared:file"]);
+    expect(graph.graph.nodes.map((node) => node.id).sort()).toEqual([
+      "model:apps/demo:memo",
+      "model:libs/shared:file",
+      "route:apps/demo:/",
+    ]);
     const changes = answerTo(6);
     if (!("changes" in changes) || "error" in changes.changes)
       throw new Error(`no changes: ${JSON.stringify(changes)}`);
@@ -227,6 +231,66 @@ process.send({ type: "build-batch-result", data: { generation, errors: {}, artif
     expect(answerTo(7)).toEqual(changes);
   }, 30_000);
 
+  test("maps the framework on request, and maps it again after a save under pkgs/akanjs", async () => {
+    const { root } = track(await createTempApp("demo"));
+    const appDir = path.join(root, "apps/demo");
+    await writeText(
+      path.join(root, "pkgs/@akanjs/devkit/incrementalBuilder/buildBatch.proc.ts"),
+      `const { generation } = JSON.parse(process.argv[2]);
+process.send({ type: "build-batch-result", data: { generation, errors: {}, artifact: {}, optimizedFonts: { css: "", files: [] } } });
+`,
+    );
+    await writeText(path.join(appDir, "page/_index.tsx"), "export default () => null;\n");
+    await writeText(
+      path.join(appDir, "tsconfig.json"),
+      JSON.stringify({ compilerOptions: { target: "ESNext", paths: { "akanjs/*": ["./pkgs/akanjs/*"] } } }),
+    );
+    await writeText(path.join(root, "pkgs/akanjs/base/scalar.ts"), "export class Scalar {}\n");
+    const messages: BuilderMessage[] = [];
+    const proc = Bun.spawn(["bun", path.join(import.meta.dir, "incrementalBuilder.proc.ts")], {
+      cwd: appDir,
+      env: {
+        ...process.env,
+        AKAN_WORKSPACE_ROOT: root,
+        AKAN_PUBLIC_APP_NAME: "demo",
+        AKAN_PUBLIC_REPO_NAME: "repo",
+        AKAN_PUBLIC_SERVE_DOMAIN: "localhost",
+        AKAN_PUBLIC_ENV: "local",
+      },
+      stdio: ["ignore", "ignore", "pipe"],
+      serialization: "advanced",
+      ipc: (message: BuilderMessage) => {
+        messages.push(message);
+      },
+    });
+    const classesAnsweredTo = async (id: number) => {
+      proc.send({ type: "build-graph", id, framework: true } satisfies BuilderMessage);
+      await until(proc, `build-graph-res ${id}`, () =>
+        messages.some((message) => message.type === "build-graph-res" && message.id === id),
+      );
+      const answer = messages.find((message) => message.type === "build-graph-res" && message.id === id);
+      if (answer?.type !== "build-graph-res" || !answer.ok || !("framework" in answer.data))
+        throw new Error(`no framework map: ${JSON.stringify(answer)}`);
+      expect(answer.data.workspaceRoot).toBe(root);
+      return answer.data.framework?.facets.flatMap(({ classes }) => classes.map(({ name }) => name));
+    };
+    try {
+      await until(proc, "builder-ready", () => messages.some((message) => message.type === "builder-ready"));
+      expect(await classesAnsweredTo(1)).toEqual(["Scalar"]);
+      await writeText(path.join(root, "pkgs/akanjs/base/scalar.ts"), "export class Scalar {}\nexport class Unit {}\n");
+      const deadline = Date.now() + 15_000;
+      let id = 2;
+      while (Date.now() < deadline) {
+        if ((await classesAnsweredTo(id++))?.includes("Unit")) break;
+        await wait(200);
+      }
+      expect(await classesAnsweredTo(id)).toEqual(["Scalar", "Unit"]);
+    } finally {
+      proc.kill();
+      await proc.exited;
+    }
+  }, 40_000);
+
   test("answers a second shell request in the same generation without building again", async () => {
     const { root } = track(await createTempApp("demo"));
     const appDir = path.join(root, "apps/demo");

package/incrementalBuilder/incrementalBuilder.proc.ts

@@ -18,18 +18,14 @@ import { RouteClientBuilder } from "@akanjs/devkit/frontendBuild/routeClientBuil
 import { ServerGraphFile } from "@akanjs/devkit/frontendBuild/serverGraphFile";
 import { SsrDevBundler } from "@akanjs/devkit/frontendBuild/ssrDevBundler";
 import { WatchRootResolver } from "@akanjs/devkit/frontendBuild/watchRootResolver";
-import { GitRevision } from "@akanjs/devkit/gitRevision";
-import { WorkspaceGraph } from "@akanjs/devkit/workspaceGraph";
 import { Logger } from "akanjs/common";
 import type {
   BaseBuildArtifact,
-  BuildChangesPayload,
   BuilderCsrReq,
   BuilderGraphReq,
   BuilderMessage,
   BuilderReq,
   BuilderRes,
-  BuildGraphPayload,
   BuildPhase,
   BuildRouteResultPayload,
   ChangeBatch,
@@ -39,6 +35,7 @@ import { CSR_DEV_PATCHING_MARKER } from "akanjs/server/hmr/csrDevManifest";
 import type { BuildBatchNeed, BuildBatchRequest, BuildBatchResult, OptimizedFonts } from "./buildBatchProtocol";
 import { BuildBatchRunner } from "./buildBatchRunner";
 import { BuilderChannel } from "./builderChannel";
+import { BuilderGraphPayloads } from "./builderGraphPayloads";
 import { type BatchJob, BuilderWorkQueue, type DiscoveryJob } from "./builderWorkQueue";
 import { prepareDevWatchBatch } from "./devWatchBatch";
 
@@ -69,8 +66,7 @@ class IncrementalBuilder {
   #watcher: HmrWatcher | null = null;
   #generation = 0;
   #shellKey: string | null = null;
-  #graph: { generation: number; payload: BuildGraphPayload } | null = null;
-  #changes: { key: string; payload: Promise<BuildChangesPayload> } | null = null;
+  readonly #graphPayloads: BuilderGraphPayloads;
   #discoveredThrough = 0;
   #csrActive = IncrementalBuilder.#csrArmedByEnv();
   #csrBundler: CsrDevBundler;
@@ -122,6 +118,7 @@ class IncrementalBuilder {
     this.#discovery = options.discovery;
     this.#generation = options.initialGeneration ?? 0;
     this.#discoveredThrough = this.#generation;
+    this.#graphPayloads = new BuilderGraphPayloads(options.app, () => this.#generation);
     this.#batchRunner = new BuildBatchRunner({
       workspaceRoot: options.app.workspace.workspaceRoot,
       cwd: options.app.cwdPath,
@@ -370,6 +367,7 @@ class IncrementalBuilder {
   }
 
   async #handleWatchBatch(batch: ChangeBatch) {
+    this.#graphPayloads.touched(batch.files);
     const rawKinds = new Set(batch.kinds);
     if (rawKinds.size === 0) return;
     const generation = ++this.#generation;
@@ -882,7 +880,7 @@ class IncrementalBuilder {
 
   async handleBuildGraph(msg: BuilderGraphReq): Promise<void> {
     try {
-      const data = msg.changes ? await this.#changesPayload(msg.changes.since) : await this.#graphPayload();
+      const data = await this.#graphPayloads.of(msg);
       await BuilderChannel.send({ type: "build-graph-res", id: msg.id, ok: true, data });
     } catch (err) {
       const error = ApplicationBuildReporter.formatError(err, this.#app.workspace.workspaceRoot);
@@ -891,35 +889,6 @@ class IncrementalBuilder {
     }
   }
 
-  async #graphPayload(): Promise<BuildGraphPayload> {
-    const generation = this.#generation;
-    if (this.#graph?.generation !== generation) {
-      const { workspace } = this.#app;
-      const graph = WorkspaceGraph.visibleTo(await WorkspaceGraph.build(workspace), this.#app.name);
-      this.#graph = { generation, payload: { workspaceRoot: workspace.workspaceRoot, graph } };
-    }
-    return this.#graph.payload;
-  }
-
-  async #changesPayload(since: string | null): Promise<BuildChangesPayload> {
-    const { workspace, name } = this.#app;
-    const { workspaceRoot } = workspace;
-    const forkPoint = await new GitRevision(workspaceRoot).forkPointOf(since);
-    if (forkPoint.error !== undefined) return { workspaceRoot, changes: { error: forkPoint.error } };
-    const key = `${this.#generation}:${forkPoint.sha}`;
-    if (this.#changes?.key !== key) {
-      const payload = WorkspaceGraph.changesAt(workspace, forkPoint.sha).then((changes) => ({
-        workspaceRoot,
-        changes: WorkspaceGraph.changesVisibleTo(changes, name),
-      }));
-      payload.catch(() => {
-        if (this.#changes?.payload === payload) this.#changes = null;
-      });
-      this.#changes = { key, payload };
-    }
-    return await this.#changes.payload;
-  }
-
   // On demand: dev serves CSR only via the opt-in `/__csr` and `?csr=true` routes; once built, it rebuilds every save.
   async handleBuildCsr(msg: BuilderCsrReq): Promise<void> {
     if (msg.shell) {

package/integration/devStability.integration.test.ts

@@ -1,7 +1,7 @@
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { AkanAppHost } from "../akanApp";
 import { DevGeneratedIndexSync } from "../frontendBuild";
-import { DevStabilityHarness, type DevStabilityHmrProbe } from "./devStabilityHarness";
+import { DevStabilityHarness, type DevStabilityHmrProbe } from "./devStabilityHarness.fixture";
 
 const integrationEnabled = process.env.AKAN_DEV_STABILITY_INTEGRATION === "1";
 // Contention pushes a cold dev-server boot from ~3s to nearly a minute; 120s ran out mid-restart.

package/integration/devStabilityHarness.test.ts

@@ -2,7 +2,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { mkdir, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { tempDirs } from "../testHelpers";
-import { DevStabilityHarness } from "./devStabilityHarness";
+import { DevStabilityHarness } from "./devStabilityHarness.fixture";
 
 const servers: Bun.Server<undefined>[] = [];
 const makeRoot = tempDirs("akan-harness-port-");

package/lint/no-deep-internal-import.grit

@@ -19,7 +19,7 @@ or {
     $source <: r"\"\.\./\.\./.*\"",
     register_diagnostic(
       span = $source,
-      message = "Module files should not import from two or more parent directories."
+      message = "Module files should not import from two or more parent directories. Import from the layer barrel instead: @apps/<app>/<layer> or @libs/<lib>/<layer>."
     )
   },
   JsModuleSource() as $source where {

package/maintainabilityBaseline.ts

@@ -16,14 +16,16 @@ export interface BaselineEntry {
 
 type Counts = ReadonlyMap<string, number>;
 
-//* One section per rule, each key holding what the gate measured: lines, store accesses, writes or calls. A count
-//* only falls, so a recorded entry cannot take on more of the debt it records.
+//* One section per rule, each key holding what the gate measured: lines, members, store accesses, writes or calls.
+//* A count only falls, so a recorded entry cannot take on more of the debt it records.
 export class MaintainabilityBaseline {
   static readonly fileName = "akan.baseline.json";
   static readonly reasonMinChars = 10;
   static readonly debtRules = [
     "akan.size.file",
     "akan.size.component",
+    "akan.size.function",
+    "akan.size.class",
     "akan.component.store-access",
     "akan.store.multi-write",
     "akan.store.root-write-chain",
@@ -34,12 +36,15 @@ export class MaintainabilityBaseline {
   static readonly reasonedRules: ReadonlySet<DebtRuleId> = new Set([
     "akan.size.file",
     "akan.size.component",
+    "akan.size.function",
+    "akan.size.class",
     "akan.component.store-access",
     "akan.service.call-in-loop",
   ]);
 
   static countOf(violation: MaintainabilityViolation) {
     if (violation.kind === "size") return violation.lineCount;
+    if (violation.kind === "classSize") return violation.memberCount;
     if (violation.kind === "storeAccess") return violation.accessCount;
     if (violation.kind === "multiWrite") return violation.writeCount;
     if (violation.kind === "writePlacement") return violation.writes.length;

package/maintainabilityContract.test.ts

@@ -498,6 +498,8 @@ describe("MaintainabilityContract rules", () => {
     expect(MaintainabilityContract.ruleIds).toEqual([
       "akan.size.file",
       "akan.size.component",
+      "akan.size.function",
+      "akan.size.class",
       "akan.store.multi-write",
       "akan.store.root-write-chain",
       "akan.component.write-chain",
@@ -844,3 +846,184 @@ export class CourtEndpoint extends endpoint(srv.court, ({ mutation }) => ({
     expect(await contractOf(root).enforce({ fix: false })).toEqual([]);
   });
 });
+
+describe("MaintainabilityContract packages", () => {
+  const packageOf = (root: string) => new MaintainabilityContract(root, { type: "pkg", name: "@demo/core" });
+  const functionOf = (name: string, lineNum: number) => `export function ${name}() {\n${linesOf(lineNum - 2)}\n}\n`;
+  const classOf = (name: string, memberNum: number) =>
+    `export class ${name} {\n${Array.from({ length: memberNum }, (_, idx) => `  field${idx} = ${idx};`).join("\n")}\n}\n`;
+
+  test("holds a package file to 800 lines, a function to 150 and a class to 60 members, tests and barrels aside", async () => {
+    const root = await makeWorkspace({
+      "pkgs/@demo/core/server/host.ts": `${classOf("Host", 61)}${functionOf("boot", 151)}${linesOf(600)}`,
+      "pkgs/@demo/core/server/atLimit.ts": `${classOf("Small", 60)}${functionOf("fits", 150)}${linesOf(800 - 212)}\n`,
+      "pkgs/@demo/core/server/host.test.ts": `${functionOf("suite", 900)}`,
+      "pkgs/@demo/core/server/host.fixture.ts": `${functionOf("fixture", 900)}`,
+      "pkgs/@demo/core/server/host.instance.ts": `${functionOf("instance", 900)}`,
+      "pkgs/@demo/core/test/helpers.ts": `${functionOf("helper", 900)}`,
+      "pkgs/@demo/core/types.d.ts": linesOf(900),
+      "pkgs/@demo/core/index.ts": Array.from({ length: 801 }, (_, idx) => `export * from "./m${idx}";`).join("\n"),
+    });
+
+    expect(await packageOf(root).measure()).toEqual([
+      {
+        kind: "size",
+        rule: "akan.size.file",
+        key: "server/host.ts",
+        file: "server/host.ts",
+        line: 1,
+        lineCount: 814,
+        maxLines: 800,
+      },
+      {
+        kind: "size",
+        rule: "akan.size.function",
+        key: "server/host.ts#boot",
+        file: "server/host.ts",
+        line: 64,
+        lineCount: 151,
+        maxLines: 150,
+        function: "boot",
+      },
+      {
+        kind: "classSize",
+        rule: "akan.size.class",
+        key: "server/host.ts#Host",
+        file: "server/host.ts",
+        line: 1,
+        owner: "Host",
+        memberCount: 61,
+        maxMembers: 60,
+      },
+    ]);
+  });
+
+  test("reads a package in a repository through git, so ignored output is never measured", async () => {
+    const root = await makeWorkspace({
+      ".gitignore": "**/dist\n",
+      "pkgs/@demo/core/dist/bundle.ts": linesOf(900),
+      "pkgs/@demo/core/server/committed.ts": linesOf(801),
+    });
+    await commitAll(root);
+    await writeText(path.join(root, "pkgs/@demo/core/server/untracked.ts"), linesOf(802));
+
+    expect((await packageOf(root).measure()).map(({ key }) => key)).toEqual([
+      "server/committed.ts",
+      "server/untracked.ts",
+    ]);
+  });
+
+  test("measures nothing in a package git ignores whole, and leaves a package's examples out", async () => {
+    const root = await makeWorkspace({
+      ".gitignore": "pkgs/gen/\n",
+      "pkgs/gen/package.json": "{}\n",
+      "pkgs/gen/big.ts": functionOf("generated", 162),
+      "pkgs/@demo/core/examples/sample/src/selftest.ts": functionOf("runSelftest", 900),
+    });
+    await commitAll(root);
+
+    expect(await new MaintainabilityContract(root, { type: "pkg", name: "gen" }).measure()).toEqual([]);
+    expect(await packageOf(root).measure()).toEqual([]);
+  });
+
+  test("numbers only the breaches sharing a name, so a short function above leaves a recorded key in place", async () => {
+    const callbackOf = (receiver: string, lineNum: number) => `${receiver}.map(() => {\n${linesOf(lineNum - 2)}\n});\n`;
+    const root = await makeWorkspace({
+      "pkgs/@demo/core/run.ts": `ys.map(() => 1);\n${callbackOf("xs", 160)}${callbackOf("zs", 170)}`,
+    });
+
+    expect((await packageOf(root).measure()).map(({ key }) => key)).toEqual(["run.ts#map()", "run.ts#map()[2]"]);
+  });
+
+  test("records a package's breaches in its own baseline, which only shrinks from the default branch", async () => {
+    const root = await makeWorkspace({ "pkgs/@demo/core/server/host.ts": functionOf("boot", 200) });
+
+    expect((await packageOf(root).seed()).result).toBe("written");
+    expect(await readFile(path.join(root, "pkgs/@demo/core/akan.baseline.json"), "utf8")).toBe(
+      '{\n  "akan.size.function": {\n    "server/host.ts#boot": 200\n  }\n}\n',
+    );
+    await commitAll(root);
+    await writeText(path.join(root, "pkgs/@demo/core/server/host.ts"), functionOf("boot", 210));
+
+    const contract = packageOf(root);
+    const failures = await contract.enforce({ fix: false });
+
+    expect(failures).toMatchObject([{ rule: "akan.size.function", key: "server/host.ts#boot", recorded: 200 }]);
+    expect(contract.describe(failures)).toBe(
+      "[maintainability] 1 violation(s) in pkgs/@demo/core:\n" +
+        "  pkgs/@demo/core/server/host.ts:1  akan.size.function  function boot has 210 lines, over the 150-line limit, up from 200\n" +
+        "How to fix:\n" +
+        "  function: Split it by family into named functions or a collaborator class, each under the limit, keeping its signature for callers.",
+    );
+  });
+});
+
+describe("MaintainabilityContract reference without a baseline", () => {
+  const packageOf = (root: string) => new MaintainabilityContract(root, { type: "pkg", name: "@demo/core" });
+  const functionOf = (name: string, lineNum: number) => `export function ${name}() {\n${linesOf(lineNum - 2)}\n}\n`;
+  const host = "pkgs/@demo/core/server/host.ts";
+  const writePackageBaseline = async (root: string, json: object) =>
+    await writeText(path.join(root, "pkgs/@demo/core/akan.baseline.json"), `${JSON.stringify(json, null, 2)}\n`);
+
+  test("refuses an entry for debt the fork point's code did not hold, unless a person gave it a reason", async () => {
+    const root = await makeWorkspace({ [host]: functionOf("boot", 100) });
+    await commitAll(root);
+    await writeText(path.join(root, host), functionOf("boot", 200));
+    await writePackageBaseline(root, { "akan.size.function": { "server/host.ts#boot": 200 } });
+
+    const contract = packageOf(root);
+    const failures = await contract.enforce({ fix: false });
+
+    expect(failures).toMatchObject([
+      { kind: "baselineGrowth", key: "server/host.ts#boot", count: 200, committed: undefined, measured: true, line: 3 },
+    ]);
+    expect(contract.describe(failures)).toMatch(
+      /pkgs\/@demo\/core\/akan\.baseline\.json:3 {2}akan\.baseline\.growth {2}entry "server\/host\.ts#boot" under akan\.size\.function is debt the code at [0-9a-f]{12} does not hold/,
+    );
+
+    await writePackageBaseline(root, {
+      "akan.size.function": { "server/host.ts#boot": 200 },
+      reasons: { "server/host.ts#boot": "One state machine a person chose to keep whole." },
+    });
+    expect(await packageOf(root).enforce({ fix: false })).toEqual([]);
+  });
+
+  test("lets a scope adopt the gate with the debt its code held at the fork point, and no more", async () => {
+    const root = await makeWorkspace({ [host]: functionOf("boot", 200) });
+    await commitAll(root);
+
+    expect((await packageOf(root).seed()).result).toBe("written");
+    expect(await packageOf(root).enforce({ fix: false })).toEqual([]);
+
+    await writeText(path.join(root, host), functionOf("boot", 210));
+    await packageOf(root).seed({ force: true });
+
+    expect(await packageOf(root).enforce({ fix: false })).toMatchObject([
+      { kind: "baselineGrowth", key: "server/host.ts#boot", count: 210, committed: 200, measured: true },
+    ]);
+  });
+
+  test("holds an app new to the branch, or one whose paid-off baseline was removed, to none", async () => {
+    const zone = "apps/demo/lib/court/Court.Zone.tsx";
+    const root = await makeWorkspace({ "apps/other/lib/court/Court.Zone.tsx": linesOf(10) });
+    await commitAll(root);
+    await writeText(path.join(root, zone), linesOf(450));
+    await writeBaseline(root, { "akan.size.file": { "lib/court/Court.Zone.tsx": 450 } });
+
+    expect(await contractOf(root).enforce({ fix: false })).toMatchObject([
+      { kind: "baselineGrowth", key: "lib/court/Court.Zone.tsx", count: 450, committed: undefined, measured: true },
+    ]);
+
+    await writeText(path.join(root, zone), linesOf(400));
+    await contractOf(root).enforce({ fix: true });
+    expect(existsSync(path.join(root, "apps/demo/akan.baseline.json"))).toBe(false);
+    await git(root, "add", "-A");
+    await git(root, "commit", "-q", "-m", "paid off");
+    await writeText(path.join(root, zone), linesOf(450));
+    await writeBaseline(root, { "akan.size.file": { "lib/court/Court.Zone.tsx": 450 } });
+
+    expect(await contractOf(root).enforce({ fix: false })).toMatchObject([
+      { kind: "baselineGrowth", key: "lib/court/Court.Zone.tsx", committed: undefined, measured: true },
+    ]);
+  });
+});