@canonical/pragma-cli 0.31.0 → 0.33.0

package/src/mcp/resources/buildGraphIndex.ts

@@ -1,167 +0,0 @@
-import type { Store } from "@canonical/ke";
-import findNamespace from "../../domains/ontology/helpers/findNamespace.js";
-import { buildQuery } from "../../domains/shared/buildQuery.js";
-import compactUri from "../../domains/shared/compactUri.js";
-import extractLocalName from "../../domains/shared/extractLocalName.js";
-import classifyEntity from "./classifyEntity.js";
-import { RDF_TYPE } from "./constants.js";
-import {
-  collectDescriptionPredicates,
-  collectLabelPredicates,
-  resolveDescriptionPredicates,
-  resolveLabelPredicates,
-} from "./displayPredicates.js";
-import pickFirstValue from "./pickFirstValue.js";
-import pickPrimaryType from "./pickPrimaryType.js";
-import type { GraphEntity, GraphIndex } from "./types.js";
-
-/** A per-subject map of predicate URI → asserted lexical values. */
-type ValuesBySubject = Map<string, Map<string, string[]>>;
-
-/** Wrap full URIs as a SPARQL `VALUES` list body. */
-function toValuesList(uris: readonly string[]): string {
-  return [...new Set(uris)].map((uri) => `<${uri}>`).join(" ");
-}
-
-/**
- * Run one `?s ?p ?v` bulk query restricted to the given predicates and
- * collect values per named-node subject. Blank-node subjects are skipped —
- * they are never listed as resources.
- *
- * @note Queries ke store
- */
-async function fetchValuesBySubject(
-  store: Store,
-  predicates: readonly string[],
-): Promise<ValuesBySubject> {
-  const bySubject: ValuesBySubject = new Map();
-  if (predicates.length === 0) return bySubject;
-
-  const result = await store.query(
-    buildQuery(
-      `SELECT ?s ?p ?v WHERE { ?s ?p ?v . VALUES ?p { ${toValuesList(predicates)} } }`,
-    ),
-  );
-  if (result.type !== "select") return bySubject;
-
-  for (const term of result.termBindings) {
-    if (term.s?.termType !== "NamedNode") continue;
-    const subject = term.s.value;
-    const predicate = term.p?.value ?? "";
-    const value = term.v?.value ?? "";
-    const byPredicate = bySubject.get(subject) ?? new Map<string, string[]>();
-    const values = byPredicate.get(predicate) ?? [];
-    values.push(value);
-    byPredicate.set(predicate, values);
-    bySubject.set(subject, byPredicate);
-  }
-  return bySubject;
-}
-
-/**
- * Build the in-memory graph index used by listing, autocomplete, and reads.
- *
- * Replaces the former per-subject label/type/description queries with three
- * bulk queries — one for types, one for labels, one for descriptions — joined
- * in memory. Only typed named-node subjects are indexed; untyped subjects and
- * blank nodes are reachable via `graph_query` but are not listed as resources.
- *
- * @param store - The ke store to query.
- * @param prefixes - The store's merged prefix map.
- * @returns The classified entities plus label and instance-count lookups.
- *
- * @note Queries ke store
- */
-export default async function buildGraphIndex(
-  store: Store,
-  prefixes: Readonly<Record<string, string>>,
-): Promise<GraphIndex> {
-  const prefixEntries = Object.entries(prefixes);
-
-  const [typesResult, labelValues, descriptionValues] = await Promise.all([
-    store.query(buildQuery(`SELECT ?s ?type WHERE { ?s <${RDF_TYPE}> ?type }`)),
-    fetchValuesBySubject(store, collectLabelPredicates()),
-    fetchValuesBySubject(store, collectDescriptionPredicates()),
-  ]);
-
-  const typesBySubject = new Map<string, string[]>();
-  const instanceCountByType = new Map<string, number>();
-  if (typesResult.type === "select") {
-    for (const term of typesResult.termBindings) {
-      if (term.s?.termType !== "NamedNode") continue;
-      const subject = term.s.value;
-      const typeUri = term.type?.value ?? "";
-      const types = typesBySubject.get(subject) ?? [];
-      types.push(typeUri);
-      typesBySubject.set(subject, types);
-      instanceCountByType.set(
-        typeUri,
-        (instanceCountByType.get(typeUri) ?? 0) + 1,
-      );
-    }
-  }
-
-  // Phase 1: resolve every subject's label and description so that a class
-  // label is available before any individual that references it is built.
-  interface ResolvedSubject {
-    readonly subject: string;
-    readonly fullTypes: string[];
-    readonly box: GraphEntity["box"];
-    readonly category: GraphEntity["category"];
-    readonly label: string | null;
-    readonly description: string | null;
-  }
-
-  const labelByUri = new Map<string, string>();
-  const resolved: ResolvedSubject[] = [];
-
-  for (const [subject, fullTypes] of typesBySubject) {
-    const classification = classifyEntity(fullTypes);
-    if (classification === null) continue;
-
-    const prefix = findNamespace(subject, prefixEntries)?.prefix;
-    const label = pickFirstValue(
-      labelValues.get(subject) ?? new Map(),
-      resolveLabelPredicates(prefix),
-    );
-    const description = pickFirstValue(
-      descriptionValues.get(subject) ?? new Map(),
-      resolveDescriptionPredicates(prefix),
-    );
-    if (label !== null) labelByUri.set(subject, label);
-
-    resolved.push({
-      subject,
-      fullTypes,
-      box: classification.box,
-      category: classification.category,
-      label,
-      description,
-    });
-  }
-
-  // Phase 2: build entities, resolving each individual's grouping label from
-  // the now-complete label lookup.
-  const entities: GraphEntity[] = resolved.map((r) => {
-    const primaryTypeFull =
-      r.category === "individual" ? pickPrimaryType(r.fullTypes) : null;
-    return {
-      uri: r.subject,
-      prefixed: compactUri(r.subject, prefixes),
-      box: r.box,
-      category: r.category,
-      types: r.fullTypes.map((t) => compactUri(t, prefixes)),
-      primaryType:
-        primaryTypeFull === null ? null : compactUri(primaryTypeFull, prefixes),
-      primaryTypeLabel:
-        primaryTypeFull === null
-          ? null
-          : (labelByUri.get(primaryTypeFull) ??
-            extractLocalName(primaryTypeFull)),
-      label: r.label,
-      description: r.description,
-    };
-  });
-
-  return { entities, labelByUri, instanceCountByType };
-}

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

