@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Manifest-DQUMRBFr.d.mts

@@ -0,0 +1,98 @@
+import { w as Subject } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import { r as Vocabulary, t as Namespace } from "./Namespace-ClTUO_ya.mjs";
+import { l as RdfParseError } from "./Serialization-Df8iVauT.mjs";
+import * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+declare namespace Manifest_d_exports {
+  export { Entry, Manifest, fileReader, load, mf, parse, rdft, toPath };
+}
+/**
+ * The W3C test manifest vocabulary.
+ *
+ * @since 0.1.0
+ * @category vocabularies
+ */
+declare const mf: Vocabulary<"http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#", "name" | "entries" | "Manifest" | "include" | "action" | "result" | "assumedTestBase">;
+/**
+ * The RDF test vocabulary.
+ *
+ * @since 0.1.0
+ * @category vocabularies
+ */
+declare const rdft: Namespace<"http://www.w3.org/ns/rdftest#">;
+/**
+ * A single test entry.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Entry {
+  /** The test IRI (or blank node key). */
+  readonly id: string;
+  /** The test node itself, for reading further properties from `dataset`. */
+  readonly node: Subject;
+  /** The IRI of the test's `rdf:type`. */
+  readonly type: string;
+  /** The local name of the test type, e.g. `TestTurtleEval`. */
+  readonly kind: string;
+  /** `mf:name` (falls back to the local name of the test IRI). */
+  readonly name: string;
+  /** `rdfs:comment`, if any. */
+  readonly comment: Option.Option<string>;
+  /** The `mf:action` IRI, if the action is an IRI. */
+  readonly action: Option.Option<string>;
+  /** The `mf:result` IRI, if the result is an IRI. */
+  readonly result: Option.Option<string>;
+  /** The IRI of the manifest that lists this entry. */
+  readonly manifest: string;
+  /** The parsed manifest document. */
+  readonly dataset: Dataset;
+}
+/**
+ * A parsed manifest.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Manifest {
+  readonly iri: string;
+  readonly label: Option.Option<string>;
+  readonly assumedTestBase: Option.Option<string>;
+  readonly entries: ReadonlyArray<Entry>;
+  readonly includes: ReadonlyArray<string>;
+  readonly dataset: Dataset;
+}
+/**
+ * Parses a manifest document. `iri` is the manifest's own IRI, used as the
+ * base IRI.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parse: (text: string, iri: string) => Effect.Effect<Manifest, RdfParseError>;
+/**
+ * Loads a manifest and, recursively, every manifest it includes, returning
+ * all entries (each manifest is read at most once).
+ *
+ * @since 0.1.0
+ * @category loading
+ */
+declare const load: <E, R>(iri: string, read: (iri: string) => Effect.Effect<string, E, R>) => Effect.Effect<ReadonlyArray<Entry>, E | RdfParseError, R>;
+/**
+ * Builds a `read` function for `load` that maps IRIs under `iriPrefix` to
+ * paths under `pathPrefix` and reads them with `readFile`.
+ *
+ * @since 0.1.0
+ * @category loading
+ */
+declare const fileReader: <E, R>(iriPrefix: string, pathPrefix: string, readFile: (path: string) => Effect.Effect<string, E, R>) => (iri: string) => Effect.Effect<string, E, R>;
+/**
+ * Maps an IRI under `iriPrefix` to a path under `pathPrefix`.
+ *
+ * @since 0.1.0
+ * @category loading
+ */
+declare const toPath: (iri: string, iriPrefix: string, pathPrefix: string) => string;
+export { load as a, rdft as c, fileReader as i, toPath as l, Manifest as n, mf as o, Manifest_d_exports as r, parse as s, Entry as t };
+//# sourceMappingURL=Manifest-DQUMRBFr.d.mts.map

package/dist/Mapping-BgG74x3U.d.mts

