@canonical/pragma-cli 0.30.0 → 0.32.0

package/src/kernel/runtime/facade.test.ts

@@ -0,0 +1,125 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  beforeAll,
+  describe,
+  expect,
+  it,
+  type Mock,
+  vi,
+} from "vitest";
+
+// Spy on the compiler entry points while keeping the real implementations, so
+// we can assert that BOOT rebuilds the schema from the extraction artifact
+// (compileFromExtraction) and NEVER runs the live 7-pass compile.
+vi.mock("@canonical/ke-graphql", async (importActual) => {
+  const actual = await importActual<typeof import("@canonical/ke-graphql")>();
+  return {
+    ...actual,
+    compile: vi.fn(actual.compile),
+    compileFromExtraction: vi.fn(actual.compileFromExtraction),
+  };
+});
+
+import { compile, compileFromExtraction } from "@canonical/ke-graphql";
+import { createQueryFacade } from "./facade.js";
+import { buildPack } from "./graphpack/build.js";
+import { readPack } from "./graphpack/read.js";
+import type { LazyStore } from "./types.js";
+
+const PREFIXES = {
+  ex: "https://pragma.canonical.com/sample#",
+  owl: "http://www.w3.org/2002/07/owl#",
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#",
+  xsd: "http://www.w3.org/2001/XMLSchema#",
+};
+const TTL = `
+@prefix ex:   <https://pragma.canonical.com/sample#> .
+@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#> .
+ex:Component a owl:Class ; rdfs:label "Component" .
+ex:Button a ex:Component ; rdfs:label "Button" .
+`;
+
+let savedCacheHome: string | undefined;
+let cacheHome: string;
+let dir: string;
+
+beforeAll(async () => {
+  savedCacheHome = process.env.XDG_CACHE_HOME;
+  cacheHome = mkdtempSync(join(tmpdir(), "pragma-facade-"));
+  process.env.XDG_CACHE_HOME = cacheHome;
+  // Building the pack is the ONE place the live compile runs.
+  const built = await buildPack([{ path: "a.ttl", content: TTL }], {
+    name: "facade-test",
+    version: "0.0.0",
+    sourceRef: "test:inline",
+    prefixes: PREFIXES,
+  });
+  dir = built.dir;
+  expect((compile as unknown as Mock).mock.calls.length).toBeGreaterThan(0);
+});
+
+afterAll(() => {
+  process.env.XDG_CACHE_HOME = savedCacheHome;
+  rmSync(cacheHome, { recursive: true, force: true });
+});
+
+describe("query facade round-trip (PROTECTED)", () => {
+  it("boots via compileFromExtraction and never calls the live compile", async () => {
+    (compile as unknown as Mock).mockClear();
+    (compileFromExtraction as unknown as Mock).mockClear();
+
+    // A minimal lazy store pointed straight at the built pack.
+    let booted = false;
+    const store: LazyStore = {
+      get booted() {
+        return booted;
+      },
+      async get() {
+        const session = await readPack(dir);
+        booted = true;
+        return session;
+      },
+      invalidate() {
+        booted = false;
+      },
+    };
+    const facade = createQueryFacade(store);
+
+    const result = await facade.graphql("{ __schema { queryType { name } } }");
+    expect(result.errors).toBeUndefined();
+    expect(result.data).toBeDefined();
+
+    // Boot rebuilt the schema from the artifact — the live compile stayed cold.
+    expect((compileFromExtraction as unknown as Mock).mock.calls.length).toBe(
+      1,
+    );
+    expect((compile as unknown as Mock).mock.calls.length).toBe(0);
+  });
+
+  it("sparql escape hatch queries the store", async () => {
+    let booted = false;
+    const store: LazyStore = {
+      get booted() {
+        return booted;
+      },
+      async get() {
+        const session = await readPack(dir);
+        booted = true;
+        return session;
+      },
+      invalidate() {
+        booted = false;
+      },
+    };
+    const facade = createQueryFacade(store);
+    const result = await facade.sparql(
+      "SELECT (COUNT(*) AS ?n) WHERE { ?s ?p ?o }",
+    );
+    expect(result.type).toBe("select");
+  });
+});

package/src/kernel/runtime/facade.ts

