@canonical/pragma-cli 0.30.0 → 0.32.0

package/src/testing/fixtures/completionFixture.ts

@@ -0,0 +1,239 @@
+/**
+ * A synthetic capability module exercising every completion path (D8 —
+ * test-only, never listed in `src/capabilities/index.ts`): an entity
+ * positional, an enum positional, enum/files/boolean/none flags, a variadic
+ * `string[]` positional, a repeatable `string[]` flag, a mutating verb, a
+ * self-verb-only noun, a mixed self-verb + sub-verb noun, and a hidden verb.
+ *
+ * Snapshots and the protected parse/resolve tests pin against THIS module,
+ * not the live capabilities, so live noun renames never churn them.
+ */
+
+import { succeed } from "@canonical/task";
+import type { CompletionEnv } from "../../kernel/completion/types.js";
+import type {
+  CapabilityModule,
+  Formatters,
+  VerbSpec,
+} from "../../kernel/spec/types.js";
+
+const passthrough: Formatters<unknown> = {
+  plain: (d) => String(d),
+  llm: (d) => String(d),
+  json: (d) => JSON.stringify(d),
+};
+
+const read = {
+  needsStore: false,
+  mutates: false,
+  mcp: { expose: false, reason: "completion test fixture" },
+} as const;
+
+/** `block get <ref>` — entity positional; enum, files, boolean, none flags. */
+const blockGet: VerbSpec = {
+  path: ["block", "get"],
+  summary: "Get a block.",
+  params: [
+    {
+      kind: "string",
+      name: "ref",
+      doc: "The block to get.",
+      positional: true,
+      required: true,
+      complete: { kind: "names", source: { from: "index", type: "ds:Block" } },
+    },
+    {
+      kind: "enum",
+      name: "view",
+      doc: "Which projection to show.",
+      values: ["anatomy", "full", "summary"],
+    },
+    {
+      kind: "string",
+      name: "out",
+      doc: "Write the result to a file.",
+      complete: { kind: "files" },
+    },
+    { kind: "boolean", name: "withMeta", doc: "Include metadata." },
+    { kind: "string", name: "note", doc: "Free-text note (not completable)." },
+  ],
+  output: { formatters: passthrough },
+  capability: read,
+  run: async () => "ok",
+};
+
+/** `block list [tier]` — enum positional (declared) + repeatable tags flag. */
+const blockList: VerbSpec = {
+  path: ["block", "list"],
+  summary: "List blocks.",
+  params: [
+    {
+      kind: "enum",
+      name: "tier",
+      doc: "Restrict to a tier.",
+      values: ["community", "core"],
+      positional: true,
+      complete: { kind: "values" },
+    },
+    { kind: "string[]", name: "tags", doc: "Filter by tags." },
+  ],
+  output: { formatters: passthrough },
+  capability: read,
+  run: async () => "ok",
+};
+
+/** `block diff <refs...>` — variadic entity positional. */
+const blockDiff: VerbSpec = {
+  path: ["block", "diff"],
+  summary: "Diff blocks.",
+  params: [
+    {
+      kind: "string[]",
+      name: "refs",
+      doc: "The blocks to diff.",
+      positional: true,
+      required: true,
+      complete: { kind: "names", source: { from: "index", type: "ds:Block" } },
+    },
+  ],
+  output: { formatters: passthrough },
+  capability: read,
+  run: async () => "ok",
+};
+
+/** `block remove <ref>` — mutates (mutation flags), completion opted out. */
+const blockRemove: VerbSpec = {
+  path: ["block", "remove"],
+  summary: "Remove a block.",
+  params: [
+    {
+      kind: "string",
+      name: "ref",
+      doc: "The block to remove.",
+      positional: true,
+      required: true,
+      complete: { kind: "none" },
+    },
+  ],
+  output: { formatters: passthrough },
+  capability: {
+    needsStore: true,
+    mutates: true,
+    destructive: true,
+    mcp: { expose: false, reason: "completion test fixture" },
+  },
+  run: () => succeed({ removed: true }),
+};
+
+/** `block probe` — hidden; must never appear in completions. */
+const blockProbe: VerbSpec = {
+  path: ["block", "probe"],
+  summary: "Internal probe.",
+  hidden: true,
+  params: [],
+  output: { formatters: passthrough },
+  capability: read,
+  run: async () => "ok",
+};
+
+/** `standard [query]` — self-verb on a noun that ALSO has a sub-verb. */
+const standardSelf: VerbSpec = {
+  path: ["standard"],
+  summary: "Look up a standard.",
+  params: [
+    {
+      kind: "string",
+      name: "query",
+      doc: "The standard to look up.",
+      positional: true,
+      complete: {
+        kind: "names",
+        source: { from: "index", type: "ds:Standard" },
+      },
+    },
+  ],
+  output: { formatters: passthrough },
+  capability: read,
+  run: async () => "ok",
+};
+
+/** `standard list` — the sub-verb beside the self-verb. */
+const standardList: VerbSpec = {
+  path: ["standard", "list"],
+  summary: "List standards.",
+  params: [],
+  output: { formatters: passthrough },
+  capability: read,
+  run: async () => "ok",
+};
+
+/** `status [scope]` — a self-verb-only noun with an enum positional. */
+const statusSelf: VerbSpec = {
+  path: ["status"],
+  summary: "Show status.",
+  params: [
+    {
+      kind: "enum",
+      name: "scope",
+      doc: "Which scope to report.",
+      values: ["all", "dirty"],
+      positional: true,
+    },
+  ],
+  output: { formatters: passthrough },
+  capability: read,
+  run: async () => "ok",
+};
+
+/** The synthetic completion module (D8 — test-only). */
+export const completionFixture: CapabilityModule = {
+  name: "completion-fixture",
+  verbs: [
+    blockGet,
+    blockList,
+    blockDiff,
+    blockRemove,
+    blockProbe,
+    standardSelf,
+    standardList,
+    statusSelf,
+  ],
+};
+
+/**
+ * A compact per-type name table backing {@link fixtureNameEnv} — the hand-built
+ * stand-in the resolver's RANKING tests (resolve/complete) drive, NOT the
+ * on-disk `PackIndex` (a flat `entities[{name,type}]` array). The real index
+ * shape ⟷ reader agreement is proven live, against a freshly built index, by
+ * `kernel/runtime/graphpack/completionSeam.test.ts`.
+ */
+export const fixtureIndex = {
+  version: 1,
+  entities: {
+    "ds:Block": {
+      names: [
+        "button",
+        "button-group",
+        "card",
+        "chip",
+        "navigation",
+        "tooltip",
+      ],
+    },
+    "ds:Standard": { names: ["accessibility", "naming"] },
+  },
+} as const;
+
+/**
+ * A completion env serving {@link fixtureIndex} by the source ref's `type`
+ * (the `from:"index"` stand-in the ranking tests drive).
+ */
+export const fixtureNameEnv: CompletionEnv = {
+  names: (ref): readonly string[] =>
+    (
+      fixtureIndex.entities as Record<
+        string,
+        { names: readonly string[] } | undefined
+      >
+    )[ref.type ?? ""]?.names ?? [],
+};

