@canonical/pragma-cli 0.31.0 → 0.33.0

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/graph/defaultPack.ts

@@ -0,0 +1,178 @@
+/**
+ * The hermetic, vendored "default-pack" fixture — a SMALL but REAL multi-typed
+ * design-system pack, shaped the way a shipped default pack actually is, not the
+ * way the 6-entity single-typed canonical graph was.
+ *
+ * WHY A SECOND GRAPH (the R1 "one graph" discipline notwithstanding): the
+ * canonical fixture (`canonical.ts`) is deliberately clean — every individual is
+ * single-typed (`a ds:Component`), every block carries a tier, every label is a
+ * bare string. That cleanliness is exactly what masked the real-data counter and
+ * classifier bugs the journey harness (AV-231, Backlog E) exists to catch. This
+ * fixture is the ADVERSARIAL default pack: it reproduces the four shapes a real
+ * vendored pack has that the clean graph does not —
+ *
+ *  1. `owl:NamedIndividual` co-typing — every block is
+ *     `a owl:NamedIndividual, ds:<Class>`, the way exported OWL individuals are.
+ *     This is what doubles the per-type instance tally (A1 `entityTotal` 2×): a
+ *     block counts once under `owl:NamedIndividual` AND once under its domain
+ *     class.
+ *  2. Two+ domain classes (`ds:Component` and `ds:Pattern`) so a read that keys
+ *     off the primary domain type is exercised across more than one class.
+ *  3. An UNTIERED block (`ds:orphanWidget` — a `ds:Component` with a `ds:name`
+ *     but NO `ds:tier`). `block list`'s SELECT inner-joins `?c ds:tier ?t`, so an
+ *     untiered block is silently dropped from every listing (A2), even though
+ *     `graph query` finds it — the fixture pins both halves of that divergence.
+ *  4. A multilingual `rdfs:label "Button"@en, "Bouton"@fr` — two same-predicate
+ *     labels whose winner in the single-valued index is store-order-arbitrary
+ *     (A7), a shape a bare-string fixture can never produce.
+ *
+ * The vocabulary is the live `ds:` design-system namespace (same as
+ * `blockGraph.ts`/`canonical.ts`), so `block list`, `ontology list/show`, and
+ * `graph query` all run against real terms — the hand-written `block list` verb
+ * hard-codes `ds:Component`/`ds:name`/`ds:tier`/`ds:release`.
+ *
+ * Stable anchors this fixture guarantees (pinned by the journey suite):
+ *  - Exactly 4 blocks in the graph: Button (`ds:Component`, global), Card
+ *    (`ds:Pattern`, global), Beta Badge (`ds:Component`, apps tier, beta
+ *    channel), Orphan Widget (`ds:Component`, UNTIERED).
+ *  - 5 TBox classes, 4 TBox properties, 2 tiers (`global`, `apps`), 2 release
+ *    channels (`stable`, `beta`).
+ *  - `ds:button` carries the multilingual label; every other subject is a bare
+ *    string, so the multilingual path is isolated to one entity.
+ */
+
+/** The prefixes the default-pack fixture store is built and queried with. */
+export const DEFAULT_PACK_PREFIXES: Readonly<Record<string, string>> = {
+  ds: "https://ds.canonical.com/",
+  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 vendored default pack as one Turtle document: TBox (5 classes, 4
+ * properties) + ABox (2 tiers, 2 channels, 4 blocks). Every block is co-typed
+ * `owl:NamedIndividual` — the real-export shape the clean canonical graph omits.
+ */
+export const DEFAULT_PACK_TTL = `
+@prefix ds: <https://ds.canonical.com/> .
+@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#> .
+
+# ---- Ontology (TBox): 5 classes, 4 properties ----
+ds:UIBlock a owl:Class ; rdfs:label "UI Block" .
+ds:Component a owl:Class ; rdfs:subClassOf ds:UIBlock ; rdfs:label "Component" .
+ds:Pattern a owl:Class ; rdfs:subClassOf ds:UIBlock ; rdfs:label "Pattern" .
+ds:Tier a owl:Class ; rdfs:label "Tier" .
+ds:ReleaseChannel a owl:Class ; rdfs:label "Release Channel" .
+
+ds:name a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
+# Functional (one tier per block), matching the live ontology — a non-functional
+# ds:tier compiles to a multi-valued GraphQL field the bundled block lookup rejects.
+ds:tier a owl:ObjectProperty, owl:FunctionalProperty ; rdfs:domain ds:UIBlock ; rdfs:range ds:Tier .
+ds:release a owl:ObjectProperty, owl:FunctionalProperty ; rdfs:domain ds:UIBlock ; rdfs:range ds:ReleaseChannel .
+ds:summary a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
+
+# ---- Tiers (a real parent chain: apps -> global) ----
+ds:global a ds:Tier ; ds:name "global" .
+ds:apps a ds:Tier ; ds:name "apps" .
+
+# ---- Release channels ----
+ds:stable a ds:ReleaseChannel ; ds:name "stable" .
+ds:beta a ds:ReleaseChannel ; ds:name "beta" .
+
+# ---- Blocks (ABox) — every one co-typed owl:NamedIndividual (the export shape) ----
+
+# A component on the global tier, carrying a MULTILINGUAL label (A7 shape).
+ds:button a owl:NamedIndividual, ds:Component ;
+  ds:name "Button" ;
+  rdfs:label "Button"@en, "Bouton"@fr ;
+  ds:tier ds:global ;
+  ds:summary "A clickable button control." .
+
+# A second DOMAIN CLASS (ds:Pattern), on the global tier.
+ds:card a owl:NamedIndividual, ds:Pattern ;
+  ds:name "Card" ;
+  rdfs:label "Card" ;
+  ds:tier ds:global ;
+  ds:summary "A content card layout pattern." .
+
+# A component gated to the BETA channel and the non-global apps tier — exercises
+# both channel visibility and tier-chain inheritance.
+ds:betaBadge a owl:NamedIndividual, ds:Component ;
+  ds:name "Beta Badge" ;
+  rdfs:label "Beta Badge" ;
+  ds:tier ds:apps ;
+  ds:release ds:beta ;
+  ds:summary "An experimental badge, gated to the prerelease channel." .
+
+# An UNTIERED component — a real ds:Component with a ds:name but NO ds:tier.
+# It IS in the graph (graph query finds it) but block list's mandatory
+# tier join (?c ds:tier ?t) drops it (A2).
+ds:orphanWidget a owl:NamedIndividual, ds:Component ;
+  ds:name "Orphan Widget" ;
+  rdfs:label "Orphan Widget" ;
+  ds:summary "A component shipped without a tier assignment." .
+`;
+
+/** No-tier viewing config, `normal` channel — hides the beta-only Beta Badge. */
+export const DEFAULT_PACK_CONFIG = { channel: "normal" as const };
+
+/** `prerelease` channel, no tier — the config where every channel-gated block shows. */
+export const DEFAULT_PACK_ALL_VISIBLE_CONFIG = {
+  channel: "prerelease" as const,
+};
+
+/** The names of the 4 blocks the fixture declares, sorted (SPARQL `ORDER BY ?name`). */
+export const DEFAULT_PACK_BLOCK_NAMES = [
+  "Beta Badge",
+  "Button",
+  "Card",
+  "Orphan Widget",
+] as const;
+
+/** The block excluded from `block list` for want of a `ds:tier` (A2 anchor). */
+export const UNTIERED_BLOCK_NAME = "Orphan Widget";
+
+/**
+ * A second, ontology-only pack with NO tiered blocks — drives the EMPTY
+ * `block list` (a calm exit-0 empty result, not an error). It still declares the
+ * `ds:` TBox, so `ontology list` is POPULATED here (the populated/empty pair for
+ * the two list verbs is split across this and {@link INSTANCE_ONLY_TTL}).
+ */
+export const NO_BLOCKS_TTL = `
+@prefix ds: <https://ds.canonical.com/> .
+@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#> .
+
+ds:UIBlock a owl:Class .
+ds:Component a owl:Class ; rdfs:subClassOf ds:UIBlock .
+ds:Tier a owl:Class .
+ds:name a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
+ds:tier a owl:ObjectProperty ; rdfs:domain ds:UIBlock ; rdfs:range ds:Tier .
+
+ds:global a ds:Tier ; ds:name "global" .
+`;
+
+/**
+ * A pack of pure instance data with NO `owl:Class`/`owl:*Property` declarations —
+ * drives the EMPTY `ontology list` (no namespace has any classes or properties
+ * to group), while `graph query` still resolves its triples.
+ */
+export const INSTANCE_ONLY_TTL = `
+@prefix ex: <https://ex.test/#> .
+ex:alpha ex:relatesTo ex:beta .
+ex:beta ex:name "Beta" .
+`;
+
+/**
+ * A malformed Turtle source — a subject/predicate with no object — drives the
+ * `sources update` data-error classification path (a NAMED `CONFIG_ERROR`, not
+ * an INTERNAL "please report this issue").
+ */
+export const MALFORMED_TTL = `@prefix ex: <https://ex.test/#> .
+ex:One a ex:Widget .
+ex:Two ex:danglingPredicate .
+`;

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

@@ -0,0 +1,95 @@
+/**
+ * A realistic multi-typed OWL / Protégé-export fixture graph.
+ *
+ * The embedded `sample.ttl` (Button/Card/Dialog, each typed by exactly ONE
+ * domain class, every block tiered, every label untagged) is a TOY: it never
+ * exercises the counters/classifiers the way a real vocabulary does. This graph
+ * deliberately carries the shapes that only bite real packs (audit backlog A):
+ *
+ * - Protégé DUAL-typing: an individual asserted as its domain class AND
+ *   `owl:NamedIndividual` — the multiset that made `entityTotal` run ~2× (A1).
+ * - A MULTI-DOMAIN individual (`ex:toggle`: two domain classes) — so the
+ *   primary-type tie-break must be deterministic, not store-order (A3).
+ * - An UNTIERED block (`ds:datePicker`: a `ds:Component` with no `ds:tier`) —
+ *   which `block list --all-tiers` must surface, not hide (A2).
+ * - A blank-node `rdf:type` (`ex:field`'s anonymous SHACL-style class) — which
+ *   must NOT become a `type:"_:b0"` primary key (A6).
+ * - An OWL-PUNNED subject (`ex:Slider`: a class that is ALSO a metaclass
+ *   individual) — whose abox facet must survive alongside its tbox one (A8).
+ * - MULTILINGUAL labels (`"Button"@en` / `"Bouton"@fr`) — resolved to a stable
+ *   language, never whichever row the store returned first (A7).
+ *
+ * The `ds:` half is a compact but faithful design-system slice (so `block list`
+ * runs against it); the `ex:` half is generic OWL, proving the index is
+ * ontology-agnostic. One document, so a single store answers every read.
+ */
+
+/** The prefixes the OWL-export fixture store is built and queried with. */
+export const OWL_EXPORT_PREFIXES: Readonly<Record<string, string>> = {
+  ds: "https://ds.canonical.com/",
+  ex: "https://ex.test/vocab#",
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#",
+  owl: "http://www.w3.org/2002/07/owl#",
+  xsd: "http://www.w3.org/2001/XMLSchema#",
+};
+
+/** The multi-typed OWL-export fixture ontology + individuals as Turtle. */
+export const OWL_EXPORT_TTL = `
+@prefix ds:   <https://ds.canonical.com/> .
+@prefix ex:   <https://ex.test/vocab#> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix owl:  <http://www.w3.org/2002/07/owl#> .
+@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
+
+# ---- Design-system TBox (so \`block list\` has real block types) ----
+ds:UIBlock a owl:Class .
+ds:Component a owl:Class ; rdfs:subClassOf ds:UIBlock ; rdfs:label "Component" .
+ds:Tier a owl:Class .
+ds:name a owl:DatatypeProperty ; rdfs:domain ds:UIBlock ; rdfs:range xsd:string .
+ds:tier a owl:ObjectProperty ; rdfs:domain ds:UIBlock ; rdfs:range ds:Tier .
+ds:global a owl:NamedIndividual, ds:Tier ; ds:name "global" .
+
+# ---- Generic OWL domain classes (multi-typing lives here) ----
+ex:Interactive a owl:Class ; rdfs:label "Interactive" .
+ex:FormControl a owl:Class ; rdfs:label "Form Control" .
+ex:Category a owl:Class ; rdfs:label "Category" .
+
+# ---- A tiered block, Protégé-style DUAL-typed (domain class + owl:NamedIndividual),
+#      with a multilingual label (A1 + A7). ----
+ds:button a owl:NamedIndividual, ds:Component ;
+  ds:name "Button" ;
+  ds:tier ds:global ;
+  rdfs:label "Button"@en , "Bouton"@fr .
+
+# ---- An UNTIERED block: a ds:Component with NO ds:tier (A2). ----
+ds:datePicker a owl:NamedIndividual, ds:Component ;
+  ds:name "Date Picker" ;
+  rdfs:label "Date Picker"@en , "Sélecteur de date"@fr .
+
+# ---- A MULTI-DOMAIN individual: two domain classes + owl:NamedIndividual (A1 + A3).
+#      The abox primary must be the lexically-smallest: ex:FormControl < ex:Interactive. ----
+ex:toggle a owl:NamedIndividual, ex:Interactive, ex:FormControl ;
+  rdfs:label "Toggle"@en , "Bascule"@fr .
+
+# ---- An OWL-PUNNED subject: a class that is ALSO a metaclass individual (A8).
+#      Must emit BOTH a tbox facet (owl:Class) and an abox facet (ex:Category). ----
+ex:Slider a owl:Class, owl:NamedIndividual, ex:Category ;
+  rdfs:label "Slider" .
+
+# ---- A subject with a BLANK-NODE rdf:type: an anonymous class (A6).
+#      The blank node must NOT become ex:field's primary type. ----
+ex:field a owl:NamedIndividual, ex:FormControl, [ a owl:Class ] ;
+  rdfs:label "Field" .
+`;
+
+/** The distinct abox individuals this fixture declares (the `entityTotal` oracle). */
+export const OWL_EXPORT_ABOX_SUBJECTS: readonly string[] = [
+  "ds:button",
+  "ds:datePicker",
+  "ds:global",
+  "ex:Slider",
+  "ex:field",
+  "ex:toggle",
+];

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",
+      },
+    ],
+  },
+};