@@ -0,0 +1,47 @@
+/**
+ * The query facade — the typed spine over the lazy store.
+ *
+ * `graphql` is the default surface: it executes a document against the pack's
+ * precompiled schema via ke-graphql's in-process `executeLocal` (no HTTP, no
+ * serialization). `sparql` is the escape hatch: a raw query against the store,
+ * auto-prefixed by ke from the pack's prefix map. Both boot the store lazily on
+ * first use through the same memoized `LazyStore.get()`. ke-graphql is
+ * dynamic-imported so this module carries no static import of the heavy
+ * runtime; the ke/graphql types are referenced inline.
+ */
+
+import type { LazyStore, QueryFacade } from "./types.js";
+
+/**
+ * Build the query facade over a lazy store.
+ *
+ * @param store - The lazy store to query through.
+ * @returns The `{ graphql, sparql }` facade.
+ */
+export function createQueryFacade(store: LazyStore): QueryFacade {
+  return {
+    async graphql(
+      document: string,
+      variables?: Record<string, unknown> | null,
+    ): Promise<import("graphql").ExecutionResult> {
+      const session = await store.get();
+      const { executeLocal } = await import("@canonical/ke-graphql");
+      const result = await executeLocal({
+        schema: session.schema,
+        source: document,
+        variableValues: variables ?? undefined,
+        contextValue: session.createContext(session.store),
+      });
+      // Our packs compile without @defer/@stream, so this is always a plain
+      // ExecutionResult (never an incremental stream).
+      return result as import("graphql").ExecutionResult;
+    },
+
+    async sparql(text: string): Promise<import("@canonical/ke").QueryResult> {
+      const session = await store.get();
+      return session.store.query(text as never) as Promise<
+        import("@canonical/ke").QueryResult
+      >;
+    },
+  };
+}

package/src/kernel/runtime/graphpack/build.ts

