@canonical/pragma-cli 0.30.0 → 0.32.0

package/src/mcp/resources/pickFirstValue.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it } from "vitest";
-import pickFirstValue from "./pickFirstValue.js";
-
-describe("pickFirstValue", () => {
-  it("returns the value of the first predicate present in priority order", () => {
-    const values = new Map([
-      ["p2", ["second"]],
-      ["p3", ["third"]],
-    ]);
-    expect(pickFirstValue(values, ["p1", "p2", "p3"])).toBe("second");
-  });
-
-  it("skips empty values", () => {
-    const values = new Map([
-      ["p1", [""]],
-      ["p2", ["real"]],
-    ]);
-    expect(pickFirstValue(values, ["p1", "p2"])).toBe("real");
-  });
-
-  it("returns null when no predicate matches", () => {
-    const values = new Map([["other", ["x"]]]);
-    expect(pickFirstValue(values, ["p1", "p2"])).toBeNull();
-  });
-
-  it("returns null for an empty map", () => {
-    expect(pickFirstValue(new Map(), ["p1"])).toBeNull();
-  });
-});

package/src/mcp/resources/pickFirstValue.ts

@@ -1,26 +0,0 @@
-/**
- * Resolve the first available value from a predicate priority chain.
- *
- * Walks `orderedPredicates` in order and returns the first non-empty value
- * present in `valuesByPredicate`. This drives the label/description fallback:
- * a namespace's `PROPERTY_MAP` predicate is tried first, then the generic
- * chain (`rdfs:label`, `skos:prefLabel`, …), so foreign ontologies still
- * resolve a name.
- *
- * @param valuesByPredicate - Full predicate URI → asserted lexical values.
- * @param orderedPredicates - Predicate URIs in descending priority.
- * @returns The first non-empty value, or `null` when none match.
- */
-export default function pickFirstValue(
-  valuesByPredicate: ReadonlyMap<string, readonly string[]>,
-  orderedPredicates: readonly string[],
-): string | null {
-  for (const predicate of orderedPredicates) {
-    const values = valuesByPredicate.get(predicate);
-    if (values === undefined) continue;
-    for (const value of values) {
-      if (value.length > 0) return value;
-    }
-  }
-  return null;
-}

package/src/mcp/resources/pickPrimaryType.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { PREFIX_MAP } from "../../domains/shared/prefixes.js";
-import pickPrimaryType from "./pickPrimaryType.js";
-
-const COMPONENT = `${PREFIX_MAP.ds}Component`;
-const BLOCK = `${PREFIX_MAP.ds}Block`;
-const NAMED_INDIVIDUAL = `${PREFIX_MAP.owl}NamedIndividual`;
-const OWL_THING = `${PREFIX_MAP.owl}Thing`;
-
-describe("pickPrimaryType", () => {
-  it("returns null for no types", () => {
-    expect(pickPrimaryType([])).toBeNull();
-  });
-
-  it("picks the domain type over a meta-type that sorts first", () => {
-    // owl: is http://… and ds: is https://…, so the meta-type sorts first;
-    // the meaningful domain type must still win.
-    expect([...[NAMED_INDIVIDUAL, COMPONENT]].sort().at(0)).toBe(
-      NAMED_INDIVIDUAL,
-    );
-    expect(pickPrimaryType([NAMED_INDIVIDUAL, COMPONENT])).toBe(COMPONENT);
-  });
-
-  it("ignores owl:Thing and owl:NamedIndividual together", () => {
-    expect(pickPrimaryType([OWL_THING, NAMED_INDIVIDUAL, COMPONENT])).toBe(
-      COMPONENT,
-    );
-  });
-
-  it("is deterministic among several domain types (lexicographic first)", () => {
-    expect(pickPrimaryType([COMPONENT, BLOCK])).toBe(BLOCK);
-    expect(pickPrimaryType([BLOCK, COMPONENT])).toBe(BLOCK);
-  });
-
-  it("falls back to the full set when only meta-types are present", () => {
-    // Both share the owl# namespace, so "NamedIndividual" < "Thing".
-    expect(pickPrimaryType([NAMED_INDIVIDUAL, OWL_THING])).toBe(
-      NAMED_INDIVIDUAL,
-    );
-  });
-});

package/src/mcp/resources/pickPrimaryType.ts