@@ -1,97 +0,0 @@
-import { describe, expect, it } from "vitest";
-import buildResourceList from "./buildResourceList.js";
-import { ABOX_PER_CLASS_LIMIT } from "./constants.js";
-import type { GraphEntity, GraphIndex } from "./types.js";
-
-const gadgetClass: GraphEntity = {
-  uri: "https://ds.canonical.com/Gadget",
-  prefixed: "ds:Gadget",
-  box: "tbox",
-  category: "class",
-  types: ["owl:Class"],
-  primaryType: null,
-  primaryTypeLabel: null,
-  label: "Gadget",
-  description: null,
-};
-
-const nameProperty: GraphEntity = {
-  uri: "https://ds.canonical.com/name",
-  prefixed: "ds:name",
-  box: "tbox",
-  category: "property",
-  types: ["owl:DatatypeProperty"],
-  primaryType: null,
-  primaryTypeLabel: null,
-  label: null,
-  description: null,
-};
-
-function makeIndividual(n: number): GraphEntity {
-  return {
-    uri: `https://ds.canonical.com/w${n}`,
-    prefixed: `ds:w${n}`,
-    box: "abox",
-    category: "individual",
-    types: ["ds:Gadget"],
-    primaryType: "ds:Gadget",
-    primaryTypeLabel: "Gadget",
-    label: `Widget ${n}`,
-    description: null,
-  };
-}
-
-function makeIndex(entities: GraphEntity[]): GraphIndex {
-  return { entities, labelByUri: new Map(), instanceCountByType: new Map() };
-}
-
-function boxOf(resource: { _meta: Record<string, unknown> }): unknown {
-  return resource._meta["pragma/box"];
-}
-
-describe("buildResourceList", () => {
-  it("orders all TBox schema before any ABox individual", () => {
-    const index = makeIndex([makeIndividual(0), nameProperty, gadgetClass]);
-    const boxes = buildResourceList(index).resources.map(boxOf);
-    expect(boxes.slice(0, 2)).toEqual(["tbox", "tbox"]);
-    expect(boxes.at(-1)).toBe("abox");
-  });
-
-  it("caps individuals per class and records the dropped remainder", () => {
-    const overflow = ABOX_PER_CLASS_LIMIT + 7;
-    const individuals = Array.from({ length: overflow }, (_, i) =>
-      makeIndividual(i),
-    );
-    const { resources, truncation } = buildResourceList(
-      makeIndex([gadgetClass, ...individuals]),
-    );
-
-    const shown = resources.filter((r) => boxOf(r) === "abox");
-    expect(shown).toHaveLength(ABOX_PER_CLASS_LIMIT);
-    expect(truncation.totalDropped).toBe(7);
-    expect(truncation.droppedByType.get("ds:Gadget")).toBe(7);
-
-    const cls = resources.find((r) => r.uri === "ds:Gadget");
-    expect(cls?._meta["pragma/instanceCount"]).toBe(overflow);
-    expect(cls?._meta["pragma/instancesShown"]).toBe(ABOX_PER_CLASS_LIMIT);
-    expect(cls?._meta["pragma/truncated"]).toBe(true);
-  });
-
-  it("reports no truncation when under the cap", () => {
-    const { truncation } = buildResourceList(
-      makeIndex([gadgetClass, makeIndividual(0)]),
-    );
-    expect(truncation.totalDropped).toBe(0);
-  });
-
-  it("assigns higher annotation priority to classes than individuals", () => {
-    const { resources } = buildResourceList(
-      makeIndex([gadgetClass, makeIndividual(0)]),
-    );
-    const cls = resources.find((r) => r.uri === "ds:Gadget");
-    const individual = resources.find((r) => r.uri === "ds:w0");
-    expect(cls?.annotations.priority).toBeGreaterThan(
-      individual?.annotations.priority ?? 1,
-    );
-  });
-});