package/src/testing/fixtures/fixtureCapability.ts

@@ -0,0 +1,175 @@
+/**
+ * A synthetic capability module used only by tests (D8 — never listed in
+ * `src/capabilities/index.ts`). It exercises every emit path: a read verb, a
+ * mutating verb with a positional + a camelCase flag, and a hidden verb the
+ * emitter must drop.
+ */
+
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { $, gen, succeed, writeFile } from "@canonical/task";
+import type { CapabilityModule } from "../../kernel/spec/types.js";
+
+/** A synthetic module: noun `widget`, three verbs (one hidden). */
+export const fixtureModule: CapabilityModule = {
+  name: "fixture",
+  verbs: [
+    {
+      path: ["widget", "list"],
+      summary: "List widgets.",
+      params: [],
+      output: {
+        formatters: {
+          plain: (d) => String(d),
+          llm: (d) => String(d),
+          json: (d) => JSON.stringify(d),
+        },
+      },
+      capability: {
+        needsStore: false,
+        mutates: false,
+        mcp: {
+          expose: true,
+          annotations: { readOnlyHint: true, openWorldHint: false },
+        },
+      },
+      run: async () => ["alpha", "beta"],
+    },
+    {
+      path: ["widget", "make"],
+      summary: "Make a widget.",
+      params: [
+        {
+          kind: "string",
+          name: "name",
+          doc: "Widget name.",
+          positional: true,
+          required: true,
+        },
+        { kind: "boolean", name: "withHistory", doc: "Seed history." },
+      ],
+      output: {
+        formatters: {
+          plain: (d) => String(d),
+          llm: (d) => String(d),
+          json: (d) => JSON.stringify(d),
+        },
+      },
+      capability: {
+        needsStore: true,
+        mutates: true,
+        destructive: true,
+        mcp: {
+          expose: true,
+          annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: false,
+          },
+        },
+      },
+      run: () => succeed({ made: true }),
+    },
+    {
+      path: ["widget", "internal"],
+      summary: "Internal probe.",
+      hidden: true,
+      params: [],
+      output: {
+        formatters: {
+          plain: (d) => String(d),
+          llm: (d) => String(d),
+          json: (d) => JSON.stringify(d),
+        },
+      },
+      capability: {
+        needsStore: false,
+        mutates: false,
+        mcp: { expose: false, reason: "internal probe, not an agent tool" },
+      },
+      run: async () => "ok",
+    },
+  ],
+};
+
+/**
+ * The isolated tmp path the fixture `touch` verb writes to. Rooted under
+ * `$XDG_STATE_HOME` so the XDG isolation setup contains it per test run.
+ *
+ * @param name - The file name to create.
+ * @returns The absolute path under the isolated state directory.
+ */
+export function touchPath(name: string): string {
+  const base = process.env.XDG_STATE_HOME ?? tmpdir();
+  return join(base, "pragma-touch", name);
+}
+
+const passthroughFormatters = {
+  plain: (d: unknown) => String(d),
+  llm: (d: unknown) => String(d),
+  json: (d: unknown) => JSON.stringify(d),
+};
+
+/**
+ * A second synthetic module exercising the effect seam end-to-end: a read verb
+ * (`probe echo`) that returns its input, and a mutating Task verb (`probe
+ * touch`) that writes a file under the isolated tmp. Used by the CLI/MCP
+ * projector tests for envelope parity and MCP plan-first/confirm. Test-only
+ * (D8) — never listed in `capabilities/index.ts`.
+ */
+export const fixtureEffectsModule: CapabilityModule = {
+  name: "fixture-effects",
+  verbs: [
+    {
+      path: ["probe", "echo"],
+      summary: "Echo the message back.",
+      params: [
+        {
+          kind: "string",
+          name: "message",
+          doc: "The message to echo.",
+          positional: true,
+          required: true,
+        },
+      ],
+      output: { formatters: passthroughFormatters },
+      capability: {
+        needsStore: false,
+        mutates: false,
+        mcp: {
+          expose: true,
+          annotations: { readOnlyHint: true, openWorldHint: false },
+        },
+      },
+      run: async (p) => ({ echoed: (p as { message: string }).message }),
+    },
+    {
+      path: ["probe", "touch"],
+      summary: "Create a file under the isolated tmp.",
+      params: [
+        {
+          kind: "string",
+          name: "name",
+          doc: "File name to create.",
+          positional: true,
+          required: true,
+        },
+      ],
+      output: { formatters: passthroughFormatters },
+      capability: {
+        needsStore: false,
+        mutates: true,
+        mcp: {
+          expose: true,
+          annotations: { readOnlyHint: false, openWorldHint: false },
+        },
+      },
+      run: (p) =>
+        gen(function* () {
+          const name = (p as { name: string }).name;
+          yield* $(writeFile(touchPath(name), "touched\n"));
+          return { touched: name };
+        }),
+    },
+  ],
+};