@@ -1,26 +0,0 @@
-import { NON_GROUPING_TYPE_URIS } from "./constants.js";
-
-/**
- * Choose an individual's primary type — its grouping key and `instanceOf`
- * pointer — from its full `rdf:type` object URIs.
- *
- * Schema and top/individual meta-types (`owl:Class`, `owl:NamedIndividual`,
- * `owl:Thing`, `rdf:Property`, …) are filtered out first, so a subject typed
- * `[ds:Component, owl:NamedIndividual]` resolves to `ds:Component` rather than
- * the meta-type that happens to sort first. Among the remaining meaningful
- * types the lexicographically-first is chosen for determinism. When an entity
- * has nothing but meta-types, the full set is the fallback pool so a type is
- * still returned.
- *
- * @param fullTypes - The subject's full `rdf:type` object URIs.
- * @returns The chosen full type URI, or `null` when there are no types.
- */
-export default function pickPrimaryType(
-  fullTypes: readonly string[],
-): string | null {
-  const meaningful = fullTypes.filter(
-    (type) => !NON_GROUPING_TYPE_URIS.includes(type),
-  );
-  const pool = meaningful.length > 0 ? meaningful : fullTypes;
-  return [...pool].sort((a, b) => a.localeCompare(b)).at(0) ?? null;
-}

package/src/mcp/resources/rankUriCompletions.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from "vitest";
-import rankUriCompletions from "./rankUriCompletions.js";
-import type { UriCompletionCandidate } from "./types.js";
-
-const candidates: UriCompletionCandidate[] = [
-  { prefixed: "ds:Component", label: "Component" },
-  { prefixed: "ds:global.component.button", label: "Button" },
-  { prefixed: "ds:global.component.card", label: "Card" },
-  { prefixed: "cs:code_purity", label: "code/function/purity" },
-];
-
-describe("rankUriCompletions", () => {
-  it("matches a URI substring case-insensitively", () => {
-    expect(rankUriCompletions(candidates, "BUTTON", 10)).toContain(
-      "ds:global.component.button",
-    );
-  });
-
-  it("matches a human label fragment", () => {
-    expect(rankUriCompletions(candidates, "card", 10)).toContain(
-      "ds:global.component.card",
-    );
-  });
-
-  it("ranks an exact match above a substring match", () => {
-    const ranked = rankUriCompletions(candidates, "component", 10);
-    expect(ranked.indexOf("ds:Component")).toBeLessThan(
-      ranked.indexOf("ds:global.component.button"),
-    );
-  });
-
-  it("ranks a prefix match above a substring match", () => {
-    const ranked = rankUriCompletions(candidates, "comp", 10);
-    expect(ranked.indexOf("ds:Component")).toBeLessThan(
-      ranked.indexOf("ds:global.component.button"),
-    );
-  });
-
-  it("returns the compacted URI even when matched by label", () => {
-    expect(rankUriCompletions(candidates, "purity", 10)).toEqual([
-      "cs:code_purity",
-    ]);
-  });
-
-  it("caps the result count", () => {
-    expect(rankUriCompletions(candidates, "", 2)).toHaveLength(2);
-  });
-
-  it("excludes non-matches", () => {
-    expect(rankUriCompletions(candidates, "zzz", 10)).toEqual([]);
-  });
-});

package/src/mcp/resources/rankUriCompletions.ts

