@canonical/pragma-cli 0.33.0 → 0.35.0

package/src/testing/perf/measure.ts

@@ -1,7 +1,7 @@
 /**
  * Perf measurement helper for the compiled `pragma` binary.
  *
- * Spawns the standalone binary N times, discards warmups, and reports the
+ * Spawns the shipped entry N times, discards warmups, and reports the
  * median and p95 of the wall-clock durations. Kept dependency-free (only
  * `node:child_process`) so it can run inside vitest without touching the
  * kernel's import graph. Wired up by the perf-spike commit; the skeleton
@@ -62,11 +62,20 @@ export function trimmedMean(sorted: readonly number[], trim = 0.1): number {
 /**
  * Measure the wall-clock cost of running `binary args…` repeatedly.
  *
- * @param binary - Absolute path to the compiled binary.
+ * Every budget argv exits 0 by contract, so a sample that FAILS —
+ * nonzero/killed `status` or a spawn `error` — throws on the spot, naming
+ * the argv and the failure. Without this the timing loop certified
+ * non-runnable artifacts: the staleness gate guarantees the emit's
+ * FRESHNESS, not its runnability, and a truncated artifact (an interrupted
+ * build) failed every spawn in ~0.3ms — sailing under every ceiling and
+ * turning the PROTECTED budgets into a vacuous pass.
+ *
+ * @param binary - Absolute path to the executable to spawn (the runtime, when
+ *   the entry is passed as its first argument).
  * @param args - Arguments passed on each spawn.
  * @param options - Run/warmup counts and env overlay.
  * @returns Median, p95, and the kept samples.
- * @note Impure — spawns child processes.
+ * @note Impure — spawns child processes; throws on the first failing sample.
  */
 export function measureCommand(
   binary: string,
@@ -79,11 +88,21 @@ export function measureCommand(
 
   for (let i = 0; i < runs; i++) {
     const start = performance.now();
-    spawnSync(binary, [...args], {
+    const result = spawnSync(binary, [...args], {
       env: { ...process.env, ...options.env },
       stdio: "ignore",
     });
     const elapsed = performance.now() - start;
+    if (result.error || result.status !== 0) {
+      throw new Error(
+        `measureCommand: \`${[binary, ...args].join(" ")}\` failed on ` +
+          `sample ${i + 1}/${runs} — status ${String(result.status)}, ` +
+          `signal ${String(result.signal)}` +
+          (result.error ? `, error: ${result.error.message}` : "") +
+          ". Every budget argv must exit 0: a binary that cannot run must " +
+          "fail the measurement, not be timed failing.",
+      );
+    }
     if (i >= warmups) samples.push(elapsed);
   }
 

package/src/testing/setupXdgIsolation.ts

@@ -1,27 +1,87 @@
 /**
- * Global test setup: isolate the XDG config, data, and state layers.
+ * Per-file test setup: give every test FILE its own directory inside the run's
+ * temp root, and isolate the XDG config, data, state, and cache layers in it.
  *
- * The layered config reader consults `$XDG_CONFIG_HOME/pragma/config.json`
- * on every read, global-first writes create it, and the project-config
- * evaluator caches compiled configs under `$XDG_STATE_HOME`. Point all three
- * at per-run temp directories so tests neither observe nor pollute the
- * developer's real global state. Individual tests that exercise XDG
- * behaviour override these values themselves.
+ * The layered config reader consults `$XDG_CONFIG_HOME/pragma/config.json` on
+ * every read, global-first writes create it, and the project-config evaluator
+ * caches compiled configs under `$XDG_STATE_HOME`. The store layer writes its
+ * content-addressed pack cache under `$XDG_CACHE_HOME`. Pointing all four at
+ * temp directories is what keeps tests from observing or polluting the
+ * developer's real global state. Individual tests that exercise XDG behaviour
+ * override these values themselves.
+ *
+ * WHY EVERY TEMP PATH IS REDIRECTED, NOT JUST THE FOUR. This module is
+ * registered as `setupFiles`, not `globalSetup`, so vitest executes it once per
+ * test FILE — over a hundred times in a full run, in a fresh process each time.
+ * Four bare module-scope `mkdtempSync` calls therefore left four directories
+ * behind per file with no hook that could ever remove them, and the tests,
+ * helpers and spawned binaries below them left thousands more, until a 12 GB
+ * tmpfs was exhausted. What that exhaustion looks like is why this docblock is
+ * long: a full disk does not read as a full disk. Every worker fails while
+ * IMPORTING its test file, so the suite reports a hundred-odd files failed
+ * against a handful of assertions run — the exact silhouette of a broken build
+ * — and each of those files still passes when run alone.
+ *
+ * So `TMPDIR`, `TMP`, and `TEMP` are pointed at this file's directory before
+ * any other temp directory exists, which puts every later `tmpdir()` consumer
+ * inside it: the four XDG directories here, the `mkdtempSync` calls in the test
+ * files and their helpers, and the subprocesses those tests spawn, which
+ * inherit this environment. 41 of the 82 files that call `mkdtempSync` have no
+ * `rmSync` anywhere in them; none of them needed editing.
+ *
+ * Allocate temp directories freely under `tmpdir()`; they are cleaned for you.
+ * Do not reintroduce a bare `mkdtempSync` rooted at the REAL system temp
+ * directory (`os.tmpdir()` read before this file runs, or an absolute `/tmp`) —
+ * it escapes the run root and leaks, which is how the tmpfs was exhausted the
+ * first time.
+ *
+ * CORRECTNESS LIVES IN THE RUN ROOT, NOT IN THIS FILE'S HOOK. The `afterAll`
+ * below is hygiene: it keeps a long run's peak disk usage flat instead of
+ * letting every finished file's footprint sit until the end. It is not what
+ * makes the run clean. A fully-skipped file runs no `afterAll` at all, and a
+ * worker torn down mid-file runs no hook either, so anything that depended on
+ * this hook would still leak on exactly the cases hardest to notice. What makes
+ * the run clean is `tempRoot.globalSetup.ts`'s teardown, which removes the run
+ * root wholesale after the last worker exits — every file's directory, skipped
+ * or not, hook or no hook.
  */
 
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { afterAll } from "vitest";
+import { requireTempRoot } from "./tempRoot.globalSetup.js";
 
-process.env.XDG_CONFIG_HOME = mkdtempSync(join(tmpdir(), "pragma-test-xdg-"));
-process.env.XDG_DATA_HOME = mkdtempSync(
-  join(tmpdir(), "pragma-test-xdg-data-"),
-);
-process.env.XDG_STATE_HOME = mkdtempSync(
-  join(tmpdir(), "pragma-test-xdg-state-"),
-);
-// The store layer writes the content-addressed pack cache under
-// $XDG_CACHE_HOME — isolate it too so tests never touch the real cache.
-process.env.XDG_CACHE_HOME = mkdtempSync(
-  join(tmpdir(), "pragma-test-xdg-cache-"),
-);
+/**
+ * This test file's directory inside the run root.
+ *
+ * Allocated before the redirection below, so it lands in the run root rather
+ * than inside itself.
+ */
+const fileTempDir = mkdtempSync(join(requireTempRoot(), "file-"));
+
+// Every subsequent `tmpdir()` in this process, and in the processes it spawns,
+// resolves here. Node reads these three names in this order.
+process.env.TMPDIR = fileTempDir;
+process.env.TMP = fileTempDir;
+process.env.TEMP = fileTempDir;
+
+process.env.XDG_CONFIG_HOME = mkdtempSync(join(fileTempDir, "xdg-config-"));
+process.env.XDG_DATA_HOME = mkdtempSync(join(fileTempDir, "xdg-data-"));
+process.env.XDG_STATE_HOME = mkdtempSync(join(fileTempDir, "xdg-state-"));
+process.env.XDG_CACHE_HOME = mkdtempSync(join(fileTempDir, "xdg-cache-"));
+
+/**
+ * Release this file's footprint early, tolerating every failure.
+ *
+ * A removal that fails (a subprocess still holding a descriptor, a mode a
+ * fixture made read-only) must never turn a green run red — the run root's
+ * teardown collects whatever is left regardless, so there is nothing useful to
+ * do here but continue.
+ */
+afterAll(() => {
+  try {
+    rmSync(fileTempDir, { recursive: true, force: true });
+  } catch {
+    // Deliberately swallowed; the run teardown is the backstop. See above.
+  }
+});

package/src/testing/tempRoot.globalSetup.ts

@@ -0,0 +1,122 @@
+/**
+ * Vitest global setup: one temp root for the whole RUN, allocated before any
+ * worker starts and removed when the last one finishes.
+ *
+ * WHY THE ROOT IS RUN-LEVEL AND NOT PER-FILE. Per-file allocation cannot meet
+ * either half of what this fix is for. A file whose every test is skipped runs
+ * no `afterAll`, and a worker torn down mid-file runs no hook at all, so a
+ * per-file scheme always leaves residue behind and has to reclaim it on some
+ * LATER run — which means a run is never actually clean, only eventually
+ * clean. And a per-file allocation fails per FILE: on a full disk every worker
+ * throws while importing its test file, which is the hundred-failures-no-
+ * assertions silhouette this whole change exists to abolish, reproduced by the
+ * cure.
+ *
+ * Run-level fixes both by construction. `setup` runs ONCE, in the main
+ * process, before a single worker exists: a disk that cannot fit one directory
+ * fails here, once, with a message that names the disk. `teardown` runs after
+ * the last worker exits, whatever happened inside it — skipped files, thrown
+ * files, torn-down workers — so one removal reclaims the run's whole
+ * footprint and the net is zero, not "zero after the next run sweeps".
+ *
+ * The path reaches the workers through the environment, which they inherit
+ * from this process. `setupXdgIsolation.ts` reads it, takes a per-file
+ * subdirectory inside it, and points `TMPDIR` there.
+ */
+
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * The variable carrying the run root to the workers.
+ *
+ * Read by `setupXdgIsolation.ts`, which runs in each worker. Not a public
+ * contract: both live only inside this package's test configuration.
+ */
+export const TEMP_ROOT_ENV = "PRAGMA_TEST_TEMP_ROOT";
+
+/**
+ * The one name every run root carries, so a human sweeping by hand — or the
+ * workaround in issue #1000 — can recognise this suite's residue.
+ *
+ * DELIBERATELY VENDOR-FREE. Redirecting `tmpdir()` puts this name inside every
+ * temp path the tests build, and some of them assert on the path text:
+ * `identity.test.ts` derives a skills root under `tmpdir()` and requires it to
+ * carry no distribution name, so a root called `pragma-…` fails a PROTECTED
+ * cell that has nothing to do with temp directories. Keep it clear of
+ * `pragma`, `canonical`, and `design-system`.
+ */
+const ROOT_PREFIX = "vitest-tmproot-";
+
+/** The run root, remembered between {@link setup} and {@link teardown}. */
+let runRoot: string | undefined;
+
+/**
+ * Allocate the run root, or fail the run with a diagnosis rather than a
+ * hundred import errors.
+ *
+ * @returns Nothing; the root is published on the environment.
+ * @note Impure — creates a directory and writes `process.env`.
+ */
+export function setup(): void {
+  const systemTmp = tmpdir();
+  try {
+    runRoot = mkdtempSync(join(systemTmp, ROOT_PREFIX));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    // The whole point of allocating here: ONE failure, named. A full disk
+    // presents as a mass import failure when it is discovered per worker, and
+    // that shape reads as a broken build rather than a full disk — which is
+    // how the leak this file fixes cost so much diagnosis time.
+    throw new Error(
+      `Could not create the test temp root under ${systemTmp}.\n` +
+        `This is a DISK problem, not a test failure: ${reason}\n\n` +
+        `Check free space with \`df -h ${systemTmp}\`, then reclaim this ` +
+        `suite's residue:\n` +
+        `  find ${systemTmp} -maxdepth 1 -type d -name '${ROOT_PREFIX}*' -exec rm -rf {} +`,
+    );
+  }
+  process.env[TEMP_ROOT_ENV] = runRoot;
+}
+
+/**
+ * Remove the run root and everything any worker put inside it.
+ *
+ * Tolerates failure: a removal that throws (a subprocess still holding a
+ * descriptor, a fixture that made a directory read-only) must never turn a
+ * green run red. One leaked root is one directory, and the message says which.
+ *
+ * @note Impure — removes a directory tree.
+ */
+export function teardown(): void {
+  if (runRoot === undefined) return;
+  try {
+    rmSync(runRoot, { recursive: true, force: true });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    console.warn(`Could not remove the test temp root ${runRoot}: ${reason}`);
+  }
+}
+
+/**
+ * The run root, for a worker that needs to allocate inside it.
+ *
+ * @returns The run root path.
+ * @throws If {@link setup} did not run — a configuration error, not a
+ *   transient one, so it says how to fix the config rather than degrading to
+ *   a per-file root that would silently reintroduce the leak.
+ * @note Impure — reads `process.env`.
+ */
+export function requireTempRoot(): string {
+  const root = process.env[TEMP_ROOT_ENV];
+  if (root === undefined || root === "") {
+    throw new Error(
+      `${TEMP_ROOT_ENV} is unset, so the run-level temp root was never ` +
+        `allocated. Add "./src/testing/tempRoot.globalSetup.ts" to this ` +
+        `config's \`globalSetup\` array.`,
+    );
+  }
+  mkdirSync(root, { recursive: true });
+  return root;
+}

package/src/types.ts

@@ -12,8 +12,8 @@ export type { DetailLevel, OutputFormat } from "./constants.js";
 // — Config authoring ————————————————————————————————————————————————————————
 export type {
   Channel,
-  PackageDeclaration,
-  PackageEntry,
+  PackDeclaration,
+  PackSource,
   PragmaConfig,
 } from "./kernel/config/types.js";
 // — Error model —————————————————————————————————————————————————————————————

package/src/capabilities/block/blockList.test.ts

@@ -1,79 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { verbKey } from "../../kernel/packs/uniqueness.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-import type { VerbSpec } from "../../kernel/spec/types.js";
-import { OWL_EXPORT_TTL } from "../../testing/fixtures/graph/owlExport.js";
-import { bootFixtureRuntime } from "../../testing/helpers/fixtureGraph.js";
-import type { BlockRow } from "./blockList.verb.js";
-import { blockModule } from "./index.js";
-
-const listVerb = blockModule.verbs.find(
-  (verb) => verbKey(verb.path) === "block list",
-) as VerbSpec;
-
-const names = (rows: BlockRow[]): string[] =>
-  rows.map((row) => row.name).sort();
-
-/**
- * The OWL-export fixture ships an UNTIERED `ds:Component` (`ds:datePicker`, no
- * `ds:tier`) beside a tiered one (`ds:button`). The pre-fix `block list` gated
- * on a REQUIRED `ds:tier` triple pattern, so `--all-tiers` — which drops the
- * FILTER but not the pattern — still hid the untiered block, contradicting the
- * flag's promise to show every block (A2). A tier-scoped view legitimately
- * omits an untiered block (it joins the list through its tier); `--all-tiers`
- * is the escape that reveals it.
- */
-describe("block list — untiered blocks under --all-tiers (A2)", () => {
-  describe("no tier configured", () => {
-    let runtime: PragmaRuntime;
-    let dispose: () => Promise<void>;
-
-    beforeAll(async () => {
-      const fixture = await bootFixtureRuntime({ ttl: OWL_EXPORT_TTL });
-      runtime = fixture.runtime;
-      dispose = fixture.dispose;
-    });
-    afterAll(() => dispose());
-
-    it("the default view still omits the untiered block", async () => {
-      const rows = (await listVerb.run({}, runtime)) as BlockRow[];
-      expect(names(rows)).toEqual(["Button"]);
-    });
-
-    it("--all-tiers reveals the untiered block", async () => {
-      const rows = (await listVerb.run(
-        { allTiers: true },
-        runtime,
-      )) as BlockRow[];
-      expect(names(rows)).toEqual(["Button", "Date Picker"]);
-    });
-  });
-
-  describe("a tier IS configured", () => {
-    let runtime: PragmaRuntime;
-    let dispose: () => Promise<void>;
-
-    beforeAll(async () => {
-      const fixture = await bootFixtureRuntime({
-        ttl: OWL_EXPORT_TTL,
-        config: { tier: "global", channel: "normal" },
-      });
-      runtime = fixture.runtime;
-      dispose = fixture.dispose;
-    });
-    afterAll(() => dispose());
-
-    it("a scoped tier lists its tiered block, not the untiered one", async () => {
-      const rows = (await listVerb.run({}, runtime)) as BlockRow[];
-      expect(names(rows)).toEqual(["Button"]);
-    });
-
-    it("--all-tiers overrides the scope and reveals the untiered block", async () => {
-      const rows = (await listVerb.run(
-        { allTiers: true },
-        runtime,
-      )) as BlockRow[];
-      expect(names(rows)).toContain("Date Picker");
-    });
-  });
-});

package/src/capabilities/block/blockList.verb.ts

@@ -1,163 +0,0 @@
-/**
- * `block list` — the ONE hand-written read (Risk5).
- *
- * A block list is config-filtered in ways packs cannot express declaratively:
- * the tier CHAIN (a tier makes its whole parent chain visible), the channel
- * (release-level visibility), and the `--all-tiers` escape. Everything else in
- * PR3 is a declarative pack; this verb ports that behaviour directly. It reads
- * the effective tier/channel from config and runs one generated SELECT (no user
- * input in the query — the tier is config, the channel a closed enum).
- */
-
-import { runSelect } from "../../kernel/packs/sparql/runSelect.js";
-import type {
-  ColumnDef,
-  RenderListOptions,
-} from "../../kernel/render/contracts.js";
-import { DEFAULT_PREFIX_MAP } from "../../kernel/render/prefixes.js";
-import {
-  renderListLlm,
-  renderListPlain,
-} from "../../kernel/render/renderers.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { Formatters, VerbSpec } from "../../kernel/spec/types.js";
-import { buildChannelFilter, buildTierFilter } from "./tierChain.js";
-
-/** One block summary row. */
-export interface BlockRow {
-  readonly uri: string;
-  readonly name: string;
-  readonly type: string;
-  readonly tier: string;
-  readonly modifiers: string;
-}
-
-/** Local name of an IRI (`…/global` → `global`; `…#Thing` → `Thing`). */
-function localName(uri: string): string {
-  const hash = uri.lastIndexOf("#");
-  if (hash !== -1) return uri.slice(hash + 1);
-  const slash = uri.lastIndexOf("/");
-  return slash !== -1 ? uri.slice(slash + 1) : uri;
-}
-
-/** Normalize a block's rdf:type to one of the four block kinds. */
-function normalizeType(typeUri: string | undefined): BlockRow["type"] {
-  const local = localName(typeUri ?? "").toLowerCase();
-  return local === "pattern" || local === "layout" || local === "subcomponent"
-    ? local
-    : "component";
-}
-
-const listColumns: ColumnDef<BlockRow>[] = [
-  { key: "name", label: "Name" },
-  { key: "type", label: "Type" },
-  { key: "tier", label: "Tier" },
-  { key: "modifiers", label: "Modifiers", showWhenEmpty: false },
-  { key: "uri", label: "IRI" },
-];
-
-const listOptions: RenderListOptions<BlockRow> = {
-  heading: "Blocks",
-  columns: listColumns,
-  prefixes: DEFAULT_PREFIX_MAP,
-  // Zero blocks is a calm success (exit 0), not an error — the list is scoped by
-  // the active tier chain and channel, so the message names that scope and the
-  // hint offers the escape hatches (a cold store fails earlier with
-  // STORE_UNAVAILABLE, so reaching here means the store is built).
-  emptyMessage: "No blocks found under the current tier and channel.",
-  emptyHint:
-    "Use --all-tiers to ignore the tier filter, or run `pragma sources update` if the store is empty.",
-};
-
-const listFormatters: Formatters<BlockRow[]> = {
-  plain: (rows) => renderListPlain(rows, listOptions),
-  llm: (rows) => renderListLlm(rows, listOptions),
-  json: (rows) => JSON.stringify(rows, null, 2),
-};
-
-/** Build the config-filtered block SELECT for the resolved tier/channel. */
-function buildQuery(
-  tier: string | undefined,
-  channel: import("../../kernel/config/types.js").Channel,
-  allTiers: boolean,
-): string {
-  const tierFilter = allTiers ? "" : buildTierFilter(tier);
-  const channelFilter = buildChannelFilter(channel);
-  // Under --all-tiers, `ds:name`/`ds:tier` become OPTIONAL so a real block that
-  // ships without either is no longer hidden — the flag promises "all blocks",
-  // yet the pre-fix query gated on those as REQUIRED patterns, dropping the
-  // FILTER but not the pattern (A2). In the scoped/default view they stay
-  // required: a block joins the list through its tier, so an untiered block is
-  // intentionally out of a tier-scoped view (and --all-tiers is the escape).
-  const nameTierPatterns = allTiers
-    ? [
-        "  OPTIONAL { ?component ds:name ?name }",
-        "  OPTIONAL { ?component ds:tier ?tier }",
-      ]
-    : ["  ?component ds:name ?name ; ds:tier ?tier ."];
-  return [
-    "SELECT ?component ?type ?name ?tier",
-    '       (GROUP_CONCAT(DISTINCT ?modName; separator=", ") AS ?modifiers)',
-    "WHERE {",
-    "  VALUES ?type { ds:Component ds:Pattern ds:Layout ds:Subcomponent }",
-    "  ?component a ?type .",
-    ...nameTierPatterns,
-    tierFilter ? `  ${tierFilter}` : "",
-    `  ${channelFilter}`,
-    "  OPTIONAL { ?component ds:hasModifierFamily ?mod . ?mod ds:name ?modName }",
-    "}",
-    "GROUP BY ?component ?type ?name ?tier",
-    "ORDER BY ?name",
-  ]
-    .filter((line) => line !== "")
-    .join("\n");
-}
-
-const listVerb: VerbSpec<Record<string, unknown>, BlockRow[]> = {
-  path: ["block", "list"],
-  summary: "List blocks visible under the current tier and channel.",
-  doc: "List design system blocks visible under the active tier chain and channel. Optionally list across every tier, ignoring the tier filter.",
-  params: [
-    {
-      kind: "boolean",
-      name: "allTiers",
-      doc: "Show blocks from all tiers, ignoring the tier filter.",
-    },
-  ],
-  output: { formatters: listFormatters },
-  examples: [
-    { cmd: "pragma block list" },
-    { cmd: "pragma block list --all-tiers" },
-    { cmd: "pragma block list --format llm" },
-  ],
-  capability: {
-    needsStore: true,
-    mutates: false,
-    mcp: {
-      expose: true,
-      annotations: { readOnlyHint: true, openWorldHint: false },
-    },
-  },
-  run: async (params: Record<string, unknown>, rt: PragmaRuntime) => {
-    const layers = await rt.loadConfig();
-    const query = buildQuery(
-      layers.config.tier,
-      layers.config.channel,
-      params.allTiers === true,
-    );
-    const rows = await runSelect(rt, query, "block");
-    return rows.map((row) => ({
-      uri: row.component ?? "",
-      // An unnamed block still needs a token to show — fall back to its IRI's
-      // local name rather than rendering a blank row (A2).
-      name: row.name ?? localName(row.component ?? ""),
-      type: normalizeType(row.type),
-      tier: localName(row.tier ?? ""),
-      modifiers: row.modifiers ?? "",
-    }));
-  },
-};
-
-/** The hand-written `block list` verb. */
-export const blockListVerb = asVerb(listVerb);

package/src/capabilities/block/index.ts

@@ -1,25 +0,0 @@
-/**
- * The `block` capability module — a COMPOSITE: the hand-written `block list`
- * (tier chain + channel + --all-tiers) plus the bundled pack's GraphQL `lookup`.
- *
- * This is the one noun where a declarative pack and a hand-written verb share a
- * module; the pack ships lookup-only, so there is no `(noun, verb)` collision.
- */
-
-import { compilePack } from "../../kernel/packs/compile.js";
-import { DEFAULT_PREFIX_MAP } from "../../kernel/render/prefixes.js";
-import type { CapabilityModule } from "../../kernel/spec/types.js";
-import { blockListVerb } from "./blockList.verb.js";
-import { blockPack } from "./pack.js";
-
-/** The `block` capability module (`list` hand-written, `lookup` from the pack). */
-export const blockModule: CapabilityModule = {
-  name: "block",
-  verbs: [
-    blockListVerb,
-    ...compilePack(blockPack, "bundled:block", DEFAULT_PREFIX_MAP),
-  ],
-  // The bundled design-system domain colophon (authored on the flagship UI-block
-  // noun), surfaced by `pragma colophon` after pragma's own.
-  colophon: blockPack.colophon,
-};