@canonical/pragma-cli 0.33.0 → 0.34.0

package/src/capabilities/block/pack.ts

@@ -1,166 +0,0 @@
-/**
- * The bundled `block` pack — the lookup verb only.
- *
- * `block lookup` is served over the GraphQL fetch path (ONE generated document
- * over the `UIBlock` interface covering Component/Pattern/Layout/Subcomponent);
- * `block list` deliberately stays HAND-WRITTEN (tier-chain inheritance + channel
- * + `--all-tiers` — see ./blockList.verb). Base level mirrors the old summary
- * view (name/tier/summary); the default is `detailed`, matching the old CLI
- * which rendered anatomy and modifiers without a flag. A derived name that maps
- * onto no schema field is omitted (OPTIONAL parity), so a graph lacking
- * whenToUse/whenNotToUse degrades gracefully.
- *
- * Disclosure declares the FULL canonical ladder `[summary, standard, detailed]`
- * (B4), the same set `standard` declares, so a config `detail=standard` names a
- * level `block` advertises rather than one it silently accepts-then-degrades.
- * Block carries no `standard`-tier content of its own — gating is by canonical
- * index, so `standard` resolves to the base view — but the declared set now
- * matches its sibling reads. The per-noun DEFAULT stays domain-tuned (`block`
- * rich-by-default, `standard` terse-by-default); only the level SET is aligned.
- */
-
-import type { PackDefinition } from "../../kernel/packs/types.js";
-
-/**
- * The bundled design-system domain colophon — the ontology + graph story,
- * surfaced by `pragma colophon` after pragma's own. Authored on the flagship
- * UI-block noun because `block` most embodies the design system; it narrates the
- * DOMAIN (what the graph models), not the toolchain (pragma's built-in section).
- */
-const DESIGN_SYSTEM_COLOPHON = `The Canonical design system is a **knowledge graph**, not a component library.
-Every block, token, modifier, standard, and tier is a node in an RDF store,
-described by the \`ds:\` ontology and queried the same way whether you reach it
-over GraphQL or raw SPARQL.
-
-## What the graph models
-
-- **Blocks** — components, patterns, layouts, and subcomponents (the \`ds:UIBlock\`
-  family). A block carries its anatomy, guidelines, and \`when to use\` / \`when
-  not to use\` narrative as graph properties, not prose in a wiki.
-- **Modifiers** — families of variant values (\`ds:hasModifierFamily\` →
-  \`ds:hasModifier\`) a block composes, so a variant is a relationship, not a
-  string.
-- **Tokens** — the themeable design values, resolved per theme.
-- **Standards** — the do / don't coding guidance, categorized and linked to the
-  blocks they govern.
-
-## How it fits together
-
-- **Tiers** are a hierarchy (\`global\` > \`apps\` > \`apps/lxd\`): a lower tier
-  inherits and overrides the blocks of its ancestors, so scoping a query to a
-  tier walks that chain.
-- **Channels** (\`normal\`, \`experimental\`, \`prerelease\`) gate visibility, so an
-  in-progress block never leaks into a stable answer.
-
-## Why RDF
-
-One graph makes every relationship first-class and queryable: \`block lookup\`
-follows edges to modifiers and subcomponents, \`graph query\` runs arbitrary
-SPARQL, and \`ontology show\` reads the schema itself. The store is built once
-by \`sources update\` and addressed by content hash, so the domain you query is
-exactly the domain that was published.`;
-
-export const blockPack: PackDefinition = {
-  noun: "block",
-  description: "Look up design system blocks.",
-  colophon: DESIGN_SYSTEM_COLOPHON,
-  lookup: {
-    source: "graphql",
-    toolDescription:
-      'Get detailed information about one or more design system blocks including anatomy, modifiers, and properties. Use when you need the full spec of specific blocks by name — detail: "summary" trims to the base view. Example: block_lookup { names: ["Button"] }.',
-    by: "ds:name",
-    types: ["ds:Component", "ds:Pattern", "ds:Layout", "ds:Subcomponent"],
-    graphqlType: "UIBlock",
-    fields: [
-      { name: "tier", property: "ds:tier", label: "Tier" },
-      {
-        name: "figmaLink",
-        property: "ds:figmaLink",
-        label: "Figma",
-        level: "detailed",
-      },
-    ],
-    sections: [
-      { name: "summary", property: "ds:summary", label: "Summary" },
-      {
-        name: "whenToUse",
-        property: "ds:whenToUse",
-        label: "When to use",
-        level: "detailed",
-      },
-      {
-        name: "whenNotToUse",
-        property: "ds:whenNotToUse",
-        label: "When not to use",
-        level: "detailed",
-      },
-      {
-        name: "guidelines",
-        property: "ds:guidelines",
-        label: "Guidelines",
-        level: "detailed",
-      },
-      {
-        name: "anatomyDsl",
-        property: "ds:anatomyDsl",
-        label: "Anatomy (DSL)",
-        kind: "code",
-        level: "detailed",
-      },
-      {
-        name: "anatomyClassic",
-        property: "ds:anatomyClassic",
-        label: "Anatomy (classic)",
-        kind: "code",
-        level: "detailed",
-      },
-    ],
-    expand: [
-      {
-        name: "modifierFamilies",
-        heading: "Modifier Families",
-        relation: "ds:hasModifierFamily",
-        level: "detailed",
-        select: [
-          { name: "name", property: "ds:name" },
-          {
-            name: "values",
-            relation: "ds:hasModifier",
-            select: [{ name: "name", property: "ds:name" }],
-          },
-        ],
-      },
-      {
-        name: "properties",
-        heading: "Properties",
-        relation: "ds:hasProperty",
-        kind: "table",
-        level: "detailed",
-        select: [
-          { name: "name", property: "ds:name" },
-          { name: "type", property: "ds:propertyType" },
-          { name: "optional", property: "ds:optional" },
-        ],
-      },
-      {
-        name: "subcomponents",
-        heading: "Subcomponents",
-        relation: "ds:hasSubcomponent",
-        level: "detailed",
-        select: [
-          { name: "name", property: "ds:name" },
-          { name: "uri", property: "ds:name", graphqlField: "uri" },
-        ],
-      },
-    ],
-    disclosure: {
-      levels: ["summary", "standard", "detailed"],
-      default: "detailed",
-    },
-    sample: {
-      fixedCount: true,
-      toolDescription:
-        "Return randomly selected complete design-system blocks as exemplars. Use BEFORE writing queries to see actual data shapes, anatomy, and property names.",
-    },
-  },
-};

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