@@ -0,0 +1,63 @@
+import { _ as Quad } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import { i as Formula, r as Document } from "./Model-DaMmxurZ.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+declare namespace Mapping_d_exports {
+  export { ToDatasetOptions, UnrepresentableError, fromDataset, fromQuadsUnsafe, isRdfCompatible, toDataset, toQuadsUnsafe };
+}
+declare const UnrepresentableError_base: Schema.Class<UnrepresentableError, Schema.TaggedStruct<"N3UnrepresentableError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An N3 construct that has no representation in the target model (e.g. a
+ * variable in an RDF dataset, or an IRI-named graph in N3).
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+declare class UnrepresentableError extends UnrepresentableError_base {}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface ToDatasetOptions {
+  /** Prefix for the labels of blank nodes generated for formulas and lists. */
+  readonly blankNodePrefix?: string | undefined;
+}
+/**
+ * Converts a formula (or document) to quads, failing with
+ * `UnrepresentableError` for constructs that are not RDF. Throws the
+ * internal failure; used by `toDataset` and the parser.
+ *
+ * @internal
+ */
+declare const toQuadsUnsafe: (self: Formula, options?: ToDatasetOptions) => Array<Quad>;
+/**
+ * Converts an N3 formula or document to a core RDF `Dataset` (see the
+ * module documentation for the mapping).
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const toDataset: (self: Formula | Document, options?: ToDatasetOptions) => Effect.Effect<Dataset, UnrepresentableError>;
+/**
+ * Whether a formula is in the RDF-compatible subset of N3 (no variables, no
+ * literal subjects, only IRI predicates).
+ *
+ * @since 0.1.0
+ * @category predicates
+ */
+declare const isRdfCompatible: (self: Formula) => boolean;
+/** @internal */
+declare const fromQuadsUnsafe: (quads: Iterable<Quad>) => Formula;
+/**
+ * Converts RDF quads to an N3 formula (see the module documentation for the
+ * mapping). Statements are sorted for deterministic output.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const fromDataset: (quads: Iterable<Quad>) => Effect.Effect<Formula, UnrepresentableError>;
+export { fromQuadsUnsafe as a, toQuadsUnsafe as c, fromDataset as i, ToDatasetOptions as n, isRdfCompatible as o, UnrepresentableError as r, toDataset as s, Mapping_d_exports as t };
+//# sourceMappingURL=Mapping-BgG74x3U.d.mts.map

package/dist/Mapping-Dc1ZGirk.mjs

@@ -0,0 +1,259 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { D as compareQuads, O as defaultGraph, d as Quad, t as BlankNode } from "./Term-CFLG1qu4.mjs";
+import { m as fromIterable } from "./Dataset-BlmlcI7J.mjs";
+import { i as rdf } from "./Vocab-DceKywpq.mjs";
+import { A as isTriple, D as isBlankNode, E as loop, O as isLiteral, d as blankNodes, j as isVariable, k as isNamedNode, r as Formula, s as Statement, t as Collection, v as isFormula } from "./Model-DlPzRYhF.mjs";
+import { a as record, i as increment, n as count, o as single, r as followList, t as append } from "./lists-D-OpQ0Ir.mjs";
+import * as Arr from "effect/Array";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+// src/n3/Mapping.ts
+/**
+* Mapping between the N3 model and core RDF datasets.
+*
+* ## N3 → RDF (`toDataset`)
+*
+* - Top-level statements become quads in the default graph.
+* - Every occurrence of a formula `{ … }` becomes a fresh blank node `_:g`
+*   used in place of the formula, and the formula's statements become quads
+*   in the named graph `_:g` (recursively for nested formulas).
+* - Collections become `rdf:first` / `rdf:rest` chains of fresh blank nodes
+*   (in the graph where the collection occurs); `()` is `rdf:nil`.
+* - IRIs, blank nodes and literals are kept as they are.
+*
+* Constructs with no RDF counterpart fail with `UnrepresentableError`:
+* variables anywhere, literals as subjects, and anything other than an IRI
+* as a predicate.
+*
+* ## RDF → N3 (`fromDataset`)
+*
+* The inverse mapping: a named graph whose name is a blank node that is also
+* used as a term (subject or object, in any graph) becomes a formula, which
+* replaces every occurrence of that blank node; well-formed `rdf:first` /
+* `rdf:rest` chains of blank nodes become collections. Graphs named by IRIs,
+* blank-node graphs that are never used as terms, cyclic graph references and
+* RDF 1.2 triple terms cannot be represented and fail with
+* `UnrepresentableError`.
+*
+* @since 0.1.0
+*/
+var Mapping_exports = /* @__PURE__ */ __exportAll({
+	UnrepresentableError: () => UnrepresentableError,
+	fromDataset: () => fromDataset,
+	fromQuadsUnsafe: () => fromQuadsUnsafe,
+	isRdfCompatible: () => isRdfCompatible,
+	toDataset: () => toDataset,
+	toQuadsUnsafe: () => toQuadsUnsafe
+});
+/**
+* An N3 construct that has no representation in the target model (e.g. a
+* variable in an RDF dataset, or an IRI-named graph in N3).
+*
+* @since 0.1.0
+* @category errors
+*/
+var UnrepresentableError = class extends Schema.TaggedError()("N3UnrepresentableError", { message: Schema.String }) {};
+var Failure = class {
+	message;
+	constructor(message) {
+		this.message = message;
+	}
+};
+const guard = (f) => Effect.suspend(() => Result.match(Result.try(f), {
+	onSuccess: Effect.succeed,
+	onFailure: (e) => e instanceof Failure ? Effect.fail(new UnrepresentableError({ message: e.message })) : Effect.die(e)
+}));
+const rdfTerm = (t, graph, conversion) => {
+	if (t instanceof Collection) {
+		const items = t.items;
+		if (!Arr.isReadonlyArrayNonEmpty(items)) return rdf.nil;
+		const nodes = Arr.map(items, () => conversion.fresh());
+		const head = nodes[0];
+		items.forEach((item, i) => {
+			const node = nodes[i] ?? head;
+			conversion.out.push(new Quad(node, rdf.first, rdfTerm(item, graph, conversion), graph));
+			conversion.out.push(new Quad(node, rdf.rest, nodes[i + 1] ?? rdf.nil, graph));
+		});
+		return head;
+	}
+	if (t instanceof Formula) {
+		const g = conversion.fresh();
+		conversion.statements(t, g);
+		return g;
+	}
+	if (isVariable(t)) throw new Failure(`Variable ${t.key} cannot be represented in RDF`);
+	return t;
+};
+/**
+* Converts a formula (or document) to quads, failing with
+* `UnrepresentableError` for constructs that are not RDF. Throws the
+* internal failure; used by `toDataset` and the parser.
+*
+* @internal
+*/
+const toQuadsUnsafe = (self, options) => {
+	const prefix = options?.blankNodePrefix ?? "";
+	const reserved = MutableHashSet.fromIterable(blankNodes(self).map((b) => b.value));
+	let counter = 0;
+	let label = "";
+	const nextLabel = () => {
+		label = `${prefix}g${(counter++).toString(36)}`;
+		return MutableHashSet.has(reserved, label);
+	};
+	const fresh = () => {
+		loop(nextLabel);
+		return new BlankNode(label);
+	};
+	const out = [];
+	const conversion = {
+		fresh,
+		out,
+		statements: (f, g) => statements(f, g)
+	};
+	const term = (t, graph) => rdfTerm(t, graph, conversion);
+	const statements = (f, graph) => {
+		f.statements.forEach((s) => {
+			const subject = term(s.subject, graph);
+			const predicate = term(s.predicate, graph);
+			const object = term(s.object, graph);
+			if (isLiteral(subject)) throw new Failure(`Literal ${subject.key} cannot be the subject of an RDF triple`);
+			if (!isNamedNode(predicate)) throw new Failure(`${predicate.key} cannot be the predicate of an RDF triple`);
+			out.push(new Quad(subject, predicate, object, graph));
+		});
+	};
+	statements(self, defaultGraph);
+	return out;
+};
+/**
+* Converts an N3 formula or document to a core RDF `Dataset` (see the
+* module documentation for the mapping).
+*
+* @since 0.1.0
+* @category conversions
+*/
+const toDataset = (self, options) => guard(() => fromIterable(toQuadsUnsafe(isFormula(self) ? self : self.formula, options)));
+/**
+* Whether a formula is in the RDF-compatible subset of N3 (no variables, no
+* literal subjects, only IRI predicates).
+*
+* @since 0.1.0
+* @category predicates
+*/
+const isRdfCompatible = (self) => {
+	const result = Result.try(() => toQuadsUnsafe(self));
+	if (Result.isSuccess(result)) return true;
+	if (result.failure instanceof Failure) return false;
+	throw result.failure;
+};
+/** @internal */
+const fromQuadsUnsafe = (quads) => {
+	const all = Arr.sort(quads, compareQuads);
+	const graphs = MutableHashMap.empty();
+	const occurrences = MutableHashMap.empty();
+	const note = (t, graph) => {
+		if (isTriple(t)) throw new Failure(`Triple term ${t.key} cannot be represented in N3`);
+		if (!isBlankNode(t)) return;
+		let m = occurrences.backing.get(t.value);
+		if (m === void 0) {
+			m = MutableHashMap.empty();
+			MutableHashMap.set(occurrences, t.value, m);
+		}
+		increment(m, graph);
+	};
+	all.forEach((q) => {
+		const g = q.graph.key;
+		const graph = graphs.backing.get(g);
+		if (graph === void 0) MutableHashMap.set(graphs, g, {
+			name: q.graph,
+			quads: [q]
+		});
+		else graph.quads.push(q);
+		note(q.subject, g);
+		note(q.object, g);
+	});
+	const formulaGraphs = MutableHashSet.empty();
+	MutableHashMap.forEach(graphs, ({ name }, key) => {
+		if (key === "") return;
+		if (!isBlankNode(name) || !MutableHashMap.has(occurrences, name.value)) throw new Failure(`Named graph ${name.key} cannot be represented in N3: only graphs named by blank nodes that are used as terms map to formulas`);
+		MutableHashSet.add(formulaGraphs, name.value);
+	});
+	const formulas = MutableHashMap.empty();
+	const building = MutableHashSet.empty();
+	const buildGraph = (key) => {
+		const graphQuads = graphs.backing.get(key)?.quads ?? [];
+		const lists = foldLists(graphQuads, key);
+		const term = (t) => {
+			if (isTriple(t)) throw new Failure(`Triple term ${t.key} cannot be represented in N3`);
+			if (!isBlankNode(t)) return t;
+			const list = lists.heads.backing.get(t.value);
+			if (list !== void 0) return new Collection(list.map(term));
+			if (MutableHashSet.has(formulaGraphs, t.value)) return formulaOf(t.value);
+			return t;
+		};
+		return new Formula(graphQuads.filter((q) => !lists.consumed.has(q)).map((q) => new Statement(term(q.subject), q.predicate, term(q.object))));
+	};
+	const formulaOf = (label) => {
+		const cached = formulas.backing.get(label);
+		if (cached !== void 0) return cached;
+		if (MutableHashSet.has(building, label)) throw new Failure(`Graph _:${label} contains a reference to itself`);
+		MutableHashSet.add(building, label);
+		const f = buildGraph(`_:${label}`);
+		MutableHashSet.remove(building, label);
+		MutableHashMap.set(formulas, label, f);
+		return f;
+	};
+	const foldLists = (graphQuads, graphKey) => {
+		const first = MutableHashMap.empty();
+		const rest = MutableHashMap.empty();
+		const other = MutableHashMap.empty();
+		const asObject = MutableHashMap.empty();
+		const restTargets = MutableHashSet.empty();
+		graphQuads.forEach((q) => {
+			if (isBlankNode(q.subject)) {
+				const s = q.subject.value;
+				if (q.predicate.value === rdf.first.value) append(first, s, q);
+				else if (q.predicate.value === rdf.rest.value) append(rest, s, q);
+				else increment(other, s);
+			}
+			if (isBlankNode(q.object)) {
+				increment(asObject, q.object.value);
+				if (q.predicate.value === rdf.rest.value) MutableHashSet.add(restTargets, q.object.value);
+			}
+		});
+		const local = (label) => {
+			const occ = occurrences.backing.get(label);
+			return occ !== void 0 && MutableHashMap.size(occ) === 1 && MutableHashMap.has(occ, graphKey) && !MutableHashSet.has(formulaGraphs, label);
+		};
+		const cellOf = (label, isHead) => !local(label) || !isHead && (count(other, label) > 0 || count(asObject, label) !== 1) ? Option.none() : Option.zipWith(single(first, label), single(rest, label), (f, r) => [f, r]);
+		const heads = MutableHashMap.empty();
+		const consumed = /* @__PURE__ */ new WeakSet();
+		MutableHashMap.forEach(first, (_, label) => {
+			if (MutableHashSet.has(restTargets, label) || Option.isNone(cellOf(label, true))) return;
+			const otherCount = count(other, label);
+			const refs = count(asObject, label);
+			if (!(otherCount === 0 ? refs <= 1 : refs === 0)) return;
+			const cells = followList(label, cellOf);
+			if (Option.isSome(cells)) record(heads, consumed, label, cells.value);
+		});
+		return {
+			heads,
+			consumed
+		};
+	};
+	return buildGraph("");
+};
+/**
+* Converts RDF quads to an N3 formula (see the module documentation for the
+* mapping). Statements are sorted for deterministic output.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const fromDataset = (quads) => guard(() => fromQuadsUnsafe(quads));
+export { isRdfCompatible as a, fromQuadsUnsafe as i, UnrepresentableError as n, toDataset as o, fromDataset as r, toQuadsUnsafe as s, Mapping_exports as t };
+
+//# sourceMappingURL=Mapping-Dc1ZGirk.mjs.map

package/dist/Mapping-Dc1ZGirk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mapping-Dc1ZGirk.mjs","names":["Model.Collection","Term.Quad","Model.Formula","Guards.isVariable","Model.blankNodes","Term.BlankNode","Guards.isLiteral","Guards.isNamedNode","Term.defaultGraph","Dataset.fromIterable","Model.isFormula","Term.compareQuads","Guards.isTriple","Guards.isBlankNode","Model.Statement","Lists.count","Lists.single","Lists.followList"],"sources":["../src/n3/Mapping.ts"],"sourcesContent":["/**\n * Mapping between the N3 model and core RDF datasets.\n *\n * ## N3 → RDF (`toDataset`)\n *\n * - Top-level statements become quads in the default graph.\n * - Every occurrence of a formula `{ … }` becomes a fresh blank node `_:g`\n *   used in place of the formula, and the formula's statements become quads\n *   in the named graph `_:g` (recursively for nested formulas).\n * - Collections become `rdf:first` / `rdf:rest` chains of fresh blank nodes\n *   (in the graph where the collection occurs); `()` is `rdf:nil`.\n * - IRIs, blank nodes and literals are kept as they are.\n *\n * Constructs with no RDF counterpart fail with `UnrepresentableError`:\n * variables anywhere, literals as subjects, and anything other than an IRI\n * as a predicate.\n *\n * ## RDF → N3 (`fromDataset`)\n *\n * The inverse mapping: a named graph whose name is a blank node that is also\n * used as a term (subject or object, in any graph) becomes a formula, which\n * replaces every occurrence of that blank node; well-formed `rdf:first` /\n * `rdf:rest` chains of blank nodes become collections. Graphs named by IRIs,\n * blank-node graphs that are never used as terms, cyclic graph references and\n * RDF 1.2 triple terms cannot be represented and fail with\n * `UnrepresentableError`.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport * as MutableHashMap from 'effect/MutableHashMap';\nimport * as MutableHashSet from 'effect/MutableHashSet';\nimport * as Option from 'effect/Option';\nimport * as Result from 'effect/Result';\nimport * as Schema from 'effect/Schema';\nimport * as Dataset from '../Dataset.ts';\nimport * as Term from '../Term.ts';\nimport { rdf } from '../Vocab.ts';\nimport * as Guards from './internal/guards.ts';\nimport * as Lists from './internal/lists.ts';\nimport { loop } from './internal/loop.ts';\nimport * as Model from './Model.ts';\n\n/**\n * An N3 construct that has no representation in the target model (e.g. a\n * variable in an RDF dataset, or an IRI-named graph in N3).\n *\n * @since 0.1.0\n * @category errors\n */\nexport class UnrepresentableError extends Schema.TaggedError<UnrepresentableError>()(\n  'N3UnrepresentableError',\n  { message: Schema.String },\n) {}\n\nclass Failure {\n  readonly message: string;\n  constructor(message: string) {\n    this.message = message;\n  }\n}\n\nconst guard = <A>(f: () => A): Effect.Effect<A, UnrepresentableError> =>\n  Effect.suspend(() =>\n    Result.match(Result.try(f), {\n      onSuccess: Effect.succeed,\n      onFailure: (e) =>\n        e instanceof Failure\n          ? Effect.fail(new UnrepresentableError({ message: e.message }))\n          : Effect.die(e),\n    }),\n  );\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface ToDatasetOptions {\n  /** Prefix for the labels of blank nodes generated for formulas and lists. */\n  readonly blankNodePrefix?: string | undefined;\n}\n\n/** The state of one `toQuadsUnsafe` conversion, threaded through `rdfTerm`. */\ninterface Conversion {\n  readonly fresh: () => Term.BlankNode;\n  readonly out: Array<Term.Quad>;\n  readonly statements: (f: Model.Formula, graph: Term.Graph) => void;\n}\n\n// Plain refinements rather than `Match`: `toQuadsUnsafe` runs it for every term it converts.\nconst rdfTerm = (\n  t: Model.N3Term,\n  graph: Term.Graph,\n  conversion: Conversion,\n): Term.NamedNode | Term.BlankNode | Term.Literal => {\n  if (t instanceof Model.Collection) {\n    const items = t.items;\n    if (!Arr.isReadonlyArrayNonEmpty(items)) return rdf.nil;\n    const nodes = Arr.map(items, () => conversion.fresh());\n    const head = nodes[0];\n    items.forEach((item, i) => {\n      const node = nodes[i] ?? head;\n      conversion.out.push(new Term.Quad(node, rdf.first, rdfTerm(item, graph, conversion), graph));\n      conversion.out.push(new Term.Quad(node, rdf.rest, nodes[i + 1] ?? rdf.nil, graph));\n    });\n    return head;\n  }\n  if (t instanceof Model.Formula) {\n    const g = conversion.fresh();\n    conversion.statements(t, g);\n    return g;\n  }\n  if (Guards.isVariable(t)) throw new Failure(`Variable ${t.key} cannot be represented in RDF`);\n  return t;\n};\n\n/**\n * Converts a formula (or document) to quads, failing with\n * `UnrepresentableError` for constructs that are not RDF. Throws the\n * internal failure; used by `toDataset` and the parser.\n *\n * @internal\n */\nexport const toQuadsUnsafe = (\n  self: Model.Formula,\n  options?: ToDatasetOptions,\n): Array<Term.Quad> => {\n  const prefix = options?.blankNodePrefix ?? '';\n  const reserved = MutableHashSet.fromIterable(Model.blankNodes(self).map((b) => b.value));\n  let counter = 0;\n  let label = '';\n  const nextLabel = (): boolean => {\n    label = `${prefix}g${(counter++).toString(36)}`;\n    return MutableHashSet.has(reserved, label);\n  };\n  const fresh = (): Term.BlankNode => {\n    loop(nextLabel);\n    return new Term.BlankNode(label);\n  };\n  const out: Array<Term.Quad> = [];\n  const conversion: Conversion = { fresh, out, statements: (f, g) => statements(f, g) };\n  const term = (t: Model.N3Term, graph: Term.Graph) => rdfTerm(t, graph, conversion);\n  const statements = (f: Model.Formula, graph: Term.Graph) => {\n    f.statements.forEach((s) => {\n      const subject = term(s.subject, graph);\n      const predicate = term(s.predicate, graph);\n      const object = term(s.object, graph);\n      if (Guards.isLiteral(subject)) {\n        throw new Failure(`Literal ${subject.key} cannot be the subject of an RDF triple`);\n      }\n      if (!Guards.isNamedNode(predicate)) {\n        throw new Failure(`${predicate.key} cannot be the predicate of an RDF triple`);\n      }\n      out.push(new Term.Quad(subject, predicate, object, graph));\n    });\n  };\n  statements(self, Term.defaultGraph);\n  return out;\n};\n\n/**\n * Converts an N3 formula or document to a core RDF `Dataset` (see the\n * module documentation for the mapping).\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const toDataset = (\n  self: Model.Formula | Model.Document,\n  options?: ToDatasetOptions,\n): Effect.Effect<Dataset.Dataset, UnrepresentableError> =>\n  guard(() =>\n    Dataset.fromIterable(toQuadsUnsafe(Model.isFormula(self) ? self : self.formula, options)),\n  );\n\n/**\n * Whether a formula is in the RDF-compatible subset of N3 (no variables, no\n * literal subjects, only IRI predicates).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isRdfCompatible = (self: Model.Formula): boolean => {\n  const result = Result.try(() => toQuadsUnsafe(self));\n  if (Result.isSuccess(result)) return true;\n  if (result.failure instanceof Failure) return false;\n  throw result.failure;\n};\n\n// -----------------------------------------------------------------------------\n// RDF → N3\n// -----------------------------------------------------------------------------\n\n/** The quads of one graph, with its name. */\ninterface Graph {\n  readonly name: Term.Graph;\n  readonly quads: Array<Term.Quad>;\n}\n\n/** @internal */\nexport const fromQuadsUnsafe = (quads: Iterable<Term.Quad>): Model.Formula => {\n  const all = Arr.sort(quads, Term.compareQuads);\n  const graphs = MutableHashMap.empty<string, Graph>();\n  // Occurrences of blank nodes as subject/object, per graph and in total.\n  const occurrences = MutableHashMap.empty<string, MutableHashMap.MutableHashMap<string, number>>();\n  const note = (t: Term.Term, graph: string) => {\n    if (Guards.isTriple(t)) {\n      throw new Failure(`Triple term ${t.key} cannot be represented in N3`);\n    }\n    if (!Guards.isBlankNode(t)) return;\n    let m = occurrences.backing.get(t.value);\n    if (m === undefined) {\n      m = MutableHashMap.empty();\n      MutableHashMap.set(occurrences, t.value, m);\n    }\n    Lists.increment(m, graph);\n  };\n  all.forEach((q) => {\n    const g = q.graph.key;\n    const graph = graphs.backing.get(g);\n    if (graph === undefined) MutableHashMap.set(graphs, g, { name: q.graph, quads: [q] });\n    else graph.quads.push(q);\n    note(q.subject, g);\n    note(q.object, g);\n  });\n  const formulaGraphs = MutableHashSet.empty<string>();\n  MutableHashMap.forEach(graphs, ({ name }, key) => {\n    if (key === '') return;\n    if (!Guards.isBlankNode(name) || !MutableHashMap.has(occurrences, name.value)) {\n      throw new Failure(\n        `Named graph ${name.key} cannot be represented in N3: only graphs named by blank nodes that are used as terms map to formulas`,\n      );\n    }\n    MutableHashSet.add(formulaGraphs, name.value);\n  });\n\n  const formulas = MutableHashMap.empty<string, Model.Formula>();\n  const building = MutableHashSet.empty<string>();\n\n  const buildGraph = (key: string): Model.Formula => {\n    const graphQuads = graphs.backing.get(key)?.quads ?? [];\n    const lists = foldLists(graphQuads, key);\n    const term = (t: Term.Subject | Term.Object): Model.N3Term => {\n      // `note` has rejected triple terms\n      if (Guards.isTriple(t)) throw new Failure(`Triple term ${t.key} cannot be represented in N3`);\n      if (!Guards.isBlankNode(t)) return t;\n      const list = lists.heads.backing.get(t.value);\n      if (list !== undefined) return new Model.Collection(list.map(term));\n      if (MutableHashSet.has(formulaGraphs, t.value)) return formulaOf(t.value);\n      return t;\n    };\n    return new Model.Formula(\n      graphQuads\n        .filter((q) => !lists.consumed.has(q))\n        .map((q) => new Model.Statement(term(q.subject), q.predicate, term(q.object))),\n    );\n  };\n\n  const formulaOf = (label: string): Model.Formula => {\n    const cached = formulas.backing.get(label);\n    if (cached !== undefined) return cached;\n    if (MutableHashSet.has(building, label)) {\n      throw new Failure(`Graph _:${label} contains a reference to itself`);\n    }\n    MutableHashSet.add(building, label);\n    const f = buildGraph(`_:${label}`);\n    MutableHashSet.remove(building, label);\n    MutableHashMap.set(formulas, label, f);\n    return f;\n  };\n\n  const foldLists = (graphQuads: ReadonlyArray<Term.Quad>, graphKey: string) => {\n    const first = MutableHashMap.empty<string, Array<Term.Quad>>();\n    const rest = MutableHashMap.empty<string, Array<Term.Quad>>();\n    const other = MutableHashMap.empty<string, number>();\n    const asObject = MutableHashMap.empty<string, number>();\n    const restTargets = MutableHashSet.empty<string>();\n    graphQuads.forEach((q) => {\n      if (Guards.isBlankNode(q.subject)) {\n        const s = q.subject.value;\n        if (q.predicate.value === rdf.first.value) Lists.append(first, s, q);\n        else if (q.predicate.value === rdf.rest.value) Lists.append(rest, s, q);\n        else Lists.increment(other, s);\n      }\n      if (Guards.isBlankNode(q.object)) {\n        Lists.increment(asObject, q.object.value);\n        if (q.predicate.value === rdf.rest.value) MutableHashSet.add(restTargets, q.object.value);\n      }\n    });\n    const local = (label: string) => {\n      const occ = occurrences.backing.get(label);\n      return (\n        occ !== undefined &&\n        MutableHashMap.size(occ) === 1 &&\n        MutableHashMap.has(occ, graphKey) &&\n        !MutableHashSet.has(formulaGraphs, label)\n      );\n    };\n    // A cell: one `rdf:first` and one `rdf:rest`, in this graph only; after the head, referenced\n    // only by the list\n    const cellOf = (label: string, isHead: boolean): Option.Option<Lists.Cell<Term.Quad>> =>\n      !local(label) ||\n      (!isHead && (Lists.count(other, label) > 0 || Lists.count(asObject, label) !== 1))\n        ? Option.none()\n        : Option.zipWith(Lists.single(first, label), Lists.single(rest, label), (f, r) => [f, r]);\n    const heads = MutableHashMap.empty<string, Array<Term.Object>>();\n    const consumed = new WeakSet<Term.Quad>();\n    MutableHashMap.forEach(first, (_, label) => {\n      if (MutableHashSet.has(restTargets, label) || Option.isNone(cellOf(label, true))) return;\n      const otherCount = Lists.count(other, label);\n      const refs = Lists.count(asObject, label);\n      if (!(otherCount === 0 ? refs <= 1 : refs === 0)) return;\n      const cells = Lists.followList(label, cellOf);\n      if (Option.isSome(cells)) Lists.record(heads, consumed, label, cells.value);\n    });\n    return { heads, consumed };\n  };\n\n  return buildGraph('');\n};\n\n/**\n * Converts RDF quads to an N3 formula (see the module documentation for the\n * mapping). Statements are sorted for deterministic output.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const fromDataset = (\n  quads: Iterable<Term.Quad>,\n): Effect.Effect<Model.Formula, UnrepresentableError> => guard(() => fromQuadsUnsafe(quads));\n"],"mappings":"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"}