package/src/testing/fixtures/graph/canonical.ts

@@ -0,0 +1,184 @@
+/**
+ * The ONE shared content graph for cross-cutting behavioral tests.
+ *
+ * R1 discipline: this does NOT fork a second graph. It IMPORTS PR3's
+ * Button/Modal fixture (`testing/fixtures/blockGraph.ts` — the graph PR3's own
+ * `block` content-parity + `ontology`/`graph inspect` tests are protected
+ * against) byte-for-byte and EXTENDS it with the entities the other bundled
+ * read nouns (`standard`, `modifier`, `token`, `tier`) need, plus two more
+ * blocks that exercise tier-chain inheritance and channel visibility (PR3's
+ * hand-written `block list`, Risk5). Because `BLOCK_TTL` is reused verbatim,
+ * Button/Modal content can never drift between PR3's fixture and this one.
+ *
+ * Composed as one Turtle document, so ONE store answers every read noun:
+ * `block`/`ontology`/`graph inspect` were already provable on `BLOCK_TTL`
+ * alone; `standard`/`modifier`/`token`/`tier` need the sections added below.
+ * `modifier` in particular needs NOTHING extra — its list/lookup query the
+ * exact `ds:ModifierFamily`/`ds:Modifier` individuals `BLOCK_TTL` already
+ * declares for Button/Modal's expand sections.
+ *
+ * Anchors this fixture guarantees stay stable (referenced by B-tier tests and
+ * the eval seed, per the plan's R2 discipline — noun/verb/tool SETS are read
+ * from `emitSurface(capabilities)` at test time, but these entity VALUES are
+ * ours to pin): 4 `ds:Component` (Button, Modal, LXD Panel, Beta Widget),
+ * `importance` family with value `primary`, code standard
+ * `code/function/purity`.
+ */
+
+import { BLOCK_PREFIXES, BLOCK_TTL } from "../blockGraph.js";
+
+/** Extra `ds:` individuals: a tier-chain + a beta-only block, tokens, tiers. */
+const DS_EXTRA_TTL = `
+# ---- Tiers beyond the global BLOCK_TTL already declares ----
+ds:apps a ds:Tier ; ds:name "apps" .
+ds:apps_lxd a ds:Tier ; ds:name "apps/lxd" .
+
+# ---- Release channels ----
+ds:ReleaseChannel a owl:Class .
+ds:release a owl:ObjectProperty ; rdfs:domain ds:UIBlock ; rdfs:range ds:ReleaseChannel .
+ds:stable a ds:ReleaseChannel ; ds:name "stable" .
+ds:beta a ds:ReleaseChannel ; ds:name "beta" .
+
+# ---- A third block, scoped to the apps/lxd tier (tier-chain inheritance) ----
+ds:lxdPanel a ds:Component ;
+  ds:name "LXD Panel" ;
+  ds:tier ds:apps_lxd ;
+  ds:summary "Panel layout for the LXD application." .
+
+# ---- A fourth block, visible only on the prerelease channel ----
+ds:betaWidget a ds:Component ;
+  ds:name "Beta Widget" ;
+  ds:tier ds:global ;
+  ds:release ds:beta ;
+  ds:summary "An experimental widget gated to the prerelease channel." .
+
+# ---- Tokens ----
+ds:Token a owl:Class .
+ds:TokenType a owl:Class .
+ds:tokenId a owl:DatatypeProperty ; rdfs:domain ds:Token ; rdfs:range xsd:string .
+ds:tokenType a owl:ObjectProperty ; rdfs:domain ds:Token ; rdfs:range ds:TokenType .
+ds:valueLight a owl:DatatypeProperty ; rdfs:domain ds:Token ; rdfs:range xsd:string .
+ds:valueDark a owl:DatatypeProperty ; rdfs:domain ds:Token ; rdfs:range xsd:string .
+
+ds:type.color a ds:TokenType ; rdfs:label "color" .
+ds:type.spacing a ds:TokenType ; rdfs:label "spacing" .
+
+ds:token.color.primary a ds:Token ;
+  ds:tokenId "color.primary" ;
+  ds:tokenType ds:type.color ;
+  ds:valueLight "#0066CC" ;
+  ds:valueDark "#4D94FF" .
+ds:token.spacing.medium a ds:Token ;
+  ds:tokenId "spacing.medium" ;
+  ds:tokenType ds:type.spacing ;
+  ds:valueLight "16px" ;
+  ds:valueDark "16px" .
+`;
+
+/** The `cs:` (code standards) section — reused verbatim from `standard/parity.test.ts`'s
+ * fixture shape so `code/function/purity`/`react/component/*` are stable, shared
+ * anchor names rather than a second invented set. */
+const CS_TTL = `
+@prefix cs: <http://pragma.canonical.com/codestandards#> .
+
+cs:CodeStandard a owl:Class .
+cs:Category a owl:Class .
+cs:Example a owl:Class .
+cs:name a owl:DatatypeProperty ; rdfs:domain cs:CodeStandard ; rdfs:range xsd:string .
+cs:description a owl:DatatypeProperty ; rdfs:range xsd:string .
+cs:hasCategory a owl:ObjectProperty ; rdfs:domain cs:CodeStandard ; rdfs:range cs:Category .
+cs:slug a owl:DatatypeProperty ; rdfs:domain cs:Category ; rdfs:range xsd:string .
+cs:extends a owl:ObjectProperty ; rdfs:domain cs:CodeStandard ; rdfs:range cs:CodeStandard .
+cs:do a owl:ObjectProperty ; rdfs:domain cs:CodeStandard ; rdfs:range cs:Example .
+cs:dont a owl:ObjectProperty ; rdfs:domain cs:CodeStandard ; rdfs:range cs:Example .
+cs:language a owl:DatatypeProperty ; rdfs:domain cs:Example ; rdfs:range xsd:string .
+cs:code a owl:DatatypeProperty ; rdfs:domain cs:Example ; rdfs:range xsd:string .
+
+cs:cat.react a cs:Category ; cs:slug "react" .
+cs:cat.code a cs:Category ; cs:slug "code" .
+
+cs:react.component.props a cs:CodeStandard ;
+  cs:name "react/component/props" ;
+  cs:description "Type component props explicitly." ;
+  cs:hasCategory cs:cat.react ;
+  cs:do [ a cs:Example ; cs:description "Do type props" ; cs:language "tsx" ; cs:code "interface P {}" ] ;
+  cs:dont [ a cs:Example ; cs:description "Avoid any" ; cs:language "tsx" ; cs:code "props: any" ] .
+
+cs:react.component.structure a cs:CodeStandard ;
+  cs:name "react/component/structure" ;
+  cs:description "Keep folder structure flat." ;
+  cs:hasCategory cs:cat.react ;
+  cs:extends cs:react.component.props ;
+  cs:do [ a cs:Example ; cs:description "Do flatten" ; cs:language "text" ; cs:code "src/Button.tsx" ] .
+
+cs:code.function.purity a cs:CodeStandard ;
+  cs:name "code/function/purity" ;
+  cs:description "Prefer pure functions." ;
+  cs:hasCategory cs:cat.code .
+`;
+
+/** The `ds:Prompt` workflow templates — the ONE source both the `prompt_list`/
+ * `prompt_lookup` content tools and the native MCP `prompts/*` surface project.
+ * Adapted from the old shell's `DECISION_TREES`. `rdfs:label` is the prompt name
+ * (indexed → storeless native list); `ds:promptBody` + `ds:promptArgument`
+ * blank nodes are store-backed. Arguments are untyped blank nodes so they never
+ * enter the entity index (the same shape `cs:do`/`cs:dont` examples use). */
+const PROMPT_TTL = `
+ds:Prompt a owl:Class .
+ds:promptBody a owl:DatatypeProperty ; rdfs:domain ds:Prompt ; rdfs:range xsd:string .
+ds:promptArgument a owl:ObjectProperty ; rdfs:domain ds:Prompt .
+ds:argName a owl:DatatypeProperty ; rdfs:range xsd:string .
+ds:argRequired a owl:DatatypeProperty ; rdfs:range xsd:boolean .
+
+ds:prompt.build-a-block a ds:Prompt ;
+  rdfs:label "build-a-block" ;
+  rdfs:comment "Scaffold and wire a design-system block end to end." ;
+  ds:promptBody "You are building the {{blockName}} block. 1) If unfamiliar with block data, call block_sample for real shapes. 2) block_list to browse, or block_lookup {{blockName}} --detail detailed for anatomy, modifiers, and properties. 3) Follow the relevant standards via standard_lookup." ;
+  ds:promptArgument [ ds:argName "blockName" ; rdfs:comment "The block to build (e.g. Button)." ; ds:argRequired false ] .
+
+ds:prompt.audit-standards a ds:Prompt ;
+  rdfs:label "audit-standards" ;
+  rdfs:comment "Audit code against the design system's coding standards." ;
+  ds:promptBody "Audit code against the {{category}} standards. 1) standard_categories to see categories. 2) standard_list --category {{category}}. 3) standard_lookup <name> --detail detailed for do/don't examples, then reconcile the code." ;
+  ds:promptArgument [ ds:argName "category" ; rdfs:comment "Standard category slug (e.g. react)." ; ds:argRequired false ] .
+
+ds:prompt.explore-design-system a ds:Prompt ;
+  rdfs:label "explore-design-system" ;
+  rdfs:comment "Orient in an unfamiliar design system before querying." ;
+  ds:promptBody "Explore the design system. 1) capabilities for the tool map. 2) block_sample / modifier_sample for real data shapes. 3) ontology_list then ontology_show <ns> for the schema. 4) tier_list for the tier hierarchy. 5) graph_query for raw SPARQL joins." .
+
+ds:prompt.configure a ds:Prompt ;
+  rdfs:label "configure" ;
+  rdfs:comment "Set the active tier and release channel scope." ;
+  ds:promptBody "Configure pragma's scope. Set the tier with config_tier {{tier}}, the channel with config_channel {{channel}} (normal|experimental|prerelease), then confirm with config_show." ;
+  ds:promptArgument [ ds:argName "tier" ; rdfs:comment "Tier path (e.g. apps/lxd)." ; ds:argRequired false ] ;
+  ds:promptArgument [ ds:argName "channel" ; rdfs:comment "Release channel." ; ds:argRequired false ] .
+
+ds:prompt.scaffold-component a ds:Prompt ;
+  rdfs:label "scaffold-component" ;
+  rdfs:comment "Scaffold a new component and align it to the standards." ;
+  ds:promptBody "Scaffold the {{componentName}} component in {{framework}}. Use create_component with the component path and --framework {{framework}}, then review the generated files against the react/component standards via standard_lookup." ;
+  ds:promptArgument [ ds:argName "componentName" ; rdfs:comment "Component name/path (e.g. Button)." ; ds:argRequired true ] ;
+  ds:promptArgument [ ds:argName "framework" ; rdfs:comment "react | svelte | lit." ; ds:argRequired false ] .
+`;
+
+/** The prefixes the canonical store is built and queried with. */
+export const CANONICAL_PREFIXES: Readonly<Record<string, string>> = {
+  ...BLOCK_PREFIXES,
+  cs: "http://pragma.canonical.com/codestandards#",
+};
+
+/** The full canonical Turtle: PR3's `BLOCK_TTL` verbatim, plus the sections above. */
+export const CANONICAL_TTL = `${BLOCK_TTL}\n${DS_EXTRA_TTL}\n${CS_TTL}\n${PROMPT_TTL}`;
+
+/** Default viewing config: no tier set, `normal` channel — drops the beta-only block. */
+export const CANONICAL_CONFIG = { channel: "normal" as const };
+
+/** Scoped to the `apps/lxd` tier — own + inherited (LXD Panel, Modal, Button). */
+export const FILTERED_CONFIG = { tier: "apps/lxd" as const };
+
+/** `prerelease` channel, no tier — the one config where all 4 components are listed. */
+export const ALL_VISIBLE_CONFIG = { channel: "prerelease" as const };
+
+/** Re-exported so callers needn't also import `blockGraph.ts` directly. */
+export { BLOCK_PREFIXES, BLOCK_TTL };