@@ -0,0 +1,148 @@
+/**
+ * Build a content-addressed pack from RDF source inputs.
+ *
+ * This is the ONE place the live ke-graphql 7-pass `compile` runs (~210 ms):
+ * building is when we can afford it. The store is created once (parsing the
+ * TTL and writing the `data.nq` n-quads dump via ke's cache), the schema is
+ * extracted and serialized, the entity index is built, and a manifest is
+ * written LAST so the directory is only ever observed complete. Writes go to a
+ * temp directory and are atomically renamed into `packs/<contentHash>/`, so a
+ * crashed build never leaves a half-written pack; a hash whose directory is
+ * already complete is reused untouched.
+ *
+ * Reached only behind a dynamic import (`sources update`), never on the
+ * storeless fast path.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { createStore } from "@canonical/ke";
+import {
+  compile,
+  createStoreQueryFn,
+  serializeExtraction,
+} from "@canonical/ke-graphql";
+import { packDir, packsCacheDir } from "../paths.js";
+import { buildIndex } from "./buildIndex.js";
+import { contentHash, hashSources } from "./hash.js";
+import { packIsComplete, readManifest } from "./manifest.js";
+import {
+  DATA_FILE,
+  INDEX_FILE,
+  MANIFEST_FILE,
+  type Manifest,
+  SCHEMA_FILE,
+} from "./types.js";
+
+/** One RDF source to build into a pack. */
+export interface BuildPackInput {
+  /** Stable path label — part of the content hash. */
+  readonly path: string;
+  /** Raw RDF content. */
+  readonly content: string;
+}
+
+/** Provenance and options for a pack build. */
+export interface BuildPackOptions {
+  readonly name: string;
+  readonly version: string;
+  /** The config `packages` ref (verbatim) or a label. */
+  readonly sourceRef: string;
+  /** Prefixes the store (and every query) is built with. */
+  readonly prefixes?: Readonly<Record<string, string>>;
+}
+
+/** The outcome of a pack build (or cache hit). */
+export interface BuildPackResult {
+  readonly dir: string;
+  readonly contentHash: string;
+  readonly manifest: Manifest;
+  /** True when an already-complete pack was reused rather than rebuilt. */
+  readonly reused: boolean;
+}
+
+/**
+ * Build (or reuse) the pack for a set of source inputs.
+ *
+ * @param inputs - The RDF sources (path + content).
+ * @param options - Provenance and the prefixes to build with.
+ * @returns The pack directory, its content hash, and whether it was reused.
+ * @note Impure — creates a store, compiles the schema, writes the pack.
+ */
+export async function buildPack(
+  inputs: readonly BuildPackInput[],
+  options: BuildPackOptions,
+): Promise<BuildPackResult> {
+  const hash = await contentHash(
+    inputs.map((input) => ({ path: input.path, content: input.content })),
+  );
+  const dir = packDir(hash);
+
+  // Reuse only a COMPLETE pack (manifest + non-empty dump). A corrupt cache
+  // (intact manifest, ruined `data.nq`) must rebuild, not be reused — otherwise
+  // an emptied dump would be permanent.
+  if (packIsComplete(dir)) {
+    const cached = readManifest(dir);
+    if (cached)
+      return { dir, contentHash: hash, manifest: cached, reused: true };
+  }
+
+  mkdirSync(packsCacheDir(), { recursive: true });
+  const temp = mkdtempSync(
+    join(packsCacheDir(), `.build-${hash.slice(0, 12)}-`),
+  );
+  try {
+    const prefixes = options.prefixes ?? {};
+    const store = await createStore({
+      sources: inputs.map((input) => ({
+        content: input.content,
+        path: input.path,
+      })),
+      prefixes,
+      // ke writes the n-quads dump here after loading — our `data.nq`.
+      cache: join(temp, DATA_FILE),
+    });
+
+    try {
+      const compiled = await compile(createStoreQueryFn(store), store.prefixes);
+      const sourcesHash = hashSources(inputs.map((input) => input.content));
+      writeFileSync(
+        join(temp, SCHEMA_FILE),
+        serializeExtraction(compiled.extraction, sourcesHash),
+      );
+
+      const index = await buildIndex(store, store.prefixes, hash);
+      writeFileSync(join(temp, INDEX_FILE), JSON.stringify(index));
+
+      const manifest: Manifest = {
+        name: options.name,
+        version: options.version,
+        sourceRef: options.sourceRef,
+        contentHash: hash,
+        prefixes: { ...store.prefixes },
+        createdAt: new Date().toISOString(),
+      };
+      // Written LAST — the completeness marker for the directory.
+      writeFileSync(join(temp, MANIFEST_FILE), JSON.stringify(manifest));
+
+      // Publish atomically. A concurrent builder may have won the race — its
+      // pack is content-identical, so keep it and drop ours.
+      if (!packIsComplete(dir)) {
+        rmSync(dir, { recursive: true, force: true });
+        renameSync(temp, dir);
+      }
+      return { dir, contentHash: hash, manifest, reused: false };
+    } finally {
+      store.dispose();
+    }
+  } finally {
+    if (existsSync(temp)) rmSync(temp, { recursive: true, force: true });
+  }
+}

package/src/kernel/runtime/graphpack/buildIndex.ts