package/src/testing/helpers/extractSnippets.ts

@@ -0,0 +1,29 @@
+/**
+ * Pull the runnable `pragma` command lines out of a Markdown document.
+ *
+ * Scans fenced `bash` / `sh` / `console` blocks, strips a leading shell prompt
+ * (`$ `), and keeps the lines that invoke `pragma`. Used by the doc-example
+ * tests to prove every command shown in the docs is real grammar and — for the
+ * curated read set — actually runs.
+ */
+
+/** Fenced `bash`/`sh`/`console` blocks, capturing the body between the fences. */
+const FENCE_RE = /```(?:bash|sh|console)\r?\n(?<body>[\s\S]*?)```/g;
+
+/**
+ * Extract every `pragma …` command line from a Markdown string.
+ *
+ * @param markdown - The Markdown source to scan.
+ * @returns The `pragma` command lines, in document order, prompt-stripped.
+ */
+export function extractPragmaCommands(markdown: string): string[] {
+  const commands: string[] = [];
+  for (const match of markdown.matchAll(FENCE_RE)) {
+    const body = match.groups?.body ?? "";
+    for (const rawLine of body.split("\n")) {
+      const line = rawLine.replace(/^\s*\$\s+/, "").trim();
+      if (line.startsWith("pragma ")) commands.push(line);
+    }
+  }
+  return commands;
+}