package/src/testing/fixtures/packs/recipe.ts

@@ -0,0 +1,78 @@
+/**
+ * A foreign-namespace generic-pack proof.
+ *
+ * Every other fixture graph in this package lives under the `ds:`/`cs:`
+ * design-system prefixes. This one is deliberately OUTSIDE that vocabulary —
+ * `ex:` recipes with no relation to design systems at all — proving the pack
+ * compiler and runtime are ontology-agnostic end-to-end: a pack over ANY
+ * RDF graph registers its verbs/tools and resolves through the same one
+ * compiler (`kernel/packs/compile.ts`) every bundled DS pack does. Complements
+ * PR3's compiler-invariant UNIT tests with an e2e journey (compile → boot →
+ * list/lookup on both the CLI and MCP surfaces).
+ */
+
+import type { PackDefinition } from "../../../kernel/packs/types.js";
+
+/** The prefixes the recipe fixture store is built and queried with. */
+export const RECIPE_PREFIXES: Readonly<Record<string, string>> = {
+  ex: "https://example.com/recipes#",
+  owl: "http://www.w3.org/2002/07/owl#",
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#",
+  xsd: "http://www.w3.org/2001/XMLSchema#",
+};
+
+/** The recipe fixture ontology + individuals as Turtle. */
+export const RECIPE_TTL = `
+@prefix ex: <https://example.com/recipes#> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+ex:Recipe a owl:Class .
+ex:title a owl:DatatypeProperty ; rdfs:domain ex:Recipe ; rdfs:range xsd:string .
+ex:cuisine a owl:DatatypeProperty ; rdfs:domain ex:Recipe ; rdfs:range xsd:string .
+ex:instructions a owl:DatatypeProperty ; rdfs:domain ex:Recipe ; rdfs:range xsd:string .
+
+ex:pancakes a ex:Recipe ;
+  ex:title "Pancakes" ;
+  ex:cuisine "breakfast" ;
+  ex:instructions "Whisk batter, pour onto a hot griddle, flip when bubbling." .
+
+ex:gazpacho a ex:Recipe ;
+  ex:title "Gazpacho" ;
+  ex:cuisine "spanish" ;
+  ex:instructions "Blend chilled tomatoes, peppers, and cucumber; chill again." .
+`;
+
+/** A declarative pack over the foreign `ex:` namespace — `list` + `lookup`. */
+export const recipePack: PackDefinition = {
+  noun: "recipe",
+  description: "List recipes.",
+  list: {
+    query: [
+      "SELECT ?uri ?name ?cuisine WHERE {",
+      "  ?uri a ex:Recipe ;",
+      "       ex:title ?name .",
+      "  OPTIONAL { ?uri ex:cuisine ?cuisine }",
+      "}",
+      "ORDER BY ?name",
+    ].join("\n"),
+    columns: [
+      { field: "uri", label: "IRI" },
+      { field: "name", label: "Name" },
+      { field: "cuisine", label: "Cuisine" },
+    ],
+  },
+  lookup: {
+    by: "ex:title",
+    type: "ex:Recipe",
+    fields: [{ name: "cuisine", property: "ex:cuisine", label: "Cuisine" }],
+    sections: [
+      {
+        name: "instructions",
+        property: "ex:instructions",
+        label: "Instructions",
+      },
+    ],
+  },
+};