@@ -0,0 +1,229 @@
+/**
+ * Build the storeless entity index (`index.json`) from a populated store.
+ *
+ * A lean port of the v1 `buildGraphIndex` (#856): three bulk SPARQL queries —
+ * types, labels, and instance counts — joined in memory, rather than a query
+ * per subject. Only typed named-node subjects are indexed (untyped subjects and
+ * blank nodes are reachable via `graph query` but never listed). Each entity
+ * carries the FROZEN `{ name, type }` minimum plus the enrichment fields
+ * (`uri`, `prefixed`, `types`, `label`, `box`) the completion tier and reads
+ * use. The output is pure JSON — no store handle survives — so the completion
+ * tier reads it without ever booting oxigraph.
+ */
+
+import { compactUri } from "../../render/compactUri.js";
+import type { PackIndex, PackIndexEntity } from "./types.js";
+
+type Store = import("@canonical/ke").Store;
+
+/** `rdf:type`. */
+const RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+
+/** Meta-types that mark a subject as TBox schema (a class). */
+const CLASS_METATYPES = new Set([
+  "http://www.w3.org/2002/07/owl#Class",
+  "http://www.w3.org/2000/01/rdf-schema#Class",
+]);
+
+/** Meta-types that mark a subject as TBox schema (a property). */
+const PROPERTY_METATYPES = new Set([
+  "http://www.w3.org/2002/07/owl#ObjectProperty",
+  "http://www.w3.org/2002/07/owl#DatatypeProperty",
+  "http://www.w3.org/2002/07/owl#AnnotationProperty",
+  "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property",
+]);
+
+/** `owl:NamedIndividual` — a typing artifact, never a subject's domain class. */
+const NAMED_INDIVIDUAL = "http://www.w3.org/2002/07/owl#NamedIndividual";
+
+/** Namespaces whose types are structural, not a subject's domain class. */
+const STD_VOCAB_PREFIXES = [
+  "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  "http://www.w3.org/2000/01/rdf-schema#",
+  "http://www.w3.org/2002/07/owl#",
+  "http://www.w3.org/2001/XMLSchema#",
+  "http://www.w3.org/2004/02/skos/core#",
+  "http://www.w3.org/ns/shacl#",
+];
+
+/** Label predicates, in preference order. */
+const LABEL_PREDICATES = [
+  "http://www.w3.org/2000/01/rdf-schema#label",
+  "http://www.w3.org/2004/02/skos/core#prefLabel",
+  "http://purl.org/dc/terms/title",
+  "http://schema.org/name",
+];
+
+/** Description predicates, in preference order. */
+const DESCRIPTION_PREDICATES = [
+  "http://www.w3.org/2000/01/rdf-schema#comment",
+  "http://purl.org/dc/terms/description",
+  "http://www.w3.org/2004/02/skos/core#definition",
+  "http://schema.org/description",
+];
+
+/**
+ * Alternative-name predicates: `ds:name`, the property `tier lookup` (and other
+ * `ds:name`-addressed families) match on. Projected into `altNames` so the
+ * storeless name-completion sources can offer those tokens exactly, without a
+ * store boot. Distinct from the display `label` — a subject may carry both.
+ */
+const ALT_NAME_PREDICATES = ["https://ds.canonical.com/name"];
+
+const isStdVocab = (uri: string): boolean =>
+  STD_VOCAB_PREFIXES.some((ns) => uri.startsWith(ns));
+
+/** Classify a subject's full types into a box and a primary (filter) type. */
+function classify(
+  fullTypes: readonly string[],
+): { box: "tbox" | "abox"; primary: string } | null {
+  if (fullTypes.length === 0) return null;
+  const classMeta = fullTypes.find((t) => CLASS_METATYPES.has(t));
+  if (classMeta) return { box: "tbox", primary: classMeta };
+  const propMeta = fullTypes.find((t) => PROPERTY_METATYPES.has(t));
+  if (propMeta) return { box: "tbox", primary: propMeta };
+  // An individual: its filter key is the most specific domain class.
+  const domain =
+    fullTypes.find((t) => t !== NAMED_INDIVIDUAL && !isStdVocab(t)) ??
+    fullTypes.find((t) => t !== NAMED_INDIVIDUAL) ??
+    fullTypes[0];
+  return { box: "abox", primary: domain as string };
+}
+
+/** A `VALUES ?p { … }` body from a predicate list. */
+const valuesList = (uris: readonly string[]): string =>
+  uris.map((uri) => `<${uri}>`).join(" ");
+
+/**
+ * Per subject, keep the object whose predicate ranks HIGHEST (lowest index) in
+ * `preference`. The `?p` binding is projected so the winner is chosen by declared
+ * preference order: SPARQL returns solutions in an unspecified order, so keeping
+ * the first row per subject would be store-order-dependent (an entity carrying
+ * both `rdfs:label` and `skos:prefLabel` could index either), not ranked.
+ */
+function preferredBySubject(
+  result: import("@canonical/ke").SelectResult,
+  valueVar: string,
+  preference: readonly string[],
+): Map<string, string> {
+  const best = new Map<string, { value: string; rank: number }>();
+  for (const term of result.termBindings) {
+    if (term.s?.termType !== "NamedNode") continue;
+    const value = term[valueVar]?.value;
+    const predicate = term.p?.value;
+    if (!value || predicate === undefined) continue;
+    const rank = preference.indexOf(predicate);
+    if (rank === -1) continue;
+    const current = best.get(term.s.value);
+    if (current === undefined || rank < current.rank) {
+      best.set(term.s.value, { value, rank });
+    }
+  }
+  const picked = new Map<string, string>();
+  for (const [subject, entry] of best) picked.set(subject, entry.value);
+  return picked;
+}
+
+/**
+ * Collect ALL matching object values per subject (deduped, insertion order) —
+ * for multi-valued enrichment like `altNames`, where every value is a
+ * completable token rather than a single preferred one.
+ */
+function allBySubject(
+  result: import("@canonical/ke").SelectResult,
+  valueVar: string,
+): Map<string, string[]> {
+  const collected = new Map<string, string[]>();
+  for (const term of result.termBindings) {
+    if (term.s?.termType !== "NamedNode") continue;
+    const value = term[valueVar]?.value;
+    if (!value) continue;
+    const bucket = collected.get(term.s.value) ?? [];
+    if (!bucket.includes(value)) bucket.push(value);
+    collected.set(term.s.value, bucket);
+  }
+  return collected;
+}
+
+/**
+ * Build the entity index from a populated store.
+ *
+ * @param store - The ke store to query.
+ * @param prefixes - The store's merged prefix map.
+ * @param contentHash - The pack's content hash, embedded in the index.
+ * @returns The storeless {@link PackIndex}.
+ * @note Impure — runs bulk SPARQL queries against the store.
+ */
+export async function buildIndex(
+  store: Store,
+  prefixes: Readonly<Record<string, string>>,
+  contentHash: string,
+): Promise<PackIndex> {
+  const [typesResult, labelResult, descResult, altNameResult] =
+    await Promise.all([
+      store.query(
+        `SELECT ?s ?type WHERE { ?s <${RDF_TYPE}> ?type }` as never,
+      ) as Promise<import("@canonical/ke").SelectResult>,
+      store.query(
+        `SELECT ?s ?p ?label WHERE { ?s ?p ?label . VALUES ?p { ${valuesList(LABEL_PREDICATES)} } }` as never,
+      ) as Promise<import("@canonical/ke").SelectResult>,
+      store.query(
+        `SELECT ?s ?p ?desc WHERE { ?s ?p ?desc . VALUES ?p { ${valuesList(DESCRIPTION_PREDICATES)} } }` as never,
+      ) as Promise<import("@canonical/ke").SelectResult>,
+      store.query(
+        `SELECT ?s ?p ?alt WHERE { ?s ?p ?alt . VALUES ?p { ${valuesList(ALT_NAME_PREDICATES)} } }` as never,
+      ) as Promise<import("@canonical/ke").SelectResult>,
+    ]);
+
+  const typesBySubject = new Map<string, string[]>();
+  const instanceCountByType: Record<string, number> = {};
+  for (const term of typesResult.termBindings) {
+    if (term.s?.termType !== "NamedNode") continue;
+    const subject = term.s.value;
+    const typeUri = term.type?.value ?? "";
+    const bucket = typesBySubject.get(subject) ?? [];
+    bucket.push(typeUri);
+    typesBySubject.set(subject, bucket);
+    instanceCountByType[typeUri] = (instanceCountByType[typeUri] ?? 0) + 1;
+  }
+
+  const labelBySubject = preferredBySubject(
+    labelResult,
+    "label",
+    LABEL_PREDICATES,
+  );
+  const descBySubject = preferredBySubject(
+    descResult,
+    "desc",
+    DESCRIPTION_PREDICATES,
+  );
+  const altNamesBySubject = allBySubject(altNameResult, "alt");
+
+  const entities: PackIndexEntity[] = [];
+  for (const [subject, fullTypes] of typesBySubject) {
+    const classification = classify(fullTypes);
+    if (classification === null) continue;
+    const prefixed = compactUri(subject, prefixes);
+    const altNames = altNamesBySubject.get(subject);
+    entities.push({
+      name: prefixed,
+      type: compactUri(classification.primary, prefixes),
+      uri: subject,
+      prefixed,
+      types: fullTypes.map((t) => compactUri(t, prefixes)),
+      label: labelBySubject.get(subject) ?? null,
+      ...(altNames && altNames.length > 0 ? { altNames } : {}),
+      box: classification.box,
+      description: descBySubject.get(subject) ?? null,
+    });
+  }
+  entities.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+
+  return {
+    version: 2,
+    contentHash,
+    prefixes,
+    entities,
+    instanceCountByType,
+  };
+}