@@ -1,64 +0,0 @@
-import type { UriCompletionCandidate } from "./types.js";
-
-/** Match strength of a query against one field, higher is better. */
-const NO_MATCH = 0;
-const SUBSTRING_MATCH = 1;
-const PREFIX_MATCH = 2;
-const EXACT_MATCH = 3;
-
-/** Score a single lowercased field against a lowercased query. */
-function scoreField(field: string, query: string): number {
-  if (field === query) return EXACT_MATCH;
-  if (field.startsWith(query)) return PREFIX_MATCH;
-  if (field.includes(query)) return SUBSTRING_MATCH;
-  return NO_MATCH;
-}
-
-/**
- * Rank URI autocomplete candidates for a partial query.
- *
- * Matches case-insensitively against BOTH the compacted URI and the human
- * label, so `button` completes `ds:global.component.button` and a label
- * fragment works too. Ranks exact > prefix > substring (taking the stronger
- * of the two fields), breaks ties by compacted URI for determinism, and caps
- * the result at `limit`. Returns compacted URIs — the values a client reads.
- *
- * @param candidates - Listable subjects with their compacted URI and label.
- * @param query - The partial text typed by the client.
- * @param limit - Maximum suggestions to return.
- * @returns Ranked, deduped, capped compacted URIs.
- */
-export default function rankUriCompletions(
-  candidates: readonly UriCompletionCandidate[],
-  query: string,
-  limit: number,
-): string[] {
-  const needle = query.toLowerCase();
-
-  const scored: { prefixed: string; score: number }[] = [];
-  for (const candidate of candidates) {
-    const uriScore = scoreField(candidate.prefixed.toLowerCase(), needle);
-    const labelScore =
-      candidate.label === null
-        ? NO_MATCH
-        : scoreField(candidate.label.toLowerCase(), needle);
-    const score = Math.max(uriScore, labelScore);
-    if (score > NO_MATCH) scored.push({ prefixed: candidate.prefixed, score });
-  }
-
-  scored.sort((a, b) =>
-    b.score !== a.score
-      ? b.score - a.score
-      : a.prefixed.localeCompare(b.prefixed),
-  );
-
-  const seen = new Set<string>();
-  const ranked: string[] = [];
-  for (const { prefixed } of scored) {
-    if (seen.has(prefixed)) continue;
-    seen.add(prefixed);
-    ranked.push(prefixed);
-    if (ranked.length >= limit) break;
-  }
-  return ranked;
-}

package/src/mcp/resources/readEntity.ts

