@intentius/chant 0.124.14 → 0.124.15

package/src/workspace/principal-classes.ts

@@ -22,10 +22,9 @@
  * installed package, which must be at the version the base pins.
  */
 
-import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { join, posix } from "node:path";
-import { kindsExportTarget, pinnedPackageDir, type KindLoadProblem, type PinLike } from "./kinds";
+import { checkClassData, diskFiles, mergePinClasses, readClassFiles, type ClassData, type PackageFiles, type PinClassRead } from "./class-data";
+import { pinnedPackageDir, type KindLoadProblem, type PinLike } from "./kinds";
 import schema from "./workspace-principals.schema.json" with { type: "json" };
 import type { TrustPolicy } from "./trust/policy";
 import { joinPath, type WorkspaceTree } from "./tree";
@@ -33,8 +32,7 @@ import { CORE_CLASSES, CORE_PRINCIPAL_CLASSES, grantedClasses, type PrincipalCla
 
 export const PRINCIPALS_SCHEMA_ID = schema.$id;
 
-/** The subpath a package publishes its principal classes at. */
-export const PRINCIPALS_SUBPATH = "./workspace-principals";
+export { PRINCIPALS_SUBPATH } from "./class-data";
 
 export { CORE_CLASSES, CORE_PRINCIPAL_CLASSES, type CorePrincipalClass, type PrincipalClass } from "./identity-gate-rule";
 
@@ -44,8 +42,6 @@ export type PrincipalClassName = string;
 /** The grammar of a class name, as `workspace-principals.schema.json` and the declaration's writeScope keys say it. */
 export const CLASS_NAME = /^(?!x-)[a-z][a-z0-9-]{0,39}$/;
 
-const CORE_ROLES = new Set(CORE_CLASSES.map((c) => c.role).filter((r): r is string => r !== null));
-
 export interface ClassRegistry {
   get(name: string): PrincipalClass | undefined;
   /** Every class name, core first, for "unknown class" messages. */
@@ -111,11 +107,8 @@ function validator(): Validate {
   return compiled;
 }
 
-export interface ClassData {
-  classes: PrincipalClass[];
-  /** Why some of the data can't be used, one line each. Empty when all of it can. */
-  problems: string[];
-}
+export type { ClassData, PackageFiles } from "./class-data";
+export { diskFiles } from "./class-data";
 
 /**
  * Check the text of a principals file against
@@ -135,46 +128,7 @@ export function parseClassData(text: string, source: string): ClassData {
     const problems = (validate.errors ?? []).map((e) => `${source}: ${e.instancePath || "the principals file"} ${e.message ?? "is invalid"}`);
     return { classes: [], problems: [...new Set(problems)] };
   }
-  const problems: string[] = [];
-  const classes: PrincipalClass[] = [];
-  const names = new Set<string>();
-  const roles = new Set<string>();
-  for (const c of (raw as { classes: { name: string; description: string; role: string }[] }).classes) {
-    if ((CORE_PRINCIPAL_CLASSES as readonly string[]).includes(c.name)) {
-      problems.push(`${source}: class ${c.name} is a core class and can't be supplied by a package`);
-      continue;
-    }
-    if (CORE_ROLES.has(c.role)) {
-      problems.push(`${source}: class ${c.name} names the role ${c.role}, which puts a principal in the core ${c.role} class`);
-      continue;
-    }
-    if (names.has(c.name)) {
-      problems.push(`${source}: class ${c.name} is listed twice`);
-      continue;
-    }
-    if (roles.has(c.role)) {
-      problems.push(`${source}: class ${c.name} names the role ${c.role}, which another class in the file names; a role puts a principal in one class`);
-      continue;
-    }
-    names.add(c.name);
-    roles.add(c.role);
-    classes.push({ name: c.name, description: c.description, role: c.role, source });
-  }
-  return { classes, problems };
-}
-
-/** A package's files, by a `/`-separated path inside it, or undefined when one is not there. */
-export type PackageFiles = (path: string) => string | undefined;
-
-/** A package directory on disk. */
-export function diskFiles(dir: string): PackageFiles {
-  return (path) => {
-    try {
-      return readFileSync(join(dir, ...path.split("/")), "utf-8");
-    } catch {
-      return undefined;
-    }
-  };
+  return checkClassData(raw as Parameters<typeof checkClassData>[0], source);
 }
 
 /** A package directory at `dir` in `tree`, such as the workspace at the base revision. */
@@ -192,22 +146,7 @@ export function treeFiles(tree: WorkspaceTree, dir: string): PackageFiles {
 
 /** Read the classes a package publishes at `./workspace-principals`. Reads files only; imports nothing. A package that publishes none supplies none. */
 export function readPackageClasses(files: PackageFiles, source: string): ClassData {
-  const manifest = files("package.json");
-  if (manifest === undefined) return { classes: [], problems: [`${source}: no readable package.json`] };
-  let pkg: Record<string, unknown>;
-  try {
-    pkg = JSON.parse(manifest) as Record<string, unknown>;
-  } catch {
-    return { classes: [], problems: [`${source}: package.json is not JSON`] };
-  }
-  const target = kindsExportTarget(pkg, PRINCIPALS_SUBPATH);
-  if (target === undefined) return { classes: [], problems: [] };
-  if (typeof target !== "string") return { classes: [], problems: [`${source}: ${target.problem}`] };
-  const inside = posix.normalize(target.slice(2));
-  if (inside.startsWith("../") || inside === "..") return { classes: [], problems: [`${source}: exports["${PRINCIPALS_SUBPATH}"] points outside the package`] };
-  const text = files(inside);
-  if (text === undefined) return { classes: [], problems: [`${source}: exports["${PRINCIPALS_SUBPATH}"] names ${target}, which does not exist`] };
-  return parseClassData(text, source);
+  return readClassFiles(files, source, parseClassData);
 }
 
 export interface LoadedClasses {
@@ -227,10 +166,7 @@ export interface LoadedClasses {
  */
 export function loadClassRegistry(pins: readonly PinLike[], workspaceRoot: string, opts: { tree?: WorkspaceTree } = {}): LoadedClasses {
   const problems: KindLoadProblem[] = [];
-  const extra: PrincipalClass[] = [];
-  const byName = new Map<string, string>();
-  const byRole = new Map<string, string>();
-  const clashing = new Set<string>();
+  const reads: PinClassRead[] = [];
   pins.forEach((pin, i) => {
     let files: PackageFiles;
     let source: string;
@@ -247,29 +183,10 @@ export function loadClassRegistry(pins: readonly PinLike[], workspaceRoot: strin
       files = diskFiles(found.dir);
       source = found.source;
     }
-    const read = readPackageClasses(files, source);
-    for (const p of read.problems) problems.push({ pin: i, message: p });
-    for (const c of read.classes) {
-      const named = byName.get(c.name);
-      const roled = byRole.get(c.role!);
-      if (named !== undefined || roled !== undefined) {
-        clashing.add(c.name);
-        if (named !== undefined) {
-          problems.push({ pin: i, message: `class ${c.name} is supplied by both ${named} and ${source}; a class name has one source` });
-        } else {
-          const other = extra.find((e) => e.role === c.role)!;
-          clashing.add(other.name);
-          problems.push({ pin: i, message: `class ${c.name} (${source}) names the role ${c.role}, which class ${other.name} (${roled}) names; a role puts a principal in one class` });
-        }
-        continue;
-      }
-      byName.set(c.name, source);
-      byRole.set(c.role!, source);
-      extra.push(c);
-    }
+    reads.push({ pin: i, source, read: readPackageClasses(files, source) });
   });
-  // A name or role two pins both supply is left out altogether: neither reading is safe.
-  return { registry: createClassRegistry(extra.filter((c) => !clashing.has(c.name))), problems };
+  const merged = mergePinClasses(reads);
+  return { registry: createClassRegistry(merged.classes), problems: [...problems, ...merged.problems].sort((a, b) => a.pin - b.pin) };
 }
 
 /**

package/src/workspace/records-formats.test.ts

@@ -12,7 +12,7 @@
 
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import Ajv2020 from "ajv/dist/2020";
@@ -472,7 +472,12 @@ describe("the write commands through a declared kind (#2680)", () => {
 
 describe("the decision kind", () => {
   test("still reads as markdown front matter, and says so", async () => {
-    const doc = await queryRecords({ kind: "docs/design/decisions/decision.kind.mjs", cwd: REPO });
+    // The repository's own decision records, copied into a one-commit repository:
+    // a read in the real checkout asks git for the history of every pinned path
+    // across thousands of commits, which took 12 s alone and 20+ s under load.
+    cpSync(join(REPO, "docs", "design", "decisions"), join(root, "docs", "design", "decisions"), { recursive: true });
+    commit();
+    const doc = await queryRecords({ kind: "docs/design/decisions/decision.kind.mjs", cwd: root });
     expect(validateOutput(doc)).toBe(true);
     if ("error" in doc) throw new Error(doc.error.message);
     expect(doc.kind.format).toBe("markdown-front-matter");

package/src/workspace/records-sessions-write.test.ts

@@ -12,7 +12,7 @@
 import { cpSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { afterAll, describe, expect, test } from "vitest";
-import { cleanScratch, commitAll, contract, git, REPO, scratchDir } from "./__fixtures__/contract-repo";
+import { cleanScratch, commitAll, contract, git, REPO, repoFixture, scratchDir } from "./__fixtures__/contract-repo";
 import { declareSessions, DECISIONS_KIND, newSessionFields, sessionsRepo, SESSIONS_KIND } from "./__fixtures__/sessions";
 import { sessionSeal } from "./record-sessions";
 import { parseFrontMatter, recordTextDigest } from "./records";
@@ -36,12 +36,12 @@ const code = (doc: object) => ("error" in doc ? (doc as { error: { code: string
 const HEX = /^[0-9a-f]{40}$/;
 
 /** The reference fixture with a declaration, committed. */
-function declared(): string {
+const declared = repoFixture(() => {
   const root = sessionsRepo();
   declareSessions(root);
   commitAll(root, "declare");
   return root;
-}
+});
 
 function front(root: string, path: string): Record<string, unknown> {
   const fm = parseFrontMatter(readFileSync(join(root, path), "utf-8"));

package/src/workspace/status-contract.e2e.test.ts

@@ -0,0 +1,37 @@
+/**
+ * The chant repo's own workspace declaration reads through
+ * `chant workspace status` and validates against the output schema (#2557).
+ * It reads the real checkout, 28 members and a git call or more for each,
+ * which is 5 to 9 s: split from status-contract.test.ts so the unit budget
+ * keeps to fixtures built here (#3880).
+ */
+
+import { join } from "node:path";
+import Ajv2020 from "ajv/dist/2020";
+import { describe, expect, test } from "vitest";
+import { listWorkspace } from "./ls";
+import { workspaceStatus, type StatusDocument } from "./status";
+import schema from "./status.schema.json";
+
+const REPO = join(import.meta.dirname, "..", "..", "..", "..");
+const validate = new Ajv2020({ strict: true, allErrors: true }).compile(schema);
+
+function expectValid(doc: StatusDocument): void {
+  expect(validate(doc), JSON.stringify(validate.errors, null, 2)).toBe(true);
+}
+
+function result(doc: StatusDocument): Extract<StatusDocument, { members: unknown }> {
+  if ("error" in doc) throw new Error(`${doc.error.code}: ${doc.error.message}`);
+  return doc;
+}
+
+describe("the chant repo's own declaration", () => {
+  test("validates and lists every declared member", async () => {
+    const doc = result(await workspaceStatus({ cwd: join(REPO, "packages", "core"), env: "prod", compareTo: "staging" }));
+    expectValid(doc);
+    expect(doc.workspace).toMatchObject({ name: "chant", root: ".", file: "chant.workspace.json" });
+    const ls = listWorkspace({ cwd: REPO });
+    if ("error" in ls) throw new Error(ls.error.message);
+    expect(doc.members.map((m) => m.name)).toEqual(ls.members.map((m) => m.name));
+  });
+});

package/src/workspace/status-contract.test.ts

@@ -7,13 +7,12 @@
  */
 
 import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import Ajv2020 from "ajv/dist/2020";
 import { afterAll, describe, expect, test, vi } from "vitest";
 import type { CommandContext } from "../cli/registry";
-import { listWorkspace } from "./ls";
 import {
   formatStatus,
   runWorkspaceStatus,
@@ -35,8 +34,6 @@ import { runOpLocally } from "../op/local-executor";
 import { shellCmd } from "../op/activities/shell";
 import type { OpConfig } from "../op/types";
 
-const REPO = join(import.meta.dirname, "..", "..", "..", "..");
-
 const ajv = new Ajv2020({ strict: true, allErrors: true });
 const validate = ajv.compile(schema);
 
@@ -98,6 +95,22 @@ function lifecycle(root: string, files: Record<string, string>): string {
   return commit;
 }
 
+/**
+ * Build a fixture repository once and hand each caller its own copy. A repo
+ * costs a dozen git processes; a file copy costs none, and a test may write
+ * to its copy without touching the next test's.
+ */
+function fixture(build: () => string): () => string {
+  let template: string | undefined;
+  return () => {
+    template ??= build();
+    const root = realpathSync(mkdtempSync(join(tmpdir(), "chant-status-")));
+    scratch.push(root);
+    cpSync(template, root, { recursive: true });
+    return root;
+  };
+}
+
 let n = 0;
 /** One ledger line. */
 function release(component: string, env: string, digest: string, gitSha: string, extra: Record<string, string> = {}): string {
@@ -121,7 +134,7 @@ const D = (c: string) => `sha256:${c.repeat(64)}`;
 const declaration = (members: unknown[]) => JSON.stringify({ name: "acme", schema: 1, members }, null, 2);
 
 /** web has moved to _members/ (#2538); api and the root member still read the flat ledger. */
-function twoLayouts(): string {
+const twoLayouts = fixture(() => {
   const root = repo({
     "chant.workspace.json": declaration([
       { name: "site", dir: ".", kind: "other", because: "the root project" },
@@ -142,7 +155,7 @@ function twoLayouts(): string {
     "prod/releases.jsonl": jsonl(release("api", "prod", D("c"), "c".repeat(40))),
   });
   return root;
-}
+});
 
 describe("status output schema", () => {
   test("is a valid draft 2020-12 document with the published $id", () => {
@@ -412,7 +425,7 @@ const NOW = "2026-09-24T00:00:00.000Z";
  * Each gate is in one state: approved, pending with part of a quorum,
  * expired, superseded, and an Op gate that records no environment.
  */
-function gated(): string {
+const gated = fixture(() => {
   const root = twoLayouts();
   lifecycle(root, {
     "_members/web/staging/releases.jsonl": jsonl(release("web", "staging", D("a"), "a".repeat(40))),
@@ -437,7 +450,7 @@ function gated(): string {
     "_gates/nightly.jsonl": jsonl(pending("nightly", "confirm", "2026-09-23T00:00:00.000Z"), approval("nightly", "confirm", "dave", "2026-09-23T01:00:00.000Z")),
   });
   return root;
-}
+});
 
 describe("gate state in chant workspace status --json (#2674)", () => {
   test("each member lists its gates with state, approvals, quorum and the approve line", async () => {
@@ -570,7 +583,7 @@ describe("stewards in chant workspace status --json (#2731)", () => {
   });
 
   /** A box member declaring one steward, local by default and fountain on fountain-k3d. */
-  function stewarded(): string {
+  const stewarded = fixture(() => {
     const steward = {
       kind: "Chant::Steward",
       name: "box-steward",
@@ -594,7 +607,7 @@ describe("stewards in chant workspace status --json (#2731)", () => {
     });
     lifecycle(root, { "README": "ledger\n" });
     return root;
-  }
+  });
 
   test("names the steward, its form in the environment asked for, its Ops, schedules, last runs and lease", async () => {
     const root = stewarded();
@@ -754,14 +767,3 @@ describe("stewards in chant workspace status --json (#2731)", () => {
     expect(doc.members[0].stewardReasons.map((r) => r.code)).toEqual(["stewards-unreadable"]);
   });
 });
-
-describe("chant workspace status on the chant repo (#2557)", () => {
-  test("validates and lists every declared member", async () => {
-    const doc = result(await workspaceStatus({ cwd: join(REPO, "packages", "core"), env: "prod", compareTo: "staging" }));
-    expectValid(doc);
-    expect(doc.workspace).toMatchObject({ name: "chant", root: ".", file: "chant.workspace.json" });
-    const ls = listWorkspace({ cwd: REPO });
-    if ("error" in ls) throw new Error(ls.error.message);
-    expect(doc.members.map((m) => m.name)).toEqual(ls.members.map((m) => m.name));
-  });
-});