@akanjs/devkit 3.1.1-rc.8 → 3.1.1

package/maintainabilityReport.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, test } from "bun:test";
+import type { SizeViolation } from "./maintainabilityContract";
+import { MaintainabilityReport } from "./maintainabilityReport";
+
+const fileOf = (file: string, lineCount = 450): SizeViolation => ({
+  kind: "size",
+  rule: "akan.size.file",
+  key: file,
+  file,
+  line: 1,
+  lineCount,
+  maxLines: 400,
+});
+
+const fixLinesOf = (message: string) => message.split("How to fix:\n")[1]?.split("\n") ?? [];
+
+describe("MaintainabilityReport", () => {
+  test("gives a client file, a ui/ or webkit/ file, a long component and a busy one the same ordered paths", () => {
+    const message = MaintainabilityReport.describe("apps/demo", [
+      fileOf("lib/court/Court.Zone.tsx"),
+      fileOf("ui/Board.tsx"),
+      fileOf("webkit/useBoard.tsx"),
+      {
+        ...fileOf("lib/court/Court.Zone.tsx", 300),
+        rule: "akan.size.component",
+        key: "lib/court/Court.Zone.tsx#Canvas",
+        line: 4,
+        maxLines: 250,
+        component: "Canvas",
+      },
+      {
+        kind: "storeAccess",
+        rule: "akan.component.store-access",
+        key: "lib/court/Court.Zone.tsx#Canvas",
+        file: "lib/court/Court.Zone.tsx",
+        line: 4,
+        component: "Canvas",
+        accessCount: 20,
+        maxAccesses: 16,
+      },
+    ]);
+    const [fix = "", ...rest] = fixLinesOf(message);
+    const order = ["mode/kind table", "webkit/use<X>.tsx", "`common/`", "add-mutation", "`lib/<sub>`"].map((path) =>
+      fix.indexOf(path),
+    );
+
+    expect(rest).toEqual([]);
+    expect(fix).toStartWith(
+      "  *.Zone.tsx, ui/**, webkit/**, component or hook, component or hook reaching the store often: ",
+    );
+    expect(order.every((idx) => idx > 0)).toBe(true);
+    expect([...order].sort((a, b) => a - b)).toEqual(order);
+    expect(fix).toContain('`{ [kind in cnst.X["value"]]: … }`');
+    expect(fix).toContain("akan workflow plan create-interaction");
+    expect(fix).toContain("never model-bound code moved into `ui/`");
+  });
+
+  test("names a write sent from the wrong place, a call per item and a raised entry with their own fixes", () => {
+    const message = MaintainabilityReport.describe("apps/demo", [
+      {
+        kind: "baselineGrowth",
+        rule: "akan.baseline.growth",
+        key: "lib/court/court.store.ts#assign",
+        file: "akan.baseline.json",
+        line: 5,
+        debtRule: "akan.store.multi-write",
+        count: 3,
+        committed: 2,
+        reference: "3f2a9c1d0b7e",
+      },
+      {
+        kind: "writePlacement",
+        rule: "akan.write.placement",
+        key: "webkit/useBoard.tsx",
+        file: "webkit/useBoard.tsx",
+        line: 7,
+        writes: ["st.do.removeBoard", "fetch.placeBoard"],
+      },
+      {
+        kind: "loopCall",
+        rule: "akan.service.call-in-loop",
+        key: "lib/court/court.service.ts#syncAll",
+        file: "lib/court/court.service.ts",
+        line: 12,
+        owner: "syncAll",
+        calls: ["this.pcService.getPc"],
+        recorded: 0,
+      },
+      {
+        kind: "multiWrite",
+        rule: "akan.component.write-chain",
+        key: "webkit/useBoard.tsx#useBoard",
+        file: "webkit/useBoard.tsx",
+        line: 9,
+        owner: "useBoard",
+        writes: ["st.do.removeBoard (per item)"],
+        writeCount: 2,
+      },
+    ]);
+
+    expect(message).toContain(
+      'akan.baseline.growth  entry "lib/court/court.store.ts#assign" under akan.store.multi-write allows 3 writes, above the 2 at 3f2a9c1d0b7e',
+    );
+    expect(message).toContain(
+      "akan.write.placement  sends 2 server write(s) from outside a store action or a module component: st.do.removeBoard, fetch.placeBoard",
+    );
+    expect(message).toContain(
+      "akan.service.call-in-loop  service method syncAll calls once per item: this.pcService.getPc, more than the 0 recorded",
+    );
+    expect(message).toContain("hook useBoard sends a write per item from one handler: st.do.removeBoard (per item)");
+    expect(fixLinesOf(message).map((line) => line.split(":")[0])).toEqual([
+      "  baseline entry",
+      "  write sent outside a store action or module component",
+      "  service call per item",
+      "  handler with several writes",
+    ]);
+  });
+
+  test("keeps the server files' own fixes", () => {
+    const message = MaintainabilityReport.describe("apps/demo", [
+      fileOf("lib/court/Court.View.tsx"),
+      fileOf("lib/court/court.service.ts", 520),
+    ]);
+
+    expect(fixLinesOf(message)).toEqual([
+      "  *.View.tsx: Move model-independent pieces into ui/ components and display logic onto Light<Model>.",
+      "  *.service.ts: Move state transitions into document chain methods, and split an unrelated responsibility into its own module.",
+    ]);
+  });
+});