package/src/mcp/resources/buildResourceList.ts

@@ -1,176 +0,0 @@
-import extractLocalName from "../../domains/shared/extractLocalName.js";
-import {
-  ABOX_PER_CLASS_LIMIT,
-  ABOX_TOTAL_LIMIT,
-  CLASS_PRIORITY,
-  INDIVIDUAL_PRIORITY,
-  NAME_SEPARATOR,
-  PROPERTY_PRIORITY,
-  RESOURCE_META_KEYS,
-} from "./constants.js";
-import type {
-  GraphEntity,
-  GraphIndex,
-  ListedResource,
-  ResourceListing,
-} from "./types.js";
-
-/** Longest description surfaced in a listing entry before truncation. */
-const DESCRIPTION_MAX = 120;
-
-/** Human-facing display name for an entity: its label, else its local name. */
-function toDisplayName(entity: GraphEntity): string {
-  return entity.label ?? extractLocalName(entity.uri);
-}
-
-/** Truncate a description to a listing-friendly length. */
-function toShortDescription(text: string): string {
-  return text.length > DESCRIPTION_MAX
-    ? `${text.slice(0, DESCRIPTION_MAX - 3)}...`
-    : text;
-}
-
-/** Sort entities by display name for stable, legible ordering. */
-function byDisplayName(a: GraphEntity, b: GraphEntity): number {
-  return toDisplayName(a).localeCompare(toDisplayName(b));
-}
-
-/** Build the listing entry for a TBox class, carrying its individual counts. */
-function toClassResource(
-  entity: GraphEntity,
-  instanceCount: number,
-  instancesShown: number,
-): ListedResource {
-  const truncated = instancesShown < instanceCount;
-  const description = truncated
-    ? `Schema class · showing ${instancesShown} of ${instanceCount} individuals; use autocomplete or graph_query for the rest`
-    : `Schema class · ${instanceCount} individual${instanceCount === 1 ? "" : "s"}`;
-  return {
-    uri: entity.prefixed,
-    name: `Class${NAME_SEPARATOR}${toDisplayName(entity)}`,
-    description,
-    mimeType: "application/json",
-    annotations: { audience: ["assistant"], priority: CLASS_PRIORITY },
-    _meta: {
-      [RESOURCE_META_KEYS.box]: "tbox",
-      [RESOURCE_META_KEYS.category]: "class",
-      [RESOURCE_META_KEYS.instanceCount]: instanceCount,
-      [RESOURCE_META_KEYS.instancesShown]: instancesShown,
-      [RESOURCE_META_KEYS.truncated]: truncated,
-    },
-  };
-}
-
-/** Build the listing entry for a TBox property. */
-function toPropertyResource(entity: GraphEntity): ListedResource {
-  const construct = entity.types.find((t) => t.endsWith("Property"));
-  const description = construct
-    ? `Schema property · ${construct}`
-    : "Schema property";
-  return {
-    uri: entity.prefixed,
-    name: `Property${NAME_SEPARATOR}${toDisplayName(entity)}`,
-    description,
-    mimeType: "application/json",
-    annotations: { audience: ["assistant"], priority: PROPERTY_PRIORITY },
-    _meta: {
-      [RESOURCE_META_KEYS.box]: "tbox",
-      [RESOURCE_META_KEYS.category]: "property",
-    },
-  };
-}
-
-/** Build the listing entry for an ABox individual, grouped under its class. */
-function toIndividualResource(entity: GraphEntity): ListedResource {
-  const group = entity.primaryTypeLabel ?? "Individual";
-  const summary = entity.description
-    ? toShortDescription(entity.description)
-    : null;
-  const description = summary ? `${group}${NAME_SEPARATOR}${summary}` : group;
-  return {
-    uri: entity.prefixed,
-    name: `${group}${NAME_SEPARATOR}${toDisplayName(entity)}`,
-    description,
-    mimeType: "application/json",
-    annotations: { audience: ["assistant"], priority: INDIVIDUAL_PRIORITY },
-    _meta: {
-      [RESOURCE_META_KEYS.box]: "abox",
-      [RESOURCE_META_KEYS.category]: "individual",
-      [RESOURCE_META_KEYS.type]: entity.primaryType ?? null,
-    },
-  };
-}
-
-/**
- * Build the ordered, categorized, capped MCP resource listing from the index.
- *
- * TBox schema comes first and in full (classes, then properties) so a consumer
- * sees the schema without scrolling past every instance. ABox individuals
- * follow, grouped by class and sorted, capped per class ({@link
- * ABOX_PER_CLASS_LIMIT}) and overall ({@link ABOX_TOTAL_LIMIT}). Dropped
- * individuals are reported in the returned {@link ResourceListing.truncation}
- * and reflected in each class entry's count metadata — never silently lost.
- *
- * @param index - The graph index of classified subjects.
- * @returns The resource entries and a summary of any capping.
- */
-export default function buildResourceList(index: GraphIndex): ResourceListing {
-  const classes = index.entities
-    .filter((e) => e.category === "class")
-    .sort(byDisplayName);
-  const properties = index.entities
-    .filter((e) => e.category === "property")
-    .sort(byDisplayName);
-  const individuals = index.entities.filter((e) => e.category === "individual");
-
-  const groups = new Map<string, GraphEntity[]>();
-  for (const individual of individuals) {
-    const key = individual.primaryType ?? "";
-    const bucket = groups.get(key) ?? [];
-    bucket.push(individual);
-    groups.set(key, bucket);
-  }
-
-  const orderedKeys = [...groups.keys()].sort((a, b) => a.localeCompare(b));
-  const shownByType = new Map<string, number>();
-  const droppedByType = new Map<string, number>();
-  const individualResources: ListedResource[] = [];
-  let totalShown = 0;
-
-  for (const key of orderedKeys) {
-    const bucket = (groups.get(key) ?? []).sort(byDisplayName);
-    let groupShown = 0;
-    for (const individual of bucket) {
-      const atGlobalCap = totalShown >= ABOX_TOTAL_LIMIT;
-      const atClassCap = groupShown >= ABOX_PER_CLASS_LIMIT;
-      if (atGlobalCap || atClassCap) {
-        droppedByType.set(key, (droppedByType.get(key) ?? 0) + 1);
-        continue;
-      }
-      individualResources.push(toIndividualResource(individual));
-      groupShown += 1;
-      totalShown += 1;
-    }
-    shownByType.set(key, groupShown);
-  }
-
-  const classResources = classes.map((entity) =>
-    toClassResource(
-      entity,
-      (shownByType.get(entity.prefixed) ?? 0) +
-        (droppedByType.get(entity.prefixed) ?? 0),
-      shownByType.get(entity.prefixed) ?? 0,
-    ),
-  );
-
-  const totalDropped = [...droppedByType.values()].reduce((a, b) => a + b, 0);
-
-  return {
-    resources: [
-      ...classResources,
-      ...properties.map(toPropertyResource),
-      ...individualResources,
-    ],
-    truncation: { totalDropped, droppedByType },
-  };
-}

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