@@ -1,187 +0,0 @@
-/**
- * Block content-parity (PROTECTED) — on a FIXTURE graph, not the live one.
- *
- * The hand-written block lookup is gone; parity is asserted against the fixture
- * graph directly: Button and Modal resolve through the GraphQL `block lookup`
- * with the same content a direct SPARQL oracle returns (summary, guidance,
- * anatomy, tier, modifier families with values, properties, subcomponents). The
- * fixture DECLARES whenToUse/whenNotToUse (which the live graph superseded with
- * ds:usage), so those sections are exercised here. The hand-written `block list`
- * is checked for its tier/channel filtering and --all-tiers.
- */
-
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import type { LookupOutput } from "../../kernel/packs/resolveEntity.js";
-import { verbKey } from "../../kernel/packs/uniqueness.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-import type { VerbSpec } from "../../kernel/spec/types.js";
-import {
-  BLOCK_PREFIXES,
-  BLOCK_TTL,
-} from "../../testing/fixtures/blockGraph.js";
-import { buildFixtureRuntime } from "../../testing/helpers/packRuntime.js";
-import type { BlockRow } from "./blockList.verb.js";
-import { blockModule } from "./index.js";
-
-const DS = "https://ds.canonical.com/";
-
-const listVerb = blockModule.verbs.find(
-  (v) => verbKey(v.path) === "block list",
-) as VerbSpec;
-const lookupVerb = blockModule.verbs.find(
-  (v) => verbKey(v.path) === "block lookup",
-) as VerbSpec;
-
-let rt: PragmaRuntime;
-
-beforeAll(async () => {
-  ({ rt } = await buildFixtureRuntime({
-    ttl: BLOCK_TTL,
-    prefixes: BLOCK_PREFIXES,
-    detail: "detailed",
-  }));
-});
-
-afterAll(async () => {
-  (await rt.store.get()).store.dispose();
-});
-
-async function lookup(name: string): Promise<Record<string, unknown>> {
-  const out = (await lookupVerb.run({ name: [name] }, rt)) as LookupOutput;
-  expect(out.errors).toEqual([]);
-  return out.results.at(0) as Record<string, unknown>;
-}
-
-/** Oracle: a single scalar from the graph, queried directly. */
-async function oracle(subject: string, predicate: string): Promise<string> {
-  const result = await rt.query.sparql(
-    `SELECT ?v WHERE { <${subject}> ${predicate} ?v }`,
-  );
-  return result.type === "select" ? (result.bindings[0]?.v ?? "") : "";
-}
-
-describe("block lookup — Button content parity (GraphQL, detailed)", () => {
-  it("resolves the full Button spec with content matching the SPARQL oracle", async () => {
-    const button = await lookup("Button");
-    expect(button.uri).toBe(`${DS}button`);
-    expect(button.name).toBe("Button");
-    expect(button.tier).toBe(`${DS}global`);
-
-    // Guidance + anatomy sections — each cross-checked against the graph.
-    expect(button.summary).toBe(await oracle(`${DS}button`, "ds:summary"));
-    expect(button.whenToUse).toBe(await oracle(`${DS}button`, "ds:whenToUse"));
-    expect(button.whenNotToUse).toBe(
-      await oracle(`${DS}button`, "ds:whenNotToUse"),
-    );
-    expect(button.guidelines).toBe(
-      await oracle(`${DS}button`, "ds:guidelines"),
-    );
-    expect(button.anatomyDsl).toBe(
-      await oracle(`${DS}button`, "ds:anatomyDsl"),
-    );
-    expect(button.figmaLink).toBe(await oracle(`${DS}button`, "ds:figmaLink"));
-  });
-
-  it("resolves the nested modifier families with values (inverse union)", async () => {
-    const button = await lookup("Button");
-    const families = button.modifierFamilies as {
-      name: string;
-      values?: string[];
-    }[];
-    expect(families.map((f) => f.name).sort()).toEqual([
-      "density",
-      "importance",
-    ]);
-    const importance = families.find((f) => f.name === "importance");
-    expect(importance?.values?.sort()).toEqual(["primary", "secondary"]);
-  });
-
-  it("resolves properties and the subtype-scoped subcomponents identity field", async () => {
-    const button = await lookup("Button");
-    expect(button.properties).toEqual([
-      { name: "disabled", type: "boolean", optional: "true" },
-    ]);
-    expect(button.subcomponents).toEqual([
-      { name: "Button Icon", uri: `${DS}button.icon` },
-    ]);
-  });
-
-  it("renders every declared section in the llm output", async () => {
-    const out = (await lookupVerb.run(
-      { name: ["Button"] },
-      rt,
-    )) as LookupOutput;
-    const llm = lookupVerb.output.formatters.llm(out);
-    expect(llm).toContain("## Button");
-    expect(llm).toContain("### When to use");
-    expect(llm).toContain("### Anatomy (DSL)");
-    expect(llm).toContain("### Modifier Families");
-    expect(llm).toContain("primary");
-  });
-});
-
-describe("block lookup — Modal content parity (GraphQL, detailed)", () => {
-  it("resolves the full Modal spec (a different block, same document engine)", async () => {
-    const modal = await lookup("Modal");
-    expect(modal.uri).toBe(`${DS}modal`);
-    expect(modal.name).toBe("Modal");
-    expect(modal.summary).toBe(await oracle(`${DS}modal`, "ds:summary"));
-    expect(modal.whenToUse).toBe(await oracle(`${DS}modal`, "ds:whenToUse"));
-    const families = modal.modifierFamilies as {
-      name: string;
-      values?: string[];
-    }[];
-    expect(families.map((f) => f.name)).toEqual(["size"]);
-    expect(families[0]?.values?.sort()).toEqual(["large", "small"]);
-    expect(modal.properties).toEqual([
-      { name: "open", type: "boolean", optional: "false" },
-    ]);
-    // Modal has no subcomponents — the subtype-scoped selection is simply absent.
-    expect(modal.subcomponents).toEqual([]);
-  });
-});
-
-describe("block lookup — disclosure trims to the base view at summary", () => {
-  it("summary keeps name/tier/summary and drops the detailed sections/expands", async () => {
-    const out = (await lookupVerb.run(
-      { name: ["Button"] },
-      { ...rt, globalFlags: { ...rt.globalFlags, detail: "summary" } },
-    )) as LookupOutput;
-    const button = out.results.at(0) as Record<string, unknown>;
-    expect(button.name).toBe("Button");
-    expect(button.summary).toBeDefined();
-    expect(button.whenToUse).toBeUndefined();
-    expect(button.anatomyDsl).toBeUndefined();
-    expect(button.modifierFamilies).toBeUndefined();
-    expect(button.figmaLink).toBeUndefined();
-  });
-});
-
-describe("block list — hand-written tier/channel filtering", () => {
-  it("lists visible blocks with the summary row shape", async () => {
-    const rows = (await listVerb.run({}, rt)) as BlockRow[];
-    const byName = new Map(rows.map((r) => [r.name, r]));
-    expect([...byName.keys()].sort()).toEqual(["Button", "Modal"]);
-    const button = byName.get("Button");
-    expect(button?.type).toBe("component");
-    expect(button?.tier).toBe("global");
-    expect(button?.uri).toBe(`${DS}button`);
-    // GROUP_CONCAT of the family names (order-independent).
-    expect(button?.modifiers.split(", ").sort()).toEqual([
-      "density",
-      "importance",
-    ]);
-  });
-
-  it("--all-tiers also reveals the untiered subcomponent (A2)", async () => {
-    // Button Icon is a ds:Subcomponent with NO ds:tier: the scoped/default view
-    // omits it (a block joins the list through its tier), but --all-tiers must
-    // surface every block, including untiered ones.
-    const rows = (await listVerb.run({ allTiers: true }, rt)) as BlockRow[];
-    expect(rows.map((r) => r.name).sort()).toEqual([
-      "Button",
-      "Button Icon",
-      "Modal",
-    ]);
-  });
-});