package/maintainabilityReport.ts

@@ -0,0 +1,153 @@
+import { AbstractDoc } from "./abstractDoc";
+import type {
+  DebtRuleId,
+  MaintainabilityCommands,
+  MaintainabilityFailure,
+  MaintainabilityRuleId,
+} from "./maintainabilityContract";
+import { type FileKind, MaintainabilityLimits } from "./maintainabilityLimits";
+
+type FixKey = FileKind | Exclude<MaintainabilityRuleId, "akan.size.file">;
+
+export class MaintainabilityReport {
+  static readonly #clientSplitFix =
+    'Split it, in this order: a mode/kind table `{ [kind in cnst.X["value"]]: … }` in place of mode flags, each entry a component of the module owning the data of that kind; an interaction hook in `webkit/use<X>.tsx` with its pure logic in `common/` (`akan workflow plan create-interaction`); the writes behind one endpoint (`akan workflow plan add-mutation`); last, a sub-concept in its own module (`lib/<sub>` or `lib/_<feature>`), never model-bound code moved into `ui/`.';
+  static readonly #serverMarkupFix =
+    "Move model-independent pieces into ui/ components and display logic onto Light<Model>.";
+  static readonly #oneEndpointFix =
+    "Make it one service method that runs the writes inside `this.transaction(fn)`, with a side effect such as a push command in `this.afterCommit(fn)`, behind one endpoint the action calls once; a write per item becomes one endpoint taking the list. An MCP agent or another screen calling one endpoint alone skips the rest.";
+  static readonly #fixes: { [key in FixKey]: string } = {
+    ".Template.tsx": MaintainabilityReport.#clientSplitFix,
+    ".Unit.tsx": MaintainabilityReport.#serverMarkupFix,
+    ".Util.tsx": MaintainabilityReport.#clientSplitFix,
+    ".View.tsx": MaintainabilityReport.#serverMarkupFix,
+    ".Zone.tsx": MaintainabilityReport.#clientSplitFix,
+    "ui/": MaintainabilityReport.#clientSplitFix,
+    "webkit/": MaintainabilityReport.#clientSplitFix,
+    ".store.ts":
+      "Move business logic into the service behind an endpoint and derived values onto Light<Model>; an action is fetch, set, toast.",
+    ".document.ts":
+      "Move display and predicate logic onto Light<Model>, and split an unrelated concept into its own module.",
+    ".service.ts":
+      "Move state transitions into document chain methods, and split an unrelated responsibility into its own module.",
+    [AbstractDoc.suffix]:
+      "Trim the abstract to a title, one sentence naming what the module owns, and a `## Rules` list of the invariants the code cannot show.",
+    "akan.size.component": MaintainabilityReport.#clientSplitFix,
+    "akan.store.multi-write": MaintainabilityReport.#oneEndpointFix,
+    "akan.store.root-write-chain": `A store may call another through \`RootStore\`, but that does not make the writes one. ${MaintainabilityReport.#oneEndpointFix}`,
+    "akan.component.write-chain":
+      "Move the writes into one service method behind one endpoint, called by one store action the handler calls once; a component chaining `st.do` writes, or writing once per item, leaves an agent or another screen half-done.",
+    "akan.component.store-access": MaintainabilityReport.#clientSplitFix,
+    "akan.write.placement":
+      "A server write leaves the browser through one store action, started by one module component. Move a `fetch.<mutation>` into a store action, and hand `ui/` and `webkit/` code the write as an `onX` prop or hook argument from the module's `Zone` or `Util`: they stay free of any one model, and an agent or another screen reaches the write through the store.",
+    "akan.service.call-in-loop":
+      "Load the set once (`load<Model>Many(ids)`, one filter query) or write it once (one batch method), then loop in memory: a call per item is a round trip per item, so the endpoint slows as its input grows.",
+    "akan.baseline.growth":
+      "Restore the entry from the default branch, then split the file or move the writes instead: `akan lint` lowers an entry as the code shrinks and never raises one.",
+  };
+
+  static readonly #labels: { [key in FixKey]?: string } = {
+    "ui/": "ui/**",
+    "webkit/": "webkit/**",
+    "akan.size.component": "component or hook",
+    "akan.store.multi-write": "store action with several writes",
+    "akan.store.root-write-chain": "store method chaining other stores' writes",
+    "akan.component.write-chain": "handler with several writes",
+    "akan.component.store-access": "component or hook reaching the store often",
+    "akan.write.placement": "write sent outside a store action or module component",
+    "akan.service.call-in-loop": "service call per item",
+    "akan.baseline.growth": "baseline entry",
+  };
+
+  static readonly #units: { [rule in DebtRuleId]: string } = {
+    "akan.size.file": "lines",
+    "akan.size.component": "lines",
+    "akan.component.store-access": "store accesses",
+    "akan.store.multi-write": "writes",
+    "akan.store.root-write-chain": "writes",
+    "akan.component.write-chain": "writes",
+    "akan.write.placement": "writes",
+    "akan.service.call-in-loop": "calls per item",
+  };
+
+  static describe(sysPath: string, failures: MaintainabilityFailure[], commands: MaintainabilityCommands = {}) {
+    const groups = new Map<string, { labels: string[]; rules: Set<MaintainabilityRuleId> }>();
+    for (const failure of failures) {
+      const fixKey = MaintainabilityReport.#fixKeyOf(failure);
+      const fix = MaintainabilityReport.#fixes[fixKey];
+      const group = groups.get(fix) ?? { labels: [], rules: new Set() };
+      const label = MaintainabilityReport.#labelOf(fixKey);
+      if (!group.labels.includes(label)) group.labels.push(label);
+      group.rules.add(failure.rule);
+      groups.set(fix, group);
+    }
+    return [
+      `[maintainability] ${failures.length} violation(s) in ${sysPath}:`,
+      ...failures.map(
+        (failure) =>
+          `  ${sysPath}/${failure.file}:${failure.line}  ${failure.rule}  ${MaintainabilityReport.#problemOf(failure)}`,
+      ),
+      "How to fix:",
+      ...[...groups].flatMap(([fix, { labels, rules }]) => [
+        `  ${labels.join(", ")}: ${fix}`,
+        ...[...new Set([...rules].flatMap((rule) => commands[rule] ?? []))].map((command) => `    Path: ${command}`),
+      ]),
+    ].join("\n");
+  }
+
+  static entriesOf(sysPath: string, failures: MaintainabilityFailure[], commands: MaintainabilityCommands = {}) {
+    return failures.map((failure) => ({
+      file: `${sysPath}/${failure.file}`,
+      line: failure.line,
+      rule: failure.rule,
+      problem: MaintainabilityReport.#problemOf(failure),
+      fix: MaintainabilityReport.#fixes[MaintainabilityReport.#fixKeyOf(failure)],
+      path: commands[failure.rule]?.[0] ?? null,
+    }));
+  }
+
+  static #problemOf(failure: MaintainabilityFailure) {
+    if (failure.kind === "baselineGrowth") {
+      const entry = `entry "${failure.key}" under ${failure.debtRule}`;
+      return failure.committed === undefined
+        ? `${entry} is not in the baseline at ${failure.reference}, which may only shrink`
+        : `${entry} allows ${failure.count} ${MaintainabilityReport.#units[failure.debtRule]}, above the ${failure.committed} at ${failure.reference}; the baseline may only shrink`;
+    }
+    const grown = failure.recorded === undefined ? "" : `, more than the ${failure.recorded} recorded`;
+    if (failure.kind === "multiWrite") {
+      const writes = failure.writes.some((write) => write.endsWith("(per item)"))
+        ? "a write per item"
+        : `${failure.writes.length} writes`;
+      const listed = `${failure.writes.join(", ")}${grown}`;
+      if (failure.rule === "akan.component.write-chain")
+        return `${MaintainabilityReport.#unitOf(failure.owner)} ${failure.owner} sends ${writes} from one handler: ${listed}`;
+      if (failure.rule === "akan.store.root-write-chain")
+        return `store method ${failure.owner} chains ${writes} through other stores from the browser: ${listed}`;
+      return `store action ${failure.owner} sends ${writes} from the browser: ${listed}`;
+    }
+    if (failure.kind === "writePlacement")
+      return `sends ${failure.writes.length} server write(s) from outside a store action or a module component: ${failure.writes.join(", ")}${grown}`;
+    if (failure.kind === "loopCall")
+      return `service method ${failure.owner} calls once per item: ${failure.calls.join(", ")}${grown}`;
+    if (failure.kind === "storeAccess")
+      return `${MaintainabilityReport.#unitOf(failure.component)} ${failure.component} reaches the store ${failure.accessCount} times, over the ${failure.maxAccesses}-access limit${failure.recorded === undefined ? "" : `, up from ${failure.recorded}`}`;
+    const subject = failure.component
+      ? `${MaintainabilityReport.#unitOf(failure.component)} ${failure.component} has`
+      : "file has";
+    const up = failure.recorded === undefined ? "" : `, up from ${failure.recorded}`;
+    return `${subject} ${failure.lineCount} lines, over the ${failure.maxLines}-line limit${up}`;
+  }
+
+  static #unitOf(name: string) {
+    return /^use[A-Z]/.test(name) ? "hook" : "component";
+  }
+
+  static #fixKeyOf(failure: MaintainabilityFailure): FixKey {
+    if (failure.rule !== "akan.size.file") return failure.rule;
+    return MaintainabilityLimits.fileKindOf(failure.file) ?? "akan.size.component";
+  }
+
+  static #labelOf(fixKey: FixKey) {
+    return MaintainabilityReport.#labels[fixKey] ?? `*${fixKey}`;
+  }
+}