@@ -1,40 +0,0 @@
-import { describe, expect, it } from "vitest";
-import classifyEntity from "./classifyEntity.js";
-
-const OWL_CLASS = "http://www.w3.org/2002/07/owl#Class";
-const OWL_OBJECT_PROPERTY = "http://www.w3.org/2002/07/owl#ObjectProperty";
-const DS_COMPONENT = "https://ds.canonical.com/Component";
-
-describe("classifyEntity", () => {
-  it("classifies owl:Class as tbox/class", () => {
-    expect(classifyEntity([OWL_CLASS])).toEqual({
-      box: "tbox",
-      category: "class",
-    });
-  });
-
-  it("classifies a property construct as tbox/property", () => {
-    expect(classifyEntity([OWL_OBJECT_PROPERTY])).toEqual({
-      box: "tbox",
-      category: "property",
-    });
-  });
-
-  it("classifies a domain-typed subject as abox/individual", () => {
-    expect(classifyEntity([DS_COMPONENT])).toEqual({
-      box: "abox",
-      category: "individual",
-    });
-  });
-
-  it("prefers schema when a subject is punned as both class and instance", () => {
-    expect(classifyEntity([DS_COMPONENT, OWL_CLASS])).toEqual({
-      box: "tbox",
-      category: "class",
-    });
-  });
-
-  it("returns null for an untyped subject", () => {
-    expect(classifyEntity([])).toBeNull();
-  });
-});