@@ -1,169 +0,0 @@
-import type { Store } from "@canonical/ke";
-import { PragmaError } from "#error";
-import findNamespace from "../../domains/ontology/helpers/findNamespace.js";
-import { buildQuery } from "../../domains/shared/buildQuery.js";
-import compactUri from "../../domains/shared/compactUri.js";
-import classifyEntity from "./classifyEntity.js";
-import { RDF_TYPE, RDFS_DOMAIN, RDFS_SUBCLASS_OF } from "./constants.js";
-import {
-  resolveDescriptionPredicates,
-  resolveLabelPredicates,
-} from "./displayPredicates.js";
-import pickFirstValue from "./pickFirstValue.js";
-import pickPrimaryType from "./pickPrimaryType.js";
-import type {
-  GraphIndex,
-  PropertyGroup,
-  PropertyValue,
-  ResourceEntity,
-} from "./types.js";
-
-/** Query the compacted subjects of `?x <predicate> <object>`. */
-async function fetchReferencingSubjects(
-  store: Store,
-  predicate: string,
-  object: string,
-  prefixes: Readonly<Record<string, string>>,
-): Promise<string[]> {
-  const result = await store.query(
-    buildQuery(`SELECT ?x WHERE { ?x <${predicate}> <${object}> } ORDER BY ?x`),
-  );
-  if (result.type !== "select") return [];
-  return result.termBindings
-    .filter((t) => t.x?.termType === "NamedNode")
-    .map((t) => compactUri(t.x?.value ?? "", prefixes));
-}
-
-/**
- * Read a single entity into a box-aware payload.
- *
- * Object values are classified by RDF term type (via `termBindings`), so a
- * URL-shaped literal stays a literal and a foreign IRI is recognised as a URI.
- * A class read is enriched with its superclasses, direct subclasses, asserted
- * instance count, and declared properties; an individual read carries a
- * pointer to its primary class. Object URIs are labelled from the prebuilt
- * index — no per-object query.
- *
- * @param store - The ke store to query.
- * @param fullUri - The fully resolved subject URI.
- * @param prefixes - The store's merged prefix map.
- * @param index - The prebuilt graph index for label and count lookups.
- * @returns The entity payload.
- * @throws PragmaError.notFound when the subject has no triples.
- *
- * @note Queries ke store
- */
-export default async function readEntity(
-  store: Store,
-  fullUri: string,
-  prefixes: Readonly<Record<string, string>>,
-  index: GraphIndex,
-): Promise<ResourceEntity> {
-  const result = await store.query(
-    buildQuery(`SELECT ?p ?o WHERE { <${fullUri}> ?p ?o } ORDER BY ?p ?o`),
-  );
-
-  if (result.type !== "select" || result.bindings.length === 0) {
-    throw PragmaError.notFound("entity", compactUri(fullUri, prefixes), {
-      recovery: {
-        message:
-          "Check the URI is correct and run a SPARQL query to find valid URIs.",
-        cli: "pragma graph query 'SELECT ?s WHERE { ?s ?p ?o } LIMIT 10'",
-        mcp: { tool: "graph_query" },
-      },
-    });
-  }
-
-  const fullTypes: string[] = [];
-  const types: string[] = [];
-  const groupMap = new Map<string, PropertyValue[]>();
-  const valuesByPredicate = new Map<string, string[]>();
-
-  for (const term of result.termBindings) {
-    const predicate = term.p?.value ?? "";
-    const objectTerm = term.o;
-    if (objectTerm === undefined) continue;
-
-    const rawValues = valuesByPredicate.get(predicate) ?? [];
-    rawValues.push(objectTerm.value);
-    valuesByPredicate.set(predicate, rawValues);
-
-    if (predicate === RDF_TYPE) {
-      fullTypes.push(objectTerm.value);
-      types.push(compactUri(objectTerm.value, prefixes));
-      continue;
-    }
-
-    const compactPred = compactUri(predicate, prefixes);
-    const existing = groupMap.get(compactPred) ?? [];
-    if (objectTerm.termType === "NamedNode") {
-      existing.push({
-        type: "uri",
-        uri: objectTerm.value,
-        prefixed: compactUri(objectTerm.value, prefixes),
-        label: index.labelByUri.get(objectTerm.value) ?? null,
-      });
-    } else if (objectTerm.termType === "BlankNode") {
-      existing.push({ type: "bnode", id: objectTerm.value });
-    } else {
-      existing.push({ type: "literal", value: objectTerm.value });
-    }
-    groupMap.set(compactPred, existing);
-  }
-
-  const classification = classifyEntity(fullTypes) ?? {
-    box: "abox" as const,
-    category: "individual" as const,
-  };
-  const prefix = findNamespace(fullUri, Object.entries(prefixes))?.prefix;
-  const label = pickFirstValue(
-    valuesByPredicate,
-    resolveLabelPredicates(prefix),
-  );
-  const description = pickFirstValue(
-    valuesByPredicate,
-    resolveDescriptionPredicates(prefix),
-  );
-
-  const properties: PropertyGroup[] = [...groupMap.entries()].map(
-    ([predicate, values]) => ({ predicate, values }),
-  );
-
-  const base: ResourceEntity = {
-    uri: fullUri,
-    prefixed: compactUri(fullUri, prefixes),
-    box: classification.box,
-    category: classification.category,
-    types,
-    label,
-    description,
-    properties,
-  };
-
-  if (classification.category === "class") {
-    const [subClasses, declaredProperties] = await Promise.all([
-      fetchReferencingSubjects(store, RDFS_SUBCLASS_OF, fullUri, prefixes),
-      fetchReferencingSubjects(store, RDFS_DOMAIN, fullUri, prefixes),
-    ]);
-    return {
-      ...base,
-      superClasses: (valuesByPredicate.get(RDFS_SUBCLASS_OF) ?? []).map((u) =>
-        compactUri(u, prefixes),
-      ),
-      subClasses,
-      instanceCount: index.instanceCountByType.get(fullUri) ?? 0,
-      declaredProperties,
-    };
-  }
-
-  if (classification.category === "individual") {
-    const primaryTypeFull = pickPrimaryType(fullTypes);
-    return {
-      ...base,
-      instanceOf:
-        primaryTypeFull === null ? null : compactUri(primaryTypeFull, prefixes),
-    };
-  }
-
-  return base;
-}

package/src/mcp/resources/registerResources.ts