package/src/kernel/runtime/graphpack/embedded/pack.generated.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED by scripts/genEmbedded.ts — do not edit by hand.
+// Regenerate after changing sample.ttl: `bun run scripts/genEmbedded.ts`.
+export const dataNq =
+  '<https://pragma.canonical.com/sample#Dialog> <https://pragma.canonical.com/sample#dependsOn> <https://pragma.canonical.com/sample#Card> .\n<https://pragma.canonical.com/sample#Dialog> <https://pragma.canonical.com/sample#dependsOn> <https://pragma.canonical.com/sample#Button> .\n<https://pragma.canonical.com/sample#Dialog> <https://pragma.canonical.com/sample#componentName> "Dialog" .\n<https://pragma.canonical.com/sample#Dialog> <http://www.w3.org/2000/01/rdf-schema#label> "Dialog" .\n<https://pragma.canonical.com/sample#Dialog> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://pragma.canonical.com/sample#Component> .\n<https://pragma.canonical.com/sample#Card> <https://pragma.canonical.com/sample#dependsOn> <https://pragma.canonical.com/sample#Button> .\n<https://pragma.canonical.com/sample#Card> <https://pragma.canonical.com/sample#componentName> "Card" .\n<https://pragma.canonical.com/sample#Card> <http://www.w3.org/2000/01/rdf-schema#label> "Card" .\n<https://pragma.canonical.com/sample#Card> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://pragma.canonical.com/sample#Component> .\n<https://pragma.canonical.com/sample#Button> <https://pragma.canonical.com/sample#componentName> "Button" .\n<https://pragma.canonical.com/sample#Button> <http://www.w3.org/2000/01/rdf-schema#label> "Button" .\n<https://pragma.canonical.com/sample#Button> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://pragma.canonical.com/sample#Component> .\n<https://pragma.canonical.com/sample#dependsOn> <http://www.w3.org/2000/01/rdf-schema#range> <https://pragma.canonical.com/sample#Component> .\n<https://pragma.canonical.com/sample#dependsOn> <http://www.w3.org/2000/01/rdf-schema#domain> <https://pragma.canonical.com/sample#Component> .\n<https://pragma.canonical.com/sample#dependsOn> <http://www.w3.org/2000/01/rdf-schema#label> "depends on" .\n<https://pragma.canonical.com/sample#dependsOn> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2002/07/owl#ObjectProperty> .\n<https://pragma.canonical.com/sample#componentName> <http://www.w3.org/2000/01/rdf-schema#range> <http://www.w3.org/2001/XMLSchema#string> .\n<https://pragma.canonical.com/sample#componentName> <http://www.w3.org/2000/01/rdf-schema#domain> <https://pragma.canonical.com/sample#Component> .\n<https://pragma.canonical.com/sample#componentName> <http://www.w3.org/2000/01/rdf-schema#label> "component name" .\n<https://pragma.canonical.com/sample#componentName> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2002/07/owl#DatatypeProperty> .\n<https://pragma.canonical.com/sample#Component> <http://www.w3.org/2000/01/rdf-schema#comment> "A reusable design-system building block." .\n<https://pragma.canonical.com/sample#Component> <http://www.w3.org/2000/01/rdf-schema#label> "Component" .\n<https://pragma.canonical.com/sample#Component> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2002/07/owl#Class> .\n';
+export const schemaJson =
+  '{"version":1,"sourcesHash":"8a510cc1fb8c950e","classes":[{"uri":"https://pragma.canonical.com/sample#Component","superclasses":[],"label":"Component","definition":"A reusable design-system building block."}],"properties":[{"uri":"https://pragma.canonical.com/sample#dependsOn","kind":"object","domains":["https://pragma.canonical.com/sample#Component"],"ranges":["https://pragma.canonical.com/sample#Component"],"label":"depends on"},{"uri":"https://pragma.canonical.com/sample#componentName","kind":"datatype","domains":["https://pragma.canonical.com/sample#Component"],"ranges":["http://www.w3.org/2001/XMLSchema#string"],"label":"component name"}],"inverses":[],"functionals":[],"datatypes":[],"namespaces":[["https://pragma.canonical.com/sample#","ex"]],"shaclConstraints":[],"unions":[],"instanceStats":[["http://www.w3.org/2002/07/owl#ObjectProperty",{"total":1,"named":1}],["https://pragma.canonical.com/sample#Component",{"total":3,"named":3}],["http://www.w3.org/2002/07/owl#DatatypeProperty",{"total":1,"named":1}],["http://www.w3.org/2002/07/owl#Class",{"total":1,"named":1}]],"selfReferential":[],"functionalViolations":[],"undeclaredPredicates":[],"annotations":[],"deepBlankNesting":false}';
+export const manifestJson =
+  '{"name":"pragma-sample","version":"0.31.0","sourceRef":"embedded:sample.ttl","contentHash":"bfe536dc9afc625502a8f578aadf4eb9927b55260951bc61f58cf07219593034","prefixes":{"ex":"https://pragma.canonical.com/sample#","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#"},"createdAt":"2026-07-18T04:52:05.250Z"}';