package/src/mcp/resources/classifyEntity.ts

@@ -1,27 +0,0 @@
-import { CLASS_TYPE_URIS, PROPERTY_TYPE_URIS } from "./constants.js";
-import type { EntityBox, EntityCategory } from "./types.js";
-
-/**
- * Classify a subject into its box and category from its `rdf:type` values.
- *
- * Schema constructs win over instance-hood: a subject typed as both a class
- * and something else is a class, so the schema is never buried among
- * individuals. A subject with any non-schema type is an individual; a subject
- * with no type at all returns `null` (the caller decides how to surface it).
- *
- * @param typeUris - Full `rdf:type` object URIs asserted for the subject.
- * @returns The box and category, or `null` when the subject has no type.
- */
-export default function classifyEntity(
-  typeUris: readonly string[],
-): { box: EntityBox; category: EntityCategory } | null {
-  const hasClassType = typeUris.some((t) => CLASS_TYPE_URIS.includes(t));
-  if (hasClassType) return { box: "tbox", category: "class" };
-
-  const hasPropertyType = typeUris.some((t) => PROPERTY_TYPE_URIS.includes(t));
-  if (hasPropertyType) return { box: "tbox", category: "property" };
-
-  if (typeUris.length > 0) return { box: "abox", category: "individual" };
-
-  return null;
-}