@@ -1,126 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { PragmaError } from "#error";
-import resolveUri from "../../domains/graph/helpers/resolveUri.js";
-import type { PragmaRuntime } from "../../domains/shared/runtime.js";
-import buildGraphIndex from "./buildGraphIndex.js";
-import buildResourceList from "./buildResourceList.js";
-import { COMPLETION_LIMIT } from "./constants.js";
-import rankUriCompletions from "./rankUriCompletions.js";
-import readEntity from "./readEntity.js";
-import type { GraphIndex, ListingTruncation } from "./types.js";
-
-/** RFC 6570 template capturing the whole (prefixed or full) URI as `uri`. */
-const URI_TEMPLATE = "{+uri}";
-
-const TEMPLATE_DESCRIPTION =
-  "Knowledge-graph entities from the ke store. TBox schema (owl:Class / property " +
-  "definitions) is listed first and in full; ABox individuals follow, grouped by " +
-  "class and capped per class. Category and box are carried in each entry's name, " +
-  "annotations.priority, and _meta. Read any entry by its prefixed URI " +
-  "(e.g. ds:global.component.button); autocomplete matches URI or label substrings.";
-
-/**
- * Report capped individuals to stderr so truncation is never silent.
- *
- * @note Impure — writes to stderr.
- */
-function warnTruncation(truncation: ListingTruncation): void {
-  const parts = [...truncation.droppedByType.entries()]
-    .filter(([, dropped]) => dropped > 0)
-    .map(([type, dropped]) => `${type}: ${dropped}`);
-  process.stderr.write(
-    `pragma MCP resources: capped ${truncation.totalDropped} individual(s) ` +
-      `from the listing (${parts.join(", ")}); reach them via URI autocomplete ` +
-      "or the graph_query tool.\n",
-  );
-}
-
-/** Read the single `uri` template variable, tolerating array expansion. */
-function readUriVariable(value: string | string[] | undefined): string {
-  const uri = Array.isArray(value) ? value.at(0) : value;
-  if (uri === undefined) {
-    throw PragmaError.invalidInput("uri", String(value), {
-      recovery: { message: "Provide a prefixed or full entity URI." },
-    });
-  }
-  return uri;
-}
-
-/**
- * Register the graph-driven MCP resource surface on the server.
- *
- * One `{+uri}` template backs listing, autocomplete, and reads. The graph
- * index is built once per runtime (the store is immutable after boot) and
- * reused across calls, so autocomplete stays cheap. Listing separates TBox
- * schema from ABox individuals and caps the instance long tail; reads return
- * a box-aware payload.
- *
- * @param server - The MCP server to register resources on.
- * @param runtime - The pragma runtime providing the ke store and prefixes.
- *
- * @note Impure — registers handlers and queries the store lazily.
- */
-export default function registerResources(
-  server: McpServer,
-  runtime: PragmaRuntime,
-): void {
-  const { store } = runtime;
-  const prefixes = store.prefixes;
-
-  let indexPromise: Promise<GraphIndex> | undefined;
-  const getIndex = (): Promise<GraphIndex> => {
-    indexPromise ??= buildGraphIndex(store, prefixes);
-    return indexPromise;
-  };
-
-  const template = new ResourceTemplate(URI_TEMPLATE, {
-    list: async () => {
-      const index = await getIndex();
-      const { resources, truncation } = buildResourceList(index);
-      if (truncation.totalDropped > 0) warnTruncation(truncation);
-      return { resources };
-    },
-    complete: {
-      uri: async (value) => {
-        const index = await getIndex();
-        const candidates = index.entities.map((entity) => ({
-          prefixed: entity.prefixed,
-          label: entity.label,
-        }));
-        return rankUriCompletions(candidates, value, COMPLETION_LIMIT);
-      },
-    },
-  });
-
-  server.registerResource(
-    "graph-entity",
-    template,
-    { description: TEMPLATE_DESCRIPTION, mimeType: "application/json" },
-    async (url, variables) => {
-      try {
-        const prefixedUri = readUriVariable(variables.uri);
-        const fullUri = resolveUri(prefixedUri, prefixes);
-        const index = await getIndex();
-        const entity = await readEntity(store, fullUri, prefixes, index);
-        return {
-          contents: [
-            {
-              uri: url.href,
-              mimeType: "application/json",
-              text: JSON.stringify(entity, null, 2),
-            },
-          ],
-        };
-      } catch (error) {
-        const message =
-          error instanceof PragmaError
-            ? JSON.stringify({ code: error.code, message: error.message })
-            : String(error);
-        return {
-          contents: [{ uri: url.href, mimeType: "text/plain", text: message }],
-        };
-      }
-    },
-  );
-}

package/src/mcp/resources/types.ts