package/src/capabilities/block/tierChain.ts

@@ -1,78 +0,0 @@
-/**
- * Tier-chain inheritance + channel visibility for the hand-written `block list`.
- *
- * Ported from the v1 filters. Setting a tier activates a parent-chain filter
- * (`apps/lxd` → visible tiers `global`, `apps`, `apps/lxd`); the channel maps to
- * the set of visible release levels. Both are generated SPARQL clauses composed
- * only from validated pack terms — no user input reaches the query text (the
- * tier value comes from config, the channel from a closed enum).
- */
-
-import type { Channel } from "../../kernel/config/types.js";
-
-/** The `ds:` prefix — the store injects its PREFIX declaration. */
-const DS = "ds:";
-
-/** Release levels visible per channel setting. */
-export const CHANNEL_RELEASES: Record<Channel, readonly string[]> = {
-  normal: ["stable"],
-  experimental: ["stable", "experimental"],
-  prerelease: ["stable", "experimental", "alpha", "beta"],
-};
-
-/**
- * The parent chain for a tier path.
- *
- * `apps/lxd` → `["global", "apps", "apps/lxd"]`; `undefined` → `[]` (all tiers).
- */
-export function resolveTierChain(tierPath: string | undefined): string[] {
-  if (tierPath === undefined) return [];
-  const normalized = tierPath.trim().toLowerCase();
-  const chain: string[] = ["global"];
-  const segments = normalized.split("/");
-  for (let i = 0; i < segments.length; i++) {
-    const path = segments.slice(0, i + 1).join("/");
-    if (path !== "global") chain.push(path);
-  }
-  return chain;
-}
-
-/** A tier path's URI local name (slashes → underscores: `apps/lxd` → `apps_lxd`). */
-export function tierPathToLocal(tierPath: string): string {
-  return tierPath.trim().toLowerCase().replace(/\//g, "_");
-}
-
-/**
- * A SPARQL FILTER clause for tier visibility, or empty when no tier is set.
- *
- * @param tierPath - The configured tier path (e.g. `apps/lxd`) or `undefined`.
- * @param varName - The SPARQL variable to filter (default `tier`).
- */
-export function buildTierFilter(
-  tierPath: string | undefined,
-  varName = "tier",
-): string {
-  if (tierPath === undefined) return "";
-  const uriList = resolveTierChain(tierPath)
-    .map((t) => `${DS}${tierPathToLocal(t)}`)
-    .join(", ");
-  return `FILTER(?${varName} IN (${uriList}))`;
-}
-
-/**
- * SPARQL clauses for channel visibility: bind `?release` if present, then filter
- * to allowed levels OR unbound (unannotated blocks are treated as stable).
- *
- * @param channel - The configured channel.
- * @param varName - The SPARQL variable to bind/filter (default `release`).
- */
-export function buildChannelFilter(
-  channel: Channel,
-  varName = "release",
-): string {
-  const uriList = CHANNEL_RELEASES[channel].map((r) => `${DS}${r}`).join(", ");
-  return [
-    `OPTIONAL { ?component ${DS}release ?${varName} }`,
-    `FILTER(!BOUND(?${varName}) || ?${varName} IN (${uriList}))`,
-  ].join("\n    ");
-}

package/src/capabilities/colophon/pragmaColophon.ts

@@ -1,66 +0,0 @@
-/**
- * The built-in pragma colophon — how the toolchain itself is made. Authored
- * Markdown grounded in this tree's real architecture; surfaced by `pragma
- * colophon` as the first section, before any active pack's domain colophon.
- *
- * `PRAGMA_COLOPHON` is the full narrative for humans; `PRAGMA_COLOPHON_SUMMARY`
- * is the condensed form `--format llm` emits (Markdown IS the agent-optimal shape).
- * Both are BODIES with no leading H1 — the renderer supplies the "pragma"
- * heading, so the section is never double-titled.
- */
-
-/** The full built-in colophon (Markdown body). */
-export const PRAGMA_COLOPHON = `pragma is a **domain-based toolchain**: one CLI and one MCP server projected
-from a single grammar, serving a knowledge-graph domain that reads as data.
-
-## The effect monad
-
-Reads are plain \`async\` functions; a mutation instead *describes* its effects
-as a \`Task\` (\`@canonical/task\`) that is interpreted — under the real node
-interpreter, a \`--dry-run\` planner, or an \`--undo\` reverser. Describe-then-
-interpret means dry-run and undo come for free, and the dispatcher tells the two
-worlds apart on one bit: \`capability.mutates\`.
-
-## One grammar, many projections
-
-Every capability is a \`VerbSpec\` — a noun, its params, its effect profile, its
-formatters. The CLI commands, the MCP tools, shell completion, and the
-surface/docs are all *projections* of that one shape, so they cannot drift. The
-projected surface is frozen in a covenant (\`surface/surface.v2.json\`): a single
-source of truth a test asserts the live grammar still emits, tool for tool.
-
-## LLM-optimized output
-
-Each verb renders three ways — \`plain\` for a terminal, \`json\` for the machine
-envelope, and \`llm\` for condensed Markdown. \`--format llm\` (or a non-interactive
-stdout) selects the agent form: the same data, shaped for a model to read. This
-colophon is itself a showcase of that render model.
-
-## Modular, storeless by construction
-
-Capabilities ship as **modules** — named bundles of verbs with optional
-boot / resource / prompt hooks. A verb declares whether it \`needsStore\`, and
-the dispatcher boots the triple store *only* for those; a storeless verb
-(\`info\`, \`config\`, \`capabilities\`, \`colophon\`) never pays for the graph.
-
-## Scaffolding
-
-\`pragma create\` scaffolds components, packages, and applications through the
-\`@canonical/summon-*\` generators, reusing summon's rich Ink wizard when it runs
-interactively.
-
-## The domain reads as data
-
-A domain is a **pack**: a declarative \`PackDefinition\` (its list / lookup
-queries) compiled into verbs, backed by a content-addressed graphpack that
-\`sources update\` builds once. Swap the pack and the same pragma serves a
-different domain — including the domain colophon printed below this one.`;
-
-/** The condensed colophon for `--format llm` (Markdown body, no leading H1). */
-export const PRAGMA_COLOPHON_SUMMARY = `pragma is a domain-based toolchain: one CLI + MCP server projected from a single \`VerbSpec\` grammar.
-
-- **Effect monad** (\`@canonical/task\`): reads are async; a mutation returns an interpreted \`Task\`, so \`--dry-run\` and \`--undo\` are free. The dispatcher branches on \`capability.mutates\`.
-- **One grammar, many projections**: CLI, MCP tools, completion, and docs all project one \`VerbSpec\`; the emitted surface is frozen in a covenant so the projections never drift.
-- **LLM-optimized output**: every verb renders \`plain\` / \`json\` / \`llm\`; \`--format llm\` (or a piped stdout) emits condensed Markdown for agents.
-- **Modular + storeless**: capability modules; the triple store boots only for \`needsStore\` verbs.
-- **Domain as data**: a pack is a declarative \`PackDefinition\` compiled to verbs over a content-addressed graph built by \`sources update\`.`;

package/src/capabilities/modifier/index.ts

@@ -1,15 +0,0 @@
-/**
- * The `modifier` capability module — the bundled pack (SPARQL list, GraphQL
- * lookup) compiled to verbs.
- */
-
-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 { modifierPack } from "./pack.js";
-
-/** The `modifier` capability module (`list`, `lookup`). */
-export const modifierModule: CapabilityModule = {
-  name: "modifier",
-  verbs: compilePack(modifierPack, "bundled:modifier", DEFAULT_PREFIX_MAP),
-};

package/src/capabilities/modifier/pack.ts

@@ -1,64 +0,0 @@
-/**
- * The bundled `modifier` pack — modifier families as data.
- *
- * `modifier list` is SPARQL (an alternation path collects values asserted in
- * either direction); `modifier lookup` is GRAPHQL, where the compiled
- * `ModifierFamily.modifiers` field is the declared-inverse union and resolves
- * both directions in ONE generated document — exactly the case the GraphQL fetch
- * path exists for.
- */
-
-import type { PackDefinition } from "../../kernel/packs/types.js";
-
-export const modifierPack: PackDefinition = {
-  noun: "modifier",
-  description: "List all modifier families.",
-  toolDescription:
-    "List all modifier families with their values. Use when browsing which modifier families exist and the values each allows. Example: modifier_list {}.",
-  list: {
-    query: [
-      "SELECT ?uri ?name",
-      '       (GROUP_CONCAT(DISTINCT ?valueName; separator=", ") AS ?values)',
-      "WHERE {",
-      "  ?uri a ds:ModifierFamily ;",
-      "       ds:name ?name .",
-      "  OPTIONAL {",
-      "    ?uri (ds:hasModifier|^ds:modifierFamily) ?value .",
-      "    ?value ds:name ?valueName .",
-      "  }",
-      "}",
-      "GROUP BY ?uri ?name",
-      "ORDER BY ?name",
-    ].join("\n"),
-    columns: [
-      { field: "uri", label: "IRI" },
-      { field: "name", label: "Name" },
-      { field: "values", label: "Values" },
-    ],
-    emptyRecovery: {
-      message:
-        "No modifier families in the store. Build it from the configured design-system packages.",
-      cli: "pragma sources update",
-    },
-  },
-  lookup: {
-    source: "graphql",
-    by: "ds:name",
-    type: "ds:ModifierFamily",
-    toolDescription:
-      'Get values and usage details for one or more modifier families by name. Use when you need the allowed values of specific families. Example: modifier_lookup { names: ["importance"] }.',
-    expand: [
-      {
-        name: "values",
-        heading: "Values",
-        relation: "ds:hasModifier",
-        select: [{ name: "name", property: "ds:name" }],
-      },
-    ],
-    sample: {
-      fixedCount: true,
-      toolDescription:
-        "Return randomly selected complete modifier families (with value lists) as exemplars. Use BEFORE writing queries to see actual data shapes.",
-    },
-  },
-};

package/src/capabilities/standard/index.ts

@@ -1,18 +0,0 @@
-/**
- * The `standard` capability module — the bundled pack compiled to verbs.
- *
- * Compiled at import (fast-path safe: compilePack is pure/zod-free) so the module
- * is surface-deterministic. A config/package story for `standard` overrides it at
- * dispatch (see kernel/packs/collect).
- */
-
-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 { standardPack } from "./pack.js";
-
-/** The `standard` capability module (list, categories, lookup, sample). */
-export const standardModule: CapabilityModule = {
-  name: "standard",
-  verbs: compilePack(standardPack, "bundled:standard", DEFAULT_PREFIX_MAP),
-};