package/src/mcp/resources/constants.ts

@@ -1,105 +0,0 @@
-/**
- * Constants for the MCP resource surface.
- *
- * Collects the RDF/RDFS/OWL term URIs, the label/description fallback
- * chains that let foreign ontologies (no `PROPERTY_MAP` entry) still
- * resolve human names, the listing/completion caps, and the client-facing
- * annotation priorities and `_meta` keys used to distinguish TBox schema
- * from ABox individuals.
- */
-
-import { PREFIX_MAP } from "../../domains/shared/prefixes.js";
-
-const RDF_NS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
-const DCTERMS_NS = "http://purl.org/dc/terms/";
-const SCHEMA_NS = "http://schema.org/";
-
-/** `rdf:type` predicate URI. */
-export const RDF_TYPE = `${RDF_NS}type`;
-/** `rdfs:subClassOf` predicate URI. */
-export const RDFS_SUBCLASS_OF = `${PREFIX_MAP.rdfs}subClassOf`;
-/** `rdfs:domain` predicate URI. */
-export const RDFS_DOMAIN = `${PREFIX_MAP.rdfs}domain`;
-/** `rdfs:range` predicate URI. */
-export const RDFS_RANGE = `${PREFIX_MAP.rdfs}range`;
-
-/** Class-declaring `rdf:type` objects (TBox class constructs). */
-export const CLASS_TYPE_URIS: readonly string[] = [
-  `${PREFIX_MAP.owl}Class`,
-  `${PREFIX_MAP.rdfs}Class`,
-];
-
-/** Property-declaring `rdf:type` objects (TBox property constructs). */
-export const PROPERTY_TYPE_URIS: readonly string[] = [
-  `${PREFIX_MAP.owl}ObjectProperty`,
-  `${PREFIX_MAP.owl}DatatypeProperty`,
-  `${PREFIX_MAP.owl}AnnotationProperty`,
-  `${RDF_NS}Property`,
-];
-
-/**
- * `rdf:type` objects that never make a meaningful grouping or `instanceOf`
- * pointer for an individual: the schema-construct meta-types plus the
- * top/individual meta-types (`owl:NamedIndividual`, `owl:Thing`,
- * `rdfs:Resource`). An individual typed `[ds:Component, owl:NamedIndividual]`
- * must group under `ds:Component`, so these are filtered out before a
- * primary type is chosen.
- */
-export const NON_GROUPING_TYPE_URIS: readonly string[] = [
-  ...CLASS_TYPE_URIS,
-  ...PROPERTY_TYPE_URIS,
-  `${PREFIX_MAP.owl}NamedIndividual`,
-  `${PREFIX_MAP.owl}Thing`,
-  `${PREFIX_MAP.rdfs}Resource`,
-];
-
-/**
- * Generic label predicates tried after a namespace's `PROPERTY_MAP` label,
- * in priority order. Lets foreign ontologies resolve a name.
- */
-export const LABEL_FALLBACK_URIS: readonly string[] = [
-  `${PREFIX_MAP.rdfs}label`,
-  `${PREFIX_MAP.skos}prefLabel`,
-  `${DCTERMS_NS}title`,
-  `${SCHEMA_NS}name`,
-];
-
-/**
- * Generic description predicates tried after a namespace's `PROPERTY_MAP`
- * description, in priority order.
- */
-export const DESCRIPTION_FALLBACK_URIS: readonly string[] = [
-  `${PREFIX_MAP.rdfs}comment`,
-  `${DCTERMS_NS}description`,
-  `${SCHEMA_NS}description`,
-  `${PREFIX_MAP.skos}definition`,
-];
-
-/** Maximum individuals listed per class before the remainder is capped. */
-export const ABOX_PER_CLASS_LIMIT = 25;
-
-/** Hard ceiling on total individuals across all classes in one listing. */
-export const ABOX_TOTAL_LIMIT = 300;
-
-/** Maximum ranked suggestions returned from URI autocomplete. */
-export const COMPLETION_LIMIT = 50;
-
-/** Annotation `priority` for TBox classes (highest — schema first). */
-export const CLASS_PRIORITY = 1;
-/** Annotation `priority` for TBox properties. */
-export const PROPERTY_PRIORITY = 0.9;
-/** Annotation `priority` for ABox individuals (lowest). */
-export const INDIVIDUAL_PRIORITY = 0.5;
-
-/** Separator between the category tag and the entity label in resource names. */
-export const NAME_SEPARATOR = " · ";
-
-/** Namespaced `_meta` keys carrying structured box/category metadata. */
-export const RESOURCE_META_KEYS = {
-  box: "pragma/box",
-  category: "pragma/category",
-  type: "pragma/type",
-  instanceCount: "pragma/instanceCount",
-  instancesShown: "pragma/instancesShown",
-  truncated: "pragma/truncated",
-} as const;