@@ -1,128 +0,0 @@
-/**
- * Shared types for the MCP resource surface.
- *
- * These shapes flow from the bulk graph index (`buildGraphIndex`) through
- * listing (`buildResourceList`), autocomplete (`rankUriCompletions`), and
- * entity reads (`readEntity`). They live together because each stage
- * consumes the previous stage's output — the box/category vocabulary is the
- * spine that keeps TBox schema and ABox individuals distinguishable end to end.
- */
-
-/** Whether an entity is schema (TBox) or an individual (ABox). */
-export type EntityBox = "tbox" | "abox";
-
-/** Fine-grained entity kind within its box. */
-export type EntityCategory = "class" | "property" | "individual";
-
-/** A literal object value in an entity read. */
-export interface PropertyValueLiteral {
-  readonly type: "literal";
-  readonly value: string;
-}
-
-/** A URI object value in an entity read, resolved to a summary. */
-export interface PropertyValueUri {
-  readonly type: "uri";
-  readonly uri: string;
-  readonly prefixed: string;
-  readonly label: string | null;
-}
-
-/** A blank-node object value in an entity read. */
-export interface PropertyValueBlank {
-  readonly type: "bnode";
-  readonly id: string;
-}
-
-/** One object value of a predicate in an entity read. */
-export type PropertyValue =
-  | PropertyValueLiteral
-  | PropertyValueUri
-  | PropertyValueBlank;
-
-/** All object values asserted for a single predicate. */
-export interface PropertyGroup {
-  readonly predicate: string;
-  readonly values: PropertyValue[];
-}
-
-/** One classified subject in the graph index. */
-export interface GraphEntity {
-  readonly uri: string;
-  readonly prefixed: string;
-  readonly box: EntityBox;
-  readonly category: EntityCategory;
-  /** Compacted `rdf:type` values. */
-  readonly types: string[];
-  /** Compacted primary type used for grouping and naming (individuals). */
-  readonly primaryType: string | null;
-  /** Compacted primary type label, or the type's local name. */
-  readonly primaryTypeLabel: string | null;
-  readonly label: string | null;
-  readonly description: string | null;
-}
-
-/** The in-memory index of all named-node subjects, built via bulk queries. */
-export interface GraphIndex {
-  readonly entities: GraphEntity[];
-  /** Full URI → resolved label, for cheap type-label and object-label joins. */
-  readonly labelByUri: ReadonlyMap<string, string>;
-  /** Full URI → count of subjects declaring it as an `rdf:type`. */
-  readonly instanceCountByType: ReadonlyMap<string, number>;
-}
-
-/** MCP resource annotations we emit (schema-valid subset). */
-export interface ResourceAnnotations {
-  readonly audience: ("assistant" | "user")[];
-  readonly priority: number;
-}
-
-/** A single resource entry returned from the `list` callback. */
-export interface ListedResource {
-  readonly uri: string;
-  readonly name: string;
-  readonly description?: string;
-  readonly mimeType: "application/json";
-  readonly annotations: ResourceAnnotations;
-  readonly _meta: Record<string, unknown>;
-}
-
-/** How many individuals a listing dropped, per capped class. */
-export interface ListingTruncation {
-  readonly totalDropped: number;
-  readonly droppedByType: ReadonlyMap<string, number>;
-}
-
-/** Result of building a resource listing from the graph index. */
-export interface ResourceListing {
-  readonly resources: ListedResource[];
-  readonly truncation: ListingTruncation;
-}
-
-/** A candidate for URI autocomplete: its compacted form and human label. */
-export interface UriCompletionCandidate {
-  readonly prefixed: string;
-  readonly label: string | null;
-}
-
-/** A read entity payload, shaped by its box. */
-export interface ResourceEntity {
-  readonly uri: string;
-  readonly prefixed: string;
-  readonly box: EntityBox;
-  readonly category: EntityCategory;
-  readonly types: string[];
-  readonly label: string | null;
-  readonly description: string | null;
-  readonly properties: PropertyGroup[];
-  /** Class read: compacted superclasses. */
-  readonly superClasses?: string[];
-  /** Class read: compacted direct subclasses. */
-  readonly subClasses?: string[];
-  /** Class read: number of asserted individuals. */
-  readonly instanceCount?: number;
-  /** Class read: compacted properties declaring this class as their domain. */
-  readonly declaredProperties?: string[];
-  /** Individual read: compacted primary class this individual belongs to. */
-  readonly instanceOf?: string | null;
-}