package/dist/Mcp-1DwTTKOK.mjs

@@ -0,0 +1,48 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { d as layerWithUpdate$1, f as toolkit, p as toolkitWithUpdate, u as layer$1 } from "./Tools-ryxphZbI.mjs";
+import * as Layer from "effect/Layer";
+import { McpServer } from "effect/ai";
+// src/sparql/ai/Mcp.ts
+/**
+* The knowledge-graph tools as an MCP (Model Context Protocol) server
+* registration: provide `Mcp.layer()` together with one of `effect/ai`'s
+* `McpServer` transports (`McpServer.layerStdio`, `McpServer.layerHttp`, …)
+* and a `SparqlEngine`, and any MCP client can call the tools.
+*
+* ```ts
+* import { Layer } from 'effect'
+* import { McpServer } from 'effect/ai'
+* import { Engine } from '@thomasfosterau/effect-rdf/sparql'
+* import { Mcp } from '@thomasfosterau/effect-rdf/sparql/ai'
+*
+* const Server = Mcp.layer({ maxRows: 50 }).pipe(
+*   Layer.provide(McpServer.layerStdio({ name: 'knowledge-graph', version: '1.0.0', protocols })),
+*   Layer.provide(Engine.layerMemory()),
+* )
+* ```
+*
+* @since 0.1.0
+*/
+var Mcp_exports = /* @__PURE__ */ __exportAll({
+	layer: () => layer,
+	layerWithUpdate: () => layerWithUpdate
+});
+/**
+* Registers the read-only `Tools.toolkit` with the `McpServer` in context,
+* with its handlers over the `SparqlEngine` in context.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layer = (options) => McpServer.toolkit(toolkit).pipe(Layer.provide(layer$1(options)));
+/**
+* Registers `Tools.toolkitWithUpdate` (the read-only tools plus
+* `sparql_update`) with the `McpServer` in context.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerWithUpdate = (options) => McpServer.toolkit(toolkitWithUpdate).pipe(Layer.provide(layerWithUpdate$1(options)));
+export { layer as n, layerWithUpdate as r, Mcp_exports as t };
+
+//# sourceMappingURL=Mcp-1DwTTKOK.mjs.map

package/dist/Mcp-1DwTTKOK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mcp-1DwTTKOK.mjs","names":["Tools.toolkit","Tools.layer","Tools.toolkitWithUpdate","Tools.layerWithUpdate"],"sources":["../src/sparql/ai/Mcp.ts"],"sourcesContent":["/**\n * The knowledge-graph tools as an MCP (Model Context Protocol) server\n * registration: provide `Mcp.layer()` together with one of `effect/ai`'s\n * `McpServer` transports (`McpServer.layerStdio`, `McpServer.layerHttp`, …)\n * and a `SparqlEngine`, and any MCP client can call the tools.\n *\n * ```ts\n * import { Layer } from 'effect'\n * import { McpServer } from 'effect/ai'\n * import { Engine } from '@thomasfosterau/effect-rdf/sparql'\n * import { Mcp } from '@thomasfosterau/effect-rdf/sparql/ai'\n *\n * const Server = Mcp.layer({ maxRows: 50 }).pipe(\n *   Layer.provide(McpServer.layerStdio({ name: 'knowledge-graph', version: '1.0.0', protocols })),\n *   Layer.provide(Engine.layerMemory()),\n * )\n * ```\n *\n * @since 0.1.0\n */\nimport * as Layer from 'effect/Layer';\nimport { McpServer } from 'effect/ai';\nimport * as Tools from './Tools.ts';\n\n/**\n * Registers the read-only `Tools.toolkit` with the `McpServer` in context,\n * with its handlers over the `SparqlEngine` in context.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layer = (options?: Tools.ToolOptions) =>\n  McpServer.toolkit(Tools.toolkit).pipe(Layer.provide(Tools.layer(options)));\n\n/**\n * Registers `Tools.toolkitWithUpdate` (the read-only tools plus\n * `sparql_update`) with the `McpServer` in context.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layerWithUpdate = (options?: Tools.ToolOptions) =>\n  McpServer.toolkit(Tools.toolkitWithUpdate).pipe(Layer.provide(Tools.layerWithUpdate(options)));\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,SAAS,YACpB,UAAU,QAAQA,OAAa,CAAC,CAAC,KAAK,MAAM,QAAQC,QAAY,OAAO,CAAC,CAAC;;;;;;;;AAS3E,MAAa,mBAAmB,YAC9B,UAAU,QAAQC,iBAAuB,CAAC,CAAC,KAAK,MAAM,QAAQC,kBAAsB,OAAO,CAAC,CAAC"}

package/dist/Mcp-d-pX9erx.d.mts

@@ -0,0 +1,25 @@
+import { o as SparqlEngine } from "./Engine-CYPB3g4h.mjs";
+import { c as ToolOptions } from "./Tools-7MdRKccr.mjs";
+import * as Layer from "effect/Layer";
+import { McpServer } from "effect/ai";
+declare namespace Mcp_d_exports {
+  export { layer, layerWithUpdate };
+}
+/**
+ * Registers the read-only `Tools.toolkit` with the `McpServer` in context,
+ * with its handlers over the `SparqlEngine` in context.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layer: (options?: ToolOptions) => Layer.Layer<never, never, SparqlEngine | McpServer.McpServer>;
+/**
+ * Registers `Tools.toolkitWithUpdate` (the read-only tools plus
+ * `sparql_update`) with the `McpServer` in context.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layerWithUpdate: (options?: ToolOptions) => Layer.Layer<never, never, SparqlEngine | McpServer.McpServer>;
+export { layer as n, layerWithUpdate as r, Mcp_d_exports as t };
+//# sourceMappingURL=Mcp-d-pX9erx.d.mts.map

package/dist/Message-CK_DGQuu.mjs

@@ -0,0 +1,95 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { o as Literal } from "./Term-CFLG1qu4.mjs";
+import * as Predicate from "effect/Predicate";
+import * as Match from "effect/Match";
+// src/shacl/Message.ts
+/**
+* Message templates: `sh:message` values (and `sh:labelTemplate`s) may refer
+* to variables with `{?name}` or `{$name}`, which are replaced with a string
+* representation of the variable's value when a validation result is
+* produced (SHACL §5.3.2 and §6.2.2).
+*
+* The validator substitutes:
+*
+* - for SPARQL-based constraints, the variables of the result solution
+*   (`this`, `value`, `path`, any other projected variable) and, for
+*   SPARQL-based constraint components, the parameter values;
+* - for core constraints, `this`, `value`, `path` and the parameters of the
+*   constraint component by their local names (`{$minCount}`,
+*   `{$datatype}`, `{$pattern}`, …).
+*
+* ```ts
+* import { Term } from "@thomasfosterau/effect-rdf"
+* import { Message } from "@thomasfosterau/effect-rdf/shacl"
+*
+* Message.substitute(Term.literal("Expected at least {$minCount} values"), (name) =>
+*   name === "minCount" ? Term.literal("2") : undefined,
+* ) // "Expected at least 2 values"
+* ```
+*
+* @since 0.1.0
+*/
+var Message_exports = /* @__PURE__ */ __exportAll({
+	display: () => display,
+	format: () => format,
+	localName: () => localName,
+	substitute: () => substitute,
+	variables: () => variables
+});
+const placeholder = /\{[?$]([\p{L}\p{N}_\p{M}]+)\}/gu;
+/**
+* A human-readable string for a term inside a message: the lexical form of
+* literals, the IRI of named nodes, `_:label` for blank nodes and the
+* N-Triples-like form of triple terms.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const display = (term) => {
+	return Match.value(term).pipe(Match.tag("Literal", "NamedNode", (node) => node.value), Match.tag("BlankNode", (node) => `_:${node.value}`), Match.orElse((node) => node.toString()));
+};
+/**
+* The variable names referenced by a template, in order of appearance.
+*
+* @since 0.1.0
+* @category queries
+*/
+const variables = (template) => Array.from(template.matchAll(placeholder), (m) => m[1] ?? "");
+/**
+* Replaces the `{?name}` / `{$name}` placeholders of a template string.
+* Placeholders whose variable `lookup` does not know are left unchanged.
+*
+* @since 0.1.0
+* @category substitution
+*/
+const format = (template, lookup) => template.replace(placeholder, (match, name) => {
+	const value = lookup(name);
+	return value === void 0 ? match : display(value);
+});
+/**
+* Substitutes the placeholders of a message literal, keeping its language
+* tag (or datatype).
+*
+* @since 0.1.0
+* @category substitution
+*/
+const substitute = (message, lookup) => {
+	const value = format(message.value, lookup);
+	return value === message.value ? message : new Literal(value, message.datatype, message.language, message.direction);
+};
+/**
+* The local name of an IRI: the longest NCName at its end (SHACL §6.2.1).
+* SPARQL-based constraint components derive their parameter names (and
+* thus the pre-bound variable names) this way. Returns an empty string when
+* the IRI does not end with an NCName.
+*
+* @since 0.1.0
+* @category utils
+*/
+const localName = (iri) => {
+	const value = Predicate.isString(iri) ? iri : iri.value;
+	return (/[\p{L}\p{N}\p{M}_.-]*$/u.exec(value)?.[0] ?? "").replace(/^[\p{N}\p{M}.-]+/u, "");
+};
+export { substitute as a, localName as i, display as n, variables as o, format as r, Message_exports as t };
+
+//# sourceMappingURL=Message-CK_DGQuu.mjs.map