package/src/kernel/runtime/graphpack/embedded/pack.index.generated.ts

@@ -0,0 +1,4 @@
+// AUTO-GENERATED by scripts/genEmbedded.ts — do not edit by hand.
+// Regenerate after changing sample.ttl: `bun run scripts/genEmbedded.ts`.
+export const indexJson =
+  '{"version":2,"contentHash":"bfe536dc9afc625502a8f578aadf4eb9927b55260951bc61f58cf07219593034","prefixes":{"ex":"https://pragma.canonical.com/sample#","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#"},"entities":[{"name":"ex:Button","type":"ex:Component","uri":"https://pragma.canonical.com/sample#Button","prefixed":"ex:Button","types":["ex:Component"],"label":"Button","box":"abox","description":null},{"name":"ex:Card","type":"ex:Component","uri":"https://pragma.canonical.com/sample#Card","prefixed":"ex:Card","types":["ex:Component"],"label":"Card","box":"abox","description":null},{"name":"ex:Component","type":"owl:Class","uri":"https://pragma.canonical.com/sample#Component","prefixed":"ex:Component","types":["owl:Class"],"label":"Component","box":"tbox","description":"A reusable design-system building block."},{"name":"ex:Dialog","type":"ex:Component","uri":"https://pragma.canonical.com/sample#Dialog","prefixed":"ex:Dialog","types":["ex:Component"],"label":"Dialog","box":"abox","description":null},{"name":"ex:componentName","type":"owl:DatatypeProperty","uri":"https://pragma.canonical.com/sample#componentName","prefixed":"ex:componentName","types":["owl:DatatypeProperty"],"label":"component name","box":"tbox","description":null},{"name":"ex:dependsOn","type":"owl:ObjectProperty","uri":"https://pragma.canonical.com/sample#dependsOn","prefixed":"ex:dependsOn","types":["owl:ObjectProperty"],"label":"depends on","box":"tbox","description":null}],"instanceCountByType":{"https://pragma.canonical.com/sample#Component":3,"http://www.w3.org/2002/07/owl#ObjectProperty":1,"http://www.w3.org/2002/07/owl#DatatypeProperty":1,"http://www.w3.org/2002/07/owl#Class":1}}';