package/mobile/desktopRelease.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { createHash, generateKeyPairSync, sign } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import * as nativeApi from "akanjs/native/api";
 import { AkanAppConfig } from "../akanConfig";
 import { tempDirs } from "../testHelpers";
 import type { DesktopArch } from "./desktopBin";
@@ -13,12 +14,18 @@ const sha256 = (bytes: string | Uint8Array) => createHash("sha256").update(bytes
 
 const keyOf = () => {
   const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+  const raw = publicKey.export({ format: "der", type: "spki" }).subarray(12).toString("base64");
+  const signature = (bytes: string) => sign(null, Buffer.from(bytes), privateKey).toString("base64");
   return {
-    publicKey: publicKey.export({ format: "der", type: "spki" }).subarray(12).toString("base64"),
-    sign: (bytes: string) => `${sign(null, Buffer.from(bytes), privateKey).toString("base64")}\n`,
+    publicKey: raw,
+    keyId: nativeApi.keyIdOf(raw),
+    sign: (bytes: string) => `${signature(bytes)}\n`,
+    seal: (bytes: string) =>
+      `${JSON.stringify({ manifest: Buffer.from(bytes).toString("base64"), keyId: nativeApi.keyIdOf(raw), signature: signature(bytes) }, null, 2)}\n`,
   };
 };
 const key = keyOf();
+const spare = keyOf();
 const appId = "com.akancad.app";
 
 interface Published {
@@ -35,12 +42,18 @@ const publish = async ({
   channel = "main",
   app = platform === "macos" ? "Akancad.app" : "akancad",
   gz = "the release's gzip tar",
+  target = "default",
+  signer = key,
+  pair = "same",
 }: {
   platform?: DesktopPlatform;
   arch?: DesktopArch;
   channel?: string;
   app?: string;
   gz?: string;
+  target?: string;
+  signer?: ReturnType<typeof keyOf>;
+  pair?: "same" | "earlier" | "none";
 } = {}) => {
   const updatesDir = await makeDir();
   const dir = path.join(updatesDir, `${platform}-${arch}`);
@@ -68,9 +81,17 @@ const publish = async ({
     patches: [{ from, url: `app/${delta}`, sha256: sha256("a delta"), size: 7 }],
     server: true,
   };
-  const bytes = `${JSON.stringify(manifest, null, 2)}\n`;
-  await writeFile(path.join(dir, `${channel}.json`), bytes);
-  await writeFile(path.join(dir, `${channel}.json.sig`), key.sign(bytes));
+  await mkdir(path.join(dir, channel), { recursive: true });
+  await writeFile(
+    path.join(dir, channel, "app.json"),
+    signer.seal(`${JSON.stringify({ ...manifest, schema: 2, target }, null, 2)}\n`),
+  );
+  if (pair !== "none") {
+    const earlier = { ...manifest, sequence: manifest.sequence - 100, bundle: "1.1.0-1761699900" };
+    const bytes = `${JSON.stringify(pair === "same" ? manifest : earlier, null, 2)}\n`;
+    await writeFile(path.join(dir, `${channel}.json`), bytes);
+    await writeFile(path.join(dir, `${channel}.json.sig`), key.sign(bytes));
+  }
   return { updatesDir, dir, tarSha, delta, build } satisfies Published;
 };
 
@@ -80,10 +101,30 @@ const read = (
     platform = "macos",
     arch = "arm64",
     channel = "main",
-    publicKey = key.publicKey,
+    publicKeys = [key.publicKey, spare.publicKey],
+    revokedKeys = [],
+    target = "default",
     id = appId,
-  }: { platform?: DesktopPlatform; arch?: DesktopArch; channel?: string; publicKey?: string; id?: string } = {},
-) => DesktopRelease.read(updatesDir, { platform, arch, channel, appId: id, publicKey });
+  }: {
+    platform?: DesktopPlatform;
+    arch?: DesktopArch;
+    channel?: string;
+    publicKeys?: string[];
+    revokedKeys?: string[];
+    target?: string;
+    id?: string;
+  } = {},
+) =>
+  DesktopRelease.read(updatesDir, {
+    platform,
+    arch,
+    channel,
+    appId: id,
+    target,
+    publicKeys,
+    revokedKeys,
+    api: nativeApi,
+  });
 
 const entriesOf = (archive: string) =>
   Bun.spawnSync(["tar", "-tf", archive]).stdout.toString().split(/\r?\n/).filter(Boolean);