package/src/mcp/resources/displayPredicates.ts

@@ -1,62 +0,0 @@
-/**
- * Label and description predicate chains for display-value resolution.
- *
- * Two concerns share this file because they are one policy: how a subject's
- * human name and blurb are found. `resolve*` builds the per-subject priority
- * order (namespace-specific `PROPERTY_MAP` predicate first, then the generic
- * fallback chain); `collect*` builds the flat union used to bulk-query every
- * candidate predicate at once. Keeping them together keeps the fallback
- * ordering and the bulk query in lockstep.
- */
-
-import { PROPERTY_MAP } from "../../constants.js";
-import { DESCRIPTION_FALLBACK_URIS, LABEL_FALLBACK_URIS } from "./constants.js";
-
-/** Narrow away `undefined` while preserving the string type. */
-function isPresent(value: string | undefined): value is string {
-  return value !== undefined;
-}
-
-/**
- * Ordered label predicates for a subject: its namespace's `PROPERTY_MAP`
- * label first, then the generic chain so foreign namespaces still resolve.
- *
- * @param prefix - The subject's namespace prefix, or `undefined` if foreign.
- */
-export function resolveLabelPredicates(prefix: string | undefined): string[] {
-  const specific = prefix ? PROPERTY_MAP[prefix]?.label : undefined;
-  return [...new Set([specific, ...LABEL_FALLBACK_URIS].filter(isPresent))];
-}
-
-/**
- * Ordered description predicates for a subject: its namespace's `PROPERTY_MAP`
- * description then definition, then the generic chain.
- *
- * @param prefix - The subject's namespace prefix, or `undefined` if foreign.
- */
-export function resolveDescriptionPredicates(
-  prefix: string | undefined,
-): string[] {
-  const map = prefix ? PROPERTY_MAP[prefix] : undefined;
-  return [
-    ...new Set(
-      [map?.description, map?.definition, ...DESCRIPTION_FALLBACK_URIS].filter(
-        isPresent,
-      ),
-    ),
-  ];
-}
-
-/** Every label predicate any namespace might use, for one bulk query. */
-export function collectLabelPredicates(): string[] {
-  const fromMap = Object.values(PROPERTY_MAP).map((m) => m.label);
-  return [...new Set([...fromMap, ...LABEL_FALLBACK_URIS])];
-}
-
-/** Every description predicate any namespace might use, for one bulk query. */
-export function collectDescriptionPredicates(): string[] {
-  const fromMap = Object.values(PROPERTY_MAP).flatMap((m) =>
-    [m.description, m.definition].filter(isPresent),
-  );
-  return [...new Set([...fromMap, ...DESCRIPTION_FALLBACK_URIS])];
-}