package/dist/Message-CK_DGQuu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Message-CK_DGQuu.mjs","names":["Term.Literal"],"sources":["../src/shacl/Message.ts"],"sourcesContent":["/**\n * Message templates: `sh:message` values (and `sh:labelTemplate`s) may refer\n * to variables with `{?name}` or `{$name}`, which are replaced with a string\n * representation of the variable's value when a validation result is\n * produced (SHACL §5.3.2 and §6.2.2).\n *\n * The validator substitutes:\n *\n * - for SPARQL-based constraints, the variables of the result solution\n *   (`this`, `value`, `path`, any other projected variable) and, for\n *   SPARQL-based constraint components, the parameter values;\n * - for core constraints, `this`, `value`, `path` and the parameters of the\n *   constraint component by their local names (`{$minCount}`,\n *   `{$datatype}`, `{$pattern}`, …).\n *\n * ```ts\n * import { Term } from \"@thomasfosterau/effect-rdf\"\n * import { Message } from \"@thomasfosterau/effect-rdf/shacl\"\n *\n * Message.substitute(Term.literal(\"Expected at least {$minCount} values\"), (name) =>\n *   name === \"minCount\" ? Term.literal(\"2\") : undefined,\n * ) // \"Expected at least 2 values\"\n * ```\n *\n * @since 0.1.0\n */\nimport { Term } from '../index.ts';\nimport * as Match from 'effect/Match';\nimport * as Predicate from 'effect/Predicate';\n\nconst placeholder = /\\{[?$]([\\p{L}\\p{N}_\\p{M}]+)\\}/gu;\n\n/**\n * A human-readable string for a term inside a message: the lexical form of\n * literals, the IRI of named nodes, `_:label` for blank nodes and the\n * N-Triples-like form of triple terms.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const display = (term: Term.Term): string => {\n  return Match.value(term).pipe(\n    Match.tag('Literal', 'NamedNode', (node) => node.value),\n    Match.tag('BlankNode', (node) => `_:${node.value}`),\n    Match.orElse((node) => node.toString()),\n  );\n};\n\n/**\n * The variable names referenced by a template, in order of appearance.\n *\n * @since 0.1.0\n * @category queries\n */\nexport const variables = (template: string): ReadonlyArray<string> =>\n  Array.from(template.matchAll(placeholder), (m) => m[1] ?? '');\n\n/**\n * Replaces the `{?name}` / `{$name}` placeholders of a template string.\n * Placeholders whose variable `lookup` does not know are left unchanged.\n *\n * @since 0.1.0\n * @category substitution\n */\nexport const format = (template: string, lookup: (name: string) => Term.Term | undefined): string =>\n  template.replace(placeholder, (match, name: string) => {\n    const value = lookup(name);\n    return value === undefined ? match : display(value);\n  });\n\n/**\n * Substitutes the placeholders of a message literal, keeping its language\n * tag (or datatype).\n *\n * @since 0.1.0\n * @category substitution\n */\nexport const substitute = (\n  message: Term.Literal,\n  lookup: (name: string) => Term.Term | undefined,\n): Term.Literal => {\n  const value = format(message.value, lookup);\n  return value === message.value\n    ? message\n    : new Term.Literal(value, message.datatype, message.language, message.direction);\n};\n\n/**\n * The local name of an IRI: the longest NCName at its end (SHACL §6.2.1).\n * SPARQL-based constraint components derive their parameter names (and\n * thus the pre-bound variable names) this way. Returns an empty string when\n * the IRI does not end with an NCName.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const localName = (iri: Term.NamedNode | string): string => {\n  const value = Predicate.isString(iri) ? iri : iri.value;\n  const match = /[\\p{L}\\p{N}\\p{M}_.-]*$/u.exec(value);\n  // An NCName cannot start with a digit, `-` or `.`.\n  return (match?.[0] ?? '').replace(/^[\\p{N}\\p{M}.-]+/u, '');\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAM,cAAc;;;;;;;;;AAUpB,MAAa,WAAW,SAA4B;CAClD,OAAO,MAAM,MAAM,IAAI,CAAC,CAAC,KACvB,MAAM,IAAI,WAAW,cAAc,SAAS,KAAK,KAAK,GACtD,MAAM,IAAI,cAAc,SAAS,KAAK,KAAK,OAAO,GAClD,MAAM,QAAQ,SAAS,KAAK,SAAS,CAAC,CACxC;AACF;;;;;;;AAQA,MAAa,aAAa,aACxB,MAAM,KAAK,SAAS,SAAS,WAAW,IAAI,MAAM,EAAE,MAAM,EAAE;;;;;;;;AAS9D,MAAa,UAAU,UAAkB,WACvC,SAAS,QAAQ,cAAc,OAAO,SAAiB;CACrD,MAAM,QAAQ,OAAO,IAAI;CACzB,OAAO,UAAU,KAAA,IAAY,QAAQ,QAAQ,KAAK;AACpD,CAAC;;;;;;;;AASH,MAAa,cACX,SACA,WACiB;CACjB,MAAM,QAAQ,OAAO,QAAQ,OAAO,MAAM;CAC1C,OAAO,UAAU,QAAQ,QACrB,UACA,IAAIA,QAAa,OAAO,QAAQ,UAAU,QAAQ,UAAU,QAAQ,SAAS;AACnF;;;;;;;;;;AAWA,MAAa,aAAa,QAAyC;CACjE,MAAM,QAAQ,UAAU,SAAS,GAAG,IAAI,MAAM,IAAI;CAGlD,QAFc,0BAA0B,KAAK,KAEjC,CAAC,GAAG,MAAM,GAAA,CAAI,QAAQ,qBAAqB,EAAE;AAC3D"}