@@ -122,7 +163,8 @@ describe("DesktopRelease", () => {
     const published = await publish();
     const { dir, tarSha, delta } = published;
     await publish({ channel: "develop" }).then(async (other) => {
-      for (const name of ["develop.json", "develop.json.sig"])
+      await mkdir(path.join(dir, "develop"), { recursive: true });
+      for (const name of ["develop.json", "develop.json.sig", "develop/app.json"])
         await writeFile(path.join(dir, name), await readFile(path.join(other.dir, name)));
     });
     await writeFile(path.join(dir, "app", `${sha256("an earlier tar")}.tar.gz`), "an earlier release");
@@ -133,6 +175,7 @@ describe("DesktopRelease", () => {
 
     expect(entries).toEqual([
       "./release.json",
+      "./main/app.json",
       "./main.json",
       "./main.json.sig",
       `./app/${tarSha}.tar.gz`,
@@ -152,24 +195,24 @@ describe("DesktopRelease", () => {
     expect(headers.filter(({ prefix }) => prefix)).toEqual([]);
     expect(headers.filter(({ type }) => type === "x").map(({ paxKeys }) => paxKeys)).toEqual([["path"]]);
     const files = headers.filter(({ type }) => type === "0").map(({ name }) => name);
-    expect(files.slice(0, 3)).toEqual(["./release.json", "./main.json", "./main.json.sig"]);
-    expect(files.slice(3).every((name) => name.startsWith("./app/"))).toBe(true);
-    expect(files.slice(3)).toEqual([`./app/${published.tarSha}.tar.gz`, `./app/${published.delta}`]);
+    expect(files.slice(0, 4)).toEqual(["./release.json", "./main/app.json", "./main.json", "./main.json.sig"]);
+    expect(files.slice(4).every((name) => name.startsWith("./app/"))).toBe(true);
+    expect(files.slice(4)).toEqual([`./app/${published.tarSha}.tar.gz`, `./app/${published.delta}`]);
     expect(Buffer.byteLength(`./app/${published.delta}`)).toBeGreaterThan(100);
   });
 
-  test("the manifest and its signature go in byte for byte, beside a release.json of the CLI and the build time", async () => {
+  test("the envelope and the v1 pair go in byte for byte, beside a release.json of the CLI and the build time", async () => {
     const published = await publish();
     const release = await read(published);
     const record = release.record({ teamId: "ABCDE12345" });
 
     const out = await release.withArchive(record, extract);
 
-    for (const name of ["main.json", "main.json.sig"])
+    for (const name of ["main/app.json", "main.json", "main.json.sig"])
       expect(sha256(await readFile(path.join(out, name)))).toBe(sha256(await readFile(path.join(published.dir, name))));
     expect(await readFile(path.join(out, "release.json"), "utf8")).toBe(`${JSON.stringify(record, null, 2)}\n`);
     expect(record).toEqual({
-      schema: 1,
+      schema: 2,
       cli: AkanAppConfig.akanVersion,
       platform: "macos",
       arch: "arm64",
@@ -192,22 +235,50 @@ describe("DesktopRelease", () => {
     expect(await Bun.file(kept).exists()).toBe(false);
   });
 
-  test("refuses a manifest the target's first key did not sign, before reading anything it names", async () => {
+  test("refuses an envelope no key of the ring signs, or a revoked one, before reading anything it names", async () => {
     const published = await publish();
+    const envelope = path.join(published.dir, "main", "app.json");
+    const untrusted = `${envelope}: the update envelope is signed by key ${key.keyId}, which is not trusted; publish the release again.`;
 
-    await expect(read(published, { publicKey: keyOf().publicKey })).rejects.toThrow(
-      "main.json.sig does not verify with updates.publicKeys[0], the one key installed apps trust",
+    await expect(read(published, { publicKeys: [keyOf().publicKey] })).rejects.toThrow(untrusted);
+    await expect(read(published, { revokedKeys: [key.keyId] })).rejects.toThrow(untrusted);
+  });
+
+  test("takes a release a later key signed, and leaves out a v1 pair that is not that release", async () => {
+    const entriesFor = async (published: Published) => {
+      const release = await read(published);
+      return await release.withArchive(release.record(null), async (archive) => entriesOf(archive).slice(0, 4));
+    };
+    const tail = (published: Published) => `./app/${published.tarSha}.tar.gz`;
+
+    const bySpare = await publish({ signer: spare, pair: "earlier" });
+    expect(await entriesFor(bySpare)).toEqual([
+      "./release.json",
+      "./main/app.json",
+      tail(bySpare),
+      `./app/${bySpare.delta}`,
+    ]);
+    const unpaired = await publish({ pair: "none" });
+    expect((await entriesFor(unpaired)).slice(0, 3)).toEqual(["./release.json", "./main/app.json", tail(unpaired)]);
+    const forged = await publish();
+    await writeFile(
+      path.join(forged.dir, "main.json.sig"),
+      spare.sign(await readFile(path.join(forged.dir, "main.json"), "utf8")),
     );
+    expect((await entriesFor(forged)).slice(0, 3)).toEqual(["./release.json", "./main/app.json", tail(forged)]);
   });
 
   test("refuses a release of another app, and names a channel or CPU it holds none of", async () => {
     const published = await publish();
 
     await expect(read(published, { id: "com.other" })).rejects.toThrow(
-      "is not a release of com.other for macos-arm64 on channel main.",
+      "is not a release of com.other target default for macos-arm64 on channel main.",
+    );
+    await expect(read(published, { target: "pilot" })).rejects.toThrow(
+      `is not a release of ${appId} target pilot for macos-arm64 on channel main.`,
     );
     await expect(read(published, { channel: "develop" })).rejects.toThrow(
-      `${path.join(published.dir, "develop.json")} is missing: run \`akan publish-update\` first.`,
+      `${path.join(published.dir, "develop", "app.json")} is missing: run \`akan publish-update\` first.`,
     );
     await expect(read(published, { arch: "x64" })).rejects.toThrow("macos-x64");
   });
@@ -219,9 +290,9 @@ describe("DesktopRelease", () => {
     const send = () => release.withArchive(release.record(null), async () => "sent");
 
     await writeFile(archive, "the release's gzip tar!");
-    await expect(send()).rejects.toThrow(`${archive} is not the file main.json names: publish the release again.`);
+    await expect(send()).rejects.toThrow(`${archive} is not the file main/app.json names: publish the release again.`);
     await writeFile(archive, "the release's gzip taR");
-    await expect(send()).rejects.toThrow(`${archive} is not the file main.json names (its sha256 differs).`);
+    await expect(send()).rejects.toThrow(`${archive} is not the file main/app.json names (its sha256 differs).`);
   });
 });
 
@@ -310,7 +381,7 @@ describe("DesktopRelease signer", () => {
 
   const windowsTool = (powershell: (out: string) => Promise<number>) =>
     recordingTool(async (cmd, env) => {
-      if (cmd[0] === "tar.exe") {
+      if (cmd[0] === path.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe")) {
         await Bun.write(path.join(extractedTo(cmd), cmd.at(-1) ?? ""), "MZ");
         return { code: 0, output: "" };
       }