package/src/kernel/runtime/graphpack/embedded/sample.ttl

@@ -0,0 +1,39 @@
+# Embedded fallback pack source — a small, self-contained sample ontology.
+#
+# Compiled by `scripts/genEmbedded.ts` into `pack.generated.ts`. It exists so a
+# fresh install (no configured packages, no lock) can answer store-backed reads
+# without a network round-trip. Keep it tiny: it ships inside the binary.
+
+@prefix ex:   <https://pragma.canonical.com/sample#> .
+@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#> .
+
+ex:Component a owl:Class ;
+  rdfs:label "Component" ;
+  rdfs:comment "A reusable design-system building block." .
+
+ex:componentName a owl:DatatypeProperty ;
+  rdfs:label "component name" ;
+  rdfs:domain ex:Component ;
+  rdfs:range xsd:string .
+
+ex:dependsOn a owl:ObjectProperty ;
+  rdfs:label "depends on" ;
+  rdfs:domain ex:Component ;
+  rdfs:range ex:Component .
+
+ex:Button a ex:Component ;
+  rdfs:label "Button" ;
+  ex:componentName "Button" .
+
+ex:Card a ex:Component ;
+  rdfs:label "Card" ;
+  ex:componentName "Card" ;
+  ex:dependsOn ex:Button .
+
+ex:Dialog a ex:Component ;
+  rdfs:label "Dialog" ;
+  ex:componentName "Dialog" ;
+  ex:dependsOn ex:Button , ex:Card .