@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Reasoner-Cw90zrjv.mjs

@@ -0,0 +1,798 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { S as Variable, Y as literal, Z as namedNode, t as BlankNode } from "./Term-CFLG1qu4.mjs";
+import { i as rdf, o as xsd } from "./Vocab-DceKywpq.mjs";
+import { a as canonicalDouble, g as isNumericDatatype, m as isIntegerDatatype } from "./Xsd-Cdgx5zRB.mjs";
+import { D as isBlankNode, E as loop, O as isLiteral, T as variables, _ as isCollection, j as isVariable, k as isNamedNode, m as emptyFormula, r as Formula, s as Statement, t as Collection, v as isFormula, w as substitute, y as isGround } from "./Model-DlPzRYhF.mjs";
+import { r as isomorphic } from "./Isomorphism-DInKnWIy.mjs";
+import { a as log, i as list, l as string, o as math } from "./Vocab-TfpWG1Ne.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 Order from "effect/Order";
+import * as Record from "effect/Record";
+import * as Result from "effect/Result";
+// src/n3/internal/builtins.ts
+/**
+* A small library of N3 builtins (`math:`, `string:`, `list:`, `log:`).
+*
+* A builtin receives its subject and object with the current bindings
+* applied and returns the extended bindings for each solution, or
+* `undefined` when it cannot be evaluated yet (an input is still unbound).
+*
+* @internal
+*/
+const notReady = Option.none();
+/** The builtin's solutions. */
+const solutions = (bs) => Option.some(bs);
+/** No solutions once `t` is ground, not ready while it is not. */
+const noneOnceReady = (t) => ready(t) ? solutions([]) : notReady;
+const TRUE = literal("true", xsd.boolean);
+/** Whether a term contains no variables (blank nodes count as ground). */
+const ground = (t) => isGround(t);
+const NUMERIC = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+const toNum = (t) => {
+	if (!isLiteral(t)) return Option.none();
+	const v = t.value.trim();
+	const dt = t.datatype.value;
+	if ((dt === xsd.double.value || dt === xsd.float.value) && /^(?:[+-]?INF|NaN)$/.test(v)) return Option.some({
+		kind: "double",
+		value: v === "NaN" ? NaN : v.startsWith("-") ? -Infinity : Infinity
+	});
+	if (!NUMERIC.test(v)) return Option.none();
+	if (isIntegerDatatype(dt) || dt === "http://www.w3.org/2001/XMLSchema#string" && /^[+-]?\d+$/.test(v)) return Option.some({
+		kind: "integer",
+		value: BigInt(v)
+	});
+	if (dt === xsd.double.value || dt === xsd.float.value || /[eE]/.test(v)) return Option.some({
+		kind: "double",
+		value: Number(v)
+	});
+	if (dt === xsd.decimal.value || dt === "http://www.w3.org/2001/XMLSchema#string") return Option.some({
+		kind: "decimal",
+		value: Number(v)
+	});
+	return Option.none();
+};
+const asNumber = (n) => n.kind === "integer" ? Number(n.value) : n.value;
+/** The literal of an arithmetic result. */
+const fromNum = (n) => {
+	if (n.kind === "integer") return literal(n.value.toString(), xsd.integer);
+	if (n.kind === "double") return literal(canonicalDouble(n.value), xsd.double);
+	const s = String(Number(n.value.toPrecision(15)));
+	return Number.isFinite(n.value) && !/e/i.test(s) ? literal(s.includes(".") ? s : `${s}.0`, xsd.decimal) : literal(canonicalDouble(n.value), xsd.double);
+};
+const numEquals = (a, b) => {
+	if (a.kind === "integer" && b.kind === "integer") return a.value === b.value;
+	const x = asNumber(a);
+	const y = asNumber(b);
+	if (x === y) return true;
+	if (!Number.isFinite(x) || !Number.isFinite(y)) return false;
+	return Math.abs(x - y) <= 1e-12 * Math.max(Math.abs(x), Math.abs(y));
+};
+const resultKind = (ns) => ns.some((n) => n.kind === "double") ? "double" : ns.some((n) => n.kind === "decimal") ? "decimal" : "integer";
+const numbersOf = (t) => isCollection(t) ? Option.all(t.items.map(toNum)) : Option.none();
+/** Unifies the object with a computed value (or checks it). */
+const output = (object, value, b, ctx) => {
+	if (Option.isNone(value)) return solutions([]);
+	if (ground(object)) {
+		const on = toNum(object);
+		const vn = toNum(value.value);
+		if (Option.isSome(on) && Option.isSome(vn)) return solutions(numEquals(on.value, vn.value) ? [b] : []);
+	}
+	return solutions(ctx.unify(object, value.value, b));
+};
+const ready = (t) => ground(t);
+const listFunction = (f, arity = -1) => (s, o, b, ctx) => {
+	if (!ready(s)) return notReady;
+	const ns = numbersOf(s);
+	if (Option.isNone(ns) || arity >= 0 && ns.value.length !== arity) return solutions([]);
+	const r = f(ns.value);
+	return Option.isNone(r) ? solutions([]) : output(o, Option.some(fromNum(r.value)), b, ctx);
+};
+const unaryFunction = (f, inverse) => (s, o, b, ctx) => {
+	if (!ready(s)) {
+		if (inverse === void 0 || !ready(o)) return notReady;
+		const n = toNum(o);
+		return solutions(Option.isNone(n) ? [] : ctx.unify(s, fromNum(inverse(n.value)), b));
+	}
+	const n = toNum(s);
+	return Option.isNone(n) ? solutions([]) : output(o, Option.some(fromNum(f(n.value))), b, ctx);
+};
+const real = (f) => (n) => ({
+	kind: "double",
+	value: f(asNumber(n))
+});
+const comparison = (test) => (s, o, b) => {
+	if (!ready(s) || !ready(o)) return notReady;
+	const xs = toNum(s);
+	const ys = toNum(o);
+	if (Option.isNone(xs) || Option.isNone(ys)) return solutions([]);
+	const x = xs.value;
+	const y = ys.value;
+	const c = Number.isNaN(asNumber(x)) || Number.isNaN(asNumber(y)) ? NaN : numEquals(x, y) ? 0 : asNumber(x) < asNumber(y) ? -1 : 1;
+	return solutions(test(c) ? [b] : []);
+};
+/** Folds the numbers as integers when they all are, else as reals. */
+const fold = (int, int0, float, float0) => (ns) => {
+	const kind = resultKind(ns);
+	return Option.some(kind === "integer" ? {
+		kind,
+		value: ns.reduce((a, n) => n.kind === "integer" ? int(a, n.value) : a, int0)
+	} : {
+		kind,
+		value: ns.reduce((a, n) => float(a, asNumber(n)), float0)
+	});
+};
+const sum = fold((a, n) => a + n, 0n, (a, n) => a + n, 0);
+const product = fold((a, n) => a * n, 1n, (a, n) => a * n, 1);
+const noInteger = () => Option.none();
+const binary = (int, float, forceReal = false) => (ns) => {
+	const [a, c] = ns;
+	if (a === void 0 || c === void 0) return Option.none();
+	const kind = resultKind(ns);
+	let outKind = kind === "integer" ? "decimal" : kind;
+	if (a.kind === "integer" && c.kind === "integer" && !forceReal) {
+		const r = int(a.value, c.value);
+		if (Option.isSome(r)) return Option.some({
+			kind: "integer",
+			value: r.value
+		});
+		outKind = "double";
+	}
+	const r = float(asNumber(a), asNumber(c));
+	if (outKind !== "double" && !Number.isFinite(r)) return Option.none();
+	return Option.some({
+		kind: outKind,
+		value: r
+	});
+};
+const mathBuiltins = {
+	sum: listFunction(sum),
+	product: listFunction(product),
+	difference: listFunction(binary((a, b) => Option.some(a - b), (a, b) => a - b), 2),
+	quotient: listFunction(binary(noInteger, (a, b) => a / b, true), 2),
+	integerQuotient: listFunction((ns) => {
+		const [a, b] = ns.map(asNumber);
+		return a === void 0 || b === void 0 || b === 0 ? Option.none() : Option.some({
+			kind: "integer",
+			value: BigInt(Math.trunc(a / b))
+		});
+	}, 2),
+	remainder: listFunction((ns) => {
+		const [a, b] = ns;
+		if (a?.kind !== "integer" || b?.kind !== "integer" || b.value === 0n) return Option.none();
+		return Option.some({
+			kind: "integer",
+			value: (a.value % b.value + b.value) % b.value
+		});
+	}, 2),
+	exponentiation: listFunction(binary((a, b) => b >= 0n ? Option.some(a ** b) : Option.none(), (a, b) => a ** b), 2),
+	negation: unaryFunction((n) => n.kind === "integer" ? {
+		kind: n.kind,
+		value: -n.value
+	} : {
+		kind: n.kind,
+		value: -n.value
+	}, (n) => n.kind === "integer" ? {
+		kind: n.kind,
+		value: -n.value
+	} : {
+		kind: n.kind,
+		value: -n.value
+	}),
+	absoluteValue: unaryFunction((n) => n.kind === "integer" ? {
+		kind: n.kind,
+		value: n.value < 0n ? -n.value : n.value
+	} : {
+		kind: n.kind,
+		value: Math.abs(n.value)
+	}),
+	rounded: unaryFunction((n) => n.kind === "integer" ? n : {
+		kind: n.kind,
+		value: Math.round(n.value)
+	}),
+	floor: unaryFunction((n) => ({
+		kind: "integer",
+		value: BigInt(Math.floor(asNumber(n)))
+	})),
+	ceiling: unaryFunction((n) => ({
+		kind: "integer",
+		value: BigInt(Math.ceil(asNumber(n)))
+	})),
+	sin: unaryFunction(real(Math.sin), real(Math.asin)),
+	cos: unaryFunction(real(Math.cos), real(Math.acos)),
+	tan: unaryFunction(real(Math.tan), real(Math.atan)),
+	asin: unaryFunction(real(Math.asin), real(Math.sin)),
+	acos: unaryFunction(real(Math.acos), real(Math.cos)),
+	atan: unaryFunction(real(Math.atan), real(Math.tan)),
+	sinh: unaryFunction(real(Math.sinh), real(Math.asinh)),
+	cosh: unaryFunction(real(Math.cosh)),
+	tanh: unaryFunction(real(Math.tanh), real(Math.atanh)),
+	degrees: unaryFunction(real((x) => x * 180 / Math.PI), real((x) => x * Math.PI / 180)),
+	greaterThan: comparison((c) => c > 0),
+	lessThan: comparison((c) => c < 0),
+	notGreaterThan: comparison((c) => c <= 0),
+	notLessThan: comparison((c) => c >= 0),
+	equalTo: comparison((c) => c === 0),
+	notEqualTo: comparison((c) => !(c === 0))
+};
+/** The XPath string value of a literal (numbers and booleans in canonical form). */
+const literalString = (t) => {
+	const dt = t.datatype.value;
+	if (dt === xsd.boolean.value) return t.value === "1" || t.value === "true" ? "true" : "false";
+	if (dt !== "http://www.w3.org/2001/XMLSchema#string" && isNumericDatatype(dt)) {
+		const num = toNum(t);
+		if (Option.isSome(num)) {
+			const n = num.value;
+			if (n.kind === "integer") return n.value.toString();
+			if (Number.isNaN(n.value)) return "NaN";
+			if (!Number.isFinite(n.value)) return n.value > 0 ? "INF" : "-INF";
+			return String(n.value);
+		}
+	}
+	return t.value;
+};
+/** The XPath string value of a term: of a literal or an IRI. */
+const str = (t) => isLiteral(t) ? Option.some(literalString(t)) : isNamedNode(t) ? Option.some(t.value) : Option.none();
+const stringTest = (test) => (s, o, b) => {
+	if (!ready(s) || !ready(o)) return notReady;
+	const x = str(s);
+	const y = str(o);
+	return solutions(Option.isSome(x) && Option.isSome(y) && test(x.value, y.value) ? [b] : []);
+};
+const stringsOf = (t) => isCollection(t) ? Option.all(t.items.map(str)) : Option.none();
+const stringFunction = (f) => (s, o, b, ctx) => {
+	if (!ready(s)) return notReady;
+	const r = Option.flatMap(stringsOf(s), f);
+	return solutions(Option.isNone(r) ? [] : ctx.unify(o, literal(r.value), b));
+};
+const regex = (pattern, flags = "") => Result.getSuccess(Result.try(() => new RegExp(pattern, flags)));
+const stringBuiltins = {
+	concatenation: stringFunction((args) => Option.some(args.join(""))),
+	contains: stringTest((a, b) => a.includes(b)),
+	containsIgnoringCase: stringTest((a, b) => a.toLowerCase().includes(b.toLowerCase())),
+	startsWith: stringTest((a, b) => a.startsWith(b)),
+	endsWith: stringTest((a, b) => a.endsWith(b)),
+	equalIgnoringCase: stringTest((a, b) => a.toLowerCase() === b.toLowerCase()),
+	notEqualIgnoringCase: stringTest((a, b) => a.toLowerCase() !== b.toLowerCase()),
+	greaterThan: stringTest((a, b) => a > b),
+	lessThan: stringTest((a, b) => a < b),
+	notGreaterThan: stringTest((a, b) => a <= b),
+	notLessThan: stringTest((a, b) => a >= b),
+	matches: stringTest((a, b) => Option.exists(regex(b), (re) => re.test(a))),
+	notMatches: stringTest((a, b) => !Option.match(regex(b), {
+		onNone: () => true,
+		onSome: (re) => re.test(a)
+	})),
+	replace: stringFunction(([s, p, r]) => {
+		if (s === void 0 || p === void 0 || r === void 0) return Option.none();
+		return Option.map(regex(p, "g"), (re) => s.replace(re, r.replace(/\\(\d)/g, "$$$1")));
+	}),
+	scrape: stringFunction(([s, p]) => {
+		if (s === void 0 || p === void 0) return Option.none();
+		return Option.flatMap(regex(p), (re) => Option.fromUndefinedOr(re.exec(s)?.[1]));
+	}),
+	format: stringFunction(([fmt, ...args]) => {
+		if (fmt === void 0) return Option.none();
+		let i = 0;
+		return Option.some(fmt.replace(/%s/g, () => args[i++] ?? ""));
+	})
+};
+/** The two items of a two-item collection. */
+const pairOf = (t) => {
+	if (!isCollection(t)) return Option.none();
+	const [x, y] = t.items;
+	return t.items.length === 2 && x !== void 0 && y !== void 0 ? Option.some([x, y]) : Option.none();
+};
+/** The three items of a three-item collection. */
+const tripleOf = (t) => {
+	if (!isCollection(t)) return Option.none();
+	const [x, y, z] = t.items;
+	return t.items.length === 3 && x !== void 0 && y !== void 0 && z !== void 0 ? Option.some([
+		x,
+		y,
+		z
+	]) : Option.none();
+};
+const noSolutions = () => [];
+const integerLiteral = (n) => literal(String(n), xsd.integer);
+const listBuiltins = {
+	in: (s, o, b, ctx) => {
+		if (!isCollection(o)) return noneOnceReady(o);
+		return solutions(o.items.flatMap((item) => ctx.unify(s, item, b)));
+	},
+	member: (s, o, b, ctx) => {
+		if (!isCollection(s)) return noneOnceReady(s);
+		return solutions(s.items.flatMap((item) => ctx.unify(o, item, b)));
+	},
+	length: (s, o, b, ctx) => !isCollection(s) ? noneOnceReady(s) : output(o, Option.some(integerLiteral(s.items.length)), b, ctx),
+	first: (s, o, b, ctx) => !isCollection(s) ? noneOnceReady(s) : output(o, Option.fromUndefinedOr(s.items[0]), b, ctx),
+	last: (s, o, b, ctx) => !isCollection(s) ? noneOnceReady(s) : output(o, Option.fromUndefinedOr(s.items.at(-1)), b, ctx),
+	rest: (s, o, b, ctx) => !isCollection(s) || Arr.isReadonlyArrayEmpty(s.items) ? noneOnceReady(s) : solutions(ctx.unify(o, new Collection(s.items.slice(1)), b)),
+	append: (s, o, b, ctx) => {
+		if (!ready(s)) return notReady;
+		if (!isCollection(s) || !s.items.every(isCollection)) return solutions([]);
+		return solutions(ctx.unify(o, new Collection(s.items.flatMap((l) => isCollection(l) ? l.items : [])), b));
+	},
+	iterate: (s, o, b, ctx) => {
+		if (!isCollection(s)) return noneOnceReady(s);
+		return solutions(s.items.flatMap((item, i) => ctx.unify(o, new Collection([integerLiteral(i), item]), b)));
+	},
+	memberAt: (s, o, b, ctx) => {
+		if (!ready(s)) return notReady;
+		const found = Option.flatMap(pairOf(s), ([l, idx]) => isCollection(l) ? Option.map(toNum(idx), (n) => Option.fromUndefinedOr(l.items[asNumber(n)])) : Option.none());
+		return Option.isNone(found) ? solutions([]) : output(o, found.value, b, ctx);
+	},
+	remove: (s, o, b, ctx) => {
+		if (!ready(s)) return notReady;
+		return solutions(Option.match(pairOf(s), {
+			onNone: noSolutions,
+			onSome: ([l, x]) => isCollection(l) ? ctx.unify(o, new Collection(l.items.filter((i) => i.key !== x.key)), b) : []
+		}));
+	}
+};
+const scopeOf = (t, ctx) => isFormula(t) ? Option.some(t) : isLiteral(t) && t.key === TRUE.key ? Option.some(emptyFormula) : isBlankNode(t) ? Option.some(ctx.document()) : Option.none();
+const noGoals$1 = [];
+const goalsOf$1 = (t) => isFormula(t) ? Option.some(t.statements) : t.key === TRUE.key ? Option.some(noGoals$1) : Option.none();
+/**
+* `log:includes` / `log:notIncludes`: queries the subject formula for the
+* object's statements and maps the solutions with `answer`. An unbound or
+* non-formula operand gives no solutions once the subject is ground, and is
+* not ready otherwise.
+*/
+const included = (s, o, b, ctx, answer) => {
+	const scope = scopeOf(s, ctx);
+	const goals = goalsOf$1(o);
+	if (Option.isNone(scope) || Option.isNone(goals)) return noneOnceReady(s);
+	return solutions(answer(ctx.query(scope.value, goals.value, b, false)));
+};
+const logBuiltins = {
+	equalTo: (s, o, b, ctx) => solutions(ctx.unify(s, o, b)),
+	notEqualTo: (s, o, b) => !ready(s) || !ready(o) ? notReady : solutions(s.key !== o.key ? [b] : []),
+	includes: (s, o, b, ctx) => included(s, o, b, ctx, (found) => found),
+	notIncludes: (s, o, b, ctx) => included(s, o, b, ctx, (found) => Arr.isReadonlyArrayEmpty(found) ? [b] : []),
+	conjunction: (s, o, b, ctx) => {
+		if (!ready(s)) return notReady;
+		if (!isCollection(s)) return solutions([]);
+		const parts = Option.all(s.items.map(goalsOf$1));
+		if (Option.isNone(parts)) return solutions([]);
+		return solutions(ctx.unify(o, new Formula(parts.value.flat()), b));
+	},
+	conclusion: (s, o, b, ctx) => {
+		const f = s.key === TRUE.key ? emptyFormula : s;
+		if (!isFormula(f)) return noneOnceReady(s);
+		return solutions(ctx.unify(o, ctx.conclusion(f), b));
+	},
+	uri: (s, o, b, ctx) => {
+		if (isNamedNode(s)) return solutions(ctx.unify(o, literal(s.value), b));
+		if (isLiteral(o)) return solutions(ctx.unify(s, namedNode(o.value), b));
+		return noneOnceReady(s);
+	},
+	dtlit: (s, o, b, ctx) => {
+		const pair = pairOf(s);
+		if (Option.isSome(pair) && ready(s)) {
+			const [lex, dt] = pair.value;
+			if (!isLiteral(lex) || !isNamedNode(dt)) return solutions([]);
+			return solutions(ctx.unify(o, literal(lex.value, dt), b));
+		}
+		if (isLiteral(o)) return solutions(ctx.unify(s, new Collection([literal(o.value), o.datatype]), b));
+		return notReady;
+	},
+	langlit: (s, o, b, ctx) => {
+		const pair = pairOf(s);
+		if (Option.isSome(pair) && ready(s)) {
+			const [lex, lang] = pair.value;
+			if (!isLiteral(lex) || !isLiteral(lang)) return solutions([]);
+			return solutions(ctx.unify(o, literal(lex.value, lang.value), b));
+		}
+		if (isLiteral(o) && o.language !== "") return solutions(ctx.unify(s, new Collection([literal(o.value), literal(o.language)]), b));
+		return notReady;
+	},
+	rawType: (s, o, b, ctx) => {
+		if (!ready(s)) return notReady;
+		const type = isFormula(s) ? log.Formula : isLiteral(s) ? log.Literal : isCollection(s) ? log.List : log.Other;
+		return solutions(ctx.unify(o, type, b));
+	},
+	collectAllIn: (s, o, b, ctx) => solutions(Option.match(Option.flatMap(tripleOf(s), ([template, where, result]) => Option.map(Option.all([scopeOf(o, ctx), goalsOf$1(where)]), ([scope, goals]) => ({
+		template,
+		result,
+		scope,
+		goals
+	}))), {
+		onNone: noSolutions,
+		onSome: ({ template, result, scope, goals }) => {
+			const values = ctx.query(scope, goals, b, true).map((sol) => substitute(template, sol));
+			return ctx.unify(result, new Collection(values), b);
+		}
+	})),
+	forAllIn: (s, o, b, ctx) => solutions(Option.match(Option.flatMap(pairOf(s), ([w, t]) => {
+		const where = goalsOf$1(w);
+		const then = goalsOf$1(t);
+		return Option.all([
+			scopeOf(o, ctx),
+			where,
+			then
+		]);
+	}), {
+		onNone: noSolutions,
+		onSome: ([scope, where, then]) => ctx.query(scope, where, b, true).every((sol) => Arr.isReadonlyArrayNonEmpty(ctx.query(scope, then, sol, true))) ? [b] : []
+	}))
+};
+const table = MutableHashMap.empty();
+[
+	[math.base, mathBuiltins],
+	[string.base, stringBuiltins],
+	[list.base, listBuiltins],
+	[log.base, logBuiltins]
+].forEach(([ns, builtins]) => {
+	Record.toEntries(builtins).forEach(([name, f]) => MutableHashMap.set(table, ns + name, f));
+});
+/** @internal */
+const builtinFor = (predicate) => isNamedNode(predicate) ? MutableHashMap.get(table, predicate.value) : Option.none();
+Arr.fromIterable(MutableHashMap.keys(table));
+// src/n3/Reasoner.ts
+/**
+* A simple forward-chaining N3 reasoner.
+*
+* Rules are the top-level statements `{ premise } => { conclusion }` (and
+* `{ conclusion } <= { premise }`). The reasoner repeatedly matches every
+* rule premise against the current statements — joining triple patterns with
+* backtracking and evaluating builtins — and adds the instantiated
+* conclusions, until a fixpoint is reached.
+*
+* - Variables (`?x`) and blank nodes in a premise are matched like query
+*   variables; blank nodes that occur only in a conclusion are instantiated
+*   with fresh blank nodes for each distinct set of bindings (so the closure
+*   is finite whenever the rules do not keep inventing new terms).
+* - Rules inferred by other rules are applied too.
+* - A conclusion `false` signals an inconsistency and fails with
+*   `ReasonerError`.
+* - Builtins: a pragmatic subset of `math:` (arithmetic, comparisons,
+*   trigonometry), `string:` (concatenation, comparisons, regular
+*   expressions), `list:` (`in`, `member`, `length`, `first`, `last`, `rest`,
+*   `append`, `iterate`, `memberAt`, `remove`) and `log:` (`equalTo`,
+*   `notEqualTo`, `includes`, `notIncludes`, `conjunction`, `uri`, `dtlit`,
+*   `langlit`, `rawType`, `collectAllIn`, `forAllIn`). Builtins whose inputs
+*   are not yet bound are deferred until the other premise statements have
+*   been matched.
+*
+* @since 0.1.0
+*/
+var Reasoner_exports = /* @__PURE__ */ __exportAll({
+	ReasonerError: () => ReasonerError,
+	query: () => query,
+	reason: () => reason,
+	rules: () => rules
+});
+/**
+* Reasoning failed: an inconsistency was derived or a limit was exceeded.
+*
+* @since 0.1.0
+* @category errors
+*/
+var ReasonerError = class extends Schema.TaggedError()("N3ReasonerError", { message: Schema.String }) {};
+const TRUE_KEY = literal("true", xsd.boolean).key;
+const FALSE_KEY = literal("false", xsd.boolean).key;
+const noGoals = [];
+const goalsOf = (t) => isFormula(t) ? Option.some(t.statements) : t.key === TRUE_KEY ? Option.some(noGoals) : Option.none();
+/** Premise blank nodes become rule-local variables. */
+const BLANK_VAR = "\0b:";
+/** Blank nodes at the top level of statements (not inside nested formulas). */
+const topBlanks = (statements) => {
+	const out = MutableHashSet.empty();
+	const go = (t) => {
+		if (isBlankNode(t)) MutableHashSet.add(out, t.value);
+		else if (isCollection(t)) t.items.forEach(go);
+	};
+	statements.forEach((s) => {
+		go(s.subject);
+		go(s.predicate);
+		go(s.object);
+	});
+	return out;
+};
+/** Replaces the given blank nodes (outside nested formulas) by variables. */
+const blanksToVariables = (t, blanks) => isBlankNode(t) && MutableHashSet.has(blanks, t.value) ? new Variable(BLANK_VAR + t.value) : isCollection(t) ? new Collection(t.items.map((x) => blanksToVariables(x, blanks))) : t;
+const statementBlanksToVariables = (s, blanks) => new Statement(blanksToVariables(s.subject, blanks), blanksToVariables(s.predicate, blanks), blanksToVariables(s.object, blanks));
+/**
+* Extracts the rules (`=>` and `<=` statements between formulas) of a
+* formula's top level.
+*
+* @since 0.1.0
+* @category rules
+*/
+const rules = (formula) => Arr.getSomes(formula.statements.map((s) => {
+	if (!isNamedNode(s.predicate)) return Option.none();
+	const forward = s.predicate.value === log.implies.value;
+	const backward = s.predicate.value === log.isImpliedBy.value;
+	if (!forward && !backward) return Option.none();
+	const premiseTerm = forward ? s.subject : s.object;
+	const conclusion = forward ? s.object : s.subject;
+	return Option.map(goalsOf(premiseTerm), (premise) => {
+		const blanks = topBlanks(premise);
+		return {
+			premise: premise.map((p) => statementBlanksToVariables(p, blanks)),
+			conclusion: isFormula(conclusion) ? new Formula(conclusion.statements.map((c) => statementBlanksToVariables(c, blanks))) : conclusion,
+			source: s
+		};
+	});
+}));
+/** The bindings that bind nothing. */
+const noBindings = MutableHashMap.empty().backing;
+/** `b` with `name` bound to `value` (a copy: bindings are shared between solutions). */
+const extend = (b, name, value) => {
+	const next = MutableHashMap.fromIterable(b);
+	MutableHashMap.set(next, name, value);
+	return next.backing;
+};
+const noStatements = [];
+var Store = class {
+	all = [];
+	keys = MutableHashSet.empty();
+	byPredicate = MutableHashMap.empty();
+	constructor(statements = []) {
+		Arr.fromIterable(statements).forEach((s) => this.add(s));
+	}
+	has(s) {
+		return MutableHashSet.has(this.keys, s.key);
+	}
+	add(s) {
+		if (this.has(s)) return false;
+		MutableHashSet.add(this.keys, s.key);
+		this.all.push(s);
+		const k = s.predicate.key;
+		const l = this.byPredicate.backing.get(k);
+		if (l === void 0) MutableHashMap.set(this.byPredicate, k, [s]);
+		else l.push(s);
+		return true;
+	}
+	/** The statements with the predicate `key`. */
+	withPredicate(key) {
+		return this.byPredicate.backing.get(key) ?? noStatements;
+	}
+};
+/** The term a variable is bound to, through chains of variables (it recurses once per link). */
+const walk = (t, b) => {
+	if (!isVariable(t)) return t;
+	const next = b.get(t.value);
+	return next === void 0 ? t : walk(next, b);
+};
+const resolve = (t, b) => b.size === 0 ? t : substitute(t, b);
+const unify = (pattern, term, b) => {
+	const p = walk(pattern, b);
+	if (isVariable(p)) {
+		if (isVariable(term) && term.value === p.value) return [b];
+		return [extend(b, p.value, term)];
+	}
+	const t = isVariable(term) ? walk(term, b) : term;
+	if (p instanceof Collection) {
+		if (!(t instanceof Collection) || t.items.length !== p.items.length) return [];
+		return p.items.reduce((results, item, i) => {
+			const other = t.items[i];
+			return other === void 0 ? [] : results.flatMap((r) => unify(item, other, r));
+		}, [b]);
+	}
+	if (p instanceof Formula) {
+		if (!(t instanceof Formula) || t.statements.length !== p.statements.length) return [];
+		if (isGround(p)) return p.key === t.key || isomorphic(p, t) ? [b] : [];
+		return matchFormula(p.statements, t.statements, b);
+	}
+	return p.key === t.key ? [b] : [];
+};
+/** Matches each pattern statement to a distinct statement of `target`. */
+const matchFormula = (patterns, target, b) => {
+	const out = [];
+	const used = new Uint8Array(target.length);
+	const go = (i, cur) => {
+		const p = patterns[i];
+		if (p === void 0) {
+			out.push(cur);
+			return;
+		}
+		target.forEach((s, j) => {
+			if (used[j] === 1) return;
+			used[j] = 1;
+			unifyStatement(p, s, cur).forEach((r) => go(i + 1, r));
+			used[j] = 0;
+		});
+	};
+	go(0, b);
+	return out;
+};
+const unifyStatement = (p, s, b) => unify(p.predicate, s.predicate, b).flatMap((r) => unify(p.subject, s.subject, r)).flatMap((r) => unify(p.object, s.object, r));
+const solve = (store, goals, b, engine) => {
+	const out = [];
+	const ctx = {
+		unify,
+		query: (scope, scopeGoals, bindings, builtins) => {
+			const blanks = topBlanks(scopeGoals);
+			return solve(new Store(scope.statements), scopeGoals.map((g) => statementBlanksToVariables(g, blanks)), bindings, {
+				...engine,
+				builtins: engine.builtins && builtins
+			});
+		},
+		document: engine.document,
+		conclusion: engine.conclusion
+	};
+	const go = (remaining, cur, deferred) => {
+		if (!Arr.isReadonlyArrayNonEmpty(remaining)) {
+			out.push(cur);
+			return;
+		}
+		const [goal, ...rest] = remaining;
+		const builtin = engine.builtins ? builtinFor(walk(goal.predicate, cur)) : Option.none();
+		if (Option.isSome(builtin)) {
+			const results = builtin.value(resolve(goal.subject, cur), resolve(goal.object, cur), cur, ctx);
+			if (Option.isNone(results)) {
+				if (deferred < remaining.length) go([...rest, goal], cur, deferred + 1);
+				return;
+			}
+			results.value.forEach((r) => go(rest, r, 0));
+			return;
+		}
+		const predicate = walk(goal.predicate, cur);
+		const subject = walk(goal.subject, cur);
+		const listPredicate = predicate.key === rdf.first.key || predicate.key === rdf.rest.key;
+		if (listPredicate && isVariable(subject) && deferred < remaining.length) {
+			go([...rest, goal], cur, deferred + 1);
+			return;
+		}
+		if (listPredicate && subject instanceof Collection && Arr.isReadonlyArrayNonEmpty(subject.items)) {
+			const value = predicate.key === rdf.first.key ? subject.items[0] : subject.items.length === 1 ? rdf.nil : new Collection(subject.items.slice(1));
+			unify(goal.object, value, cur).forEach((r) => go(rest, r, 0));
+			return;
+		}
+		(isVariable(predicate) ? store.all : store.withPredicate(predicate.key)).forEach((s) => {
+			unifyStatement(goal, s, cur).forEach((r) => go(rest, r, 0));
+		});
+	};
+	go(goals, b, 0);
+	return out;
+};
+const hash = (s) => {
+	let h1 = 2166136261;
+	let h2 = 16777619;
+	loop((i) => {
+		if (i >= s.length) return false;
+		const c = s.charCodeAt(i);
+		h1 = Math.imul(h1 ^ c, 16777619);
+		h2 = Math.imul(h2 ^ c, 1540483477);
+		return true;
+	});
+	return (h1 >>> 0).toString(36) + (h2 >>> 0).toString(36);
+};
+var Inconsistency = class {
+	rule;
+	constructor(rule) {
+		this.rule = rule;
+	}
+};
+const instantiate = (rule, b) => {
+	const conclusion = walk(rule.conclusion, b);
+	if (conclusion.key === FALSE_KEY) throw new Inconsistency(rule.source);
+	if (conclusion !== rule.conclusion) return Option.getOrElse(goalsOf(resolve(conclusion, b)), () => noGoals);
+	const goals = goalsOf(conclusion);
+	if (Option.isNone(goals)) return noGoals;
+	const used = MutableHashSet.fromIterable(variables(conclusion).map((v) => v.value));
+	const entries = Arr.fromIterable(b).filter(([k]) => MutableHashSet.has(used, k)).map(([k, v]) => `${k}=${resolve(v, b).key}`);
+	const signature = Arr.sort(entries, Order.String).join("|");
+	const fresh = MutableHashMap.empty();
+	const skolem = (label) => {
+		const known = fresh.backing.get(label);
+		if (known !== void 0) return known;
+		const node = new BlankNode(`sk${hash(`${rule.source.key}|${signature}|${label}`)}`);
+		MutableHashMap.set(fresh, label, node);
+		return node;
+	};
+	const top = (t) => isBlankNode(t) ? skolem(t.value) : isCollection(t) ? new Collection(t.items.map(top)) : t;
+	return goals.value.map((s) => new Statement(resolve(top(s.subject), b), resolve(top(s.predicate), b), resolve(top(s.object), b)));
+};
+var LimitExceeded = class {
+	message;
+	constructor(message) {
+		this.message = message;
+	}
+};
+/** Forward chaining to a fixpoint; throws `Inconsistency` / `LimitExceeded`. */
+const closureOf = (input, options, depth = 0) => {
+	const maxRounds = options?.maxRounds ?? 1e3;
+	const maxStatements = options?.maxStatements ?? 1e6;
+	const store = new Store(input.statements);
+	const inferred = [];
+	let snapshot = Option.none();
+	const engine = {
+		builtins: options?.builtins ?? true,
+		document: () => {
+			if (Option.isSome(snapshot)) return snapshot.value;
+			const f = new Formula(store.all);
+			snapshot = Option.some(f);
+			return f;
+		},
+		conclusion: (f) => {
+			if (depth > 8) throw new LimitExceeded("log:conclusion nested too deeply");
+			return closureOf(f, options, depth + 1).closure;
+		}
+	};
+	let result = Option.none();
+	loop((i) => {
+		const round = i + 1;
+		if (round > maxRounds) return false;
+		snapshot = Option.none();
+		const fresh = [];
+		rules(new Formula(store.all)).forEach((rule) => {
+			solve(store, rule.premise, noBindings, engine).forEach((b) => {
+				instantiate(rule, b).forEach((s) => {
+					if (!store.has(s)) fresh.push(s);
+				});
+			});
+		});
+		let added = 0;
+		fresh.forEach((s) => {
+			if (store.add(s)) {
+				inferred.push(s);
+				added++;
+			}
+		});
+		if (store.all.length > maxStatements) throw new LimitExceeded(`Closure exceeds ${maxStatements} statements`);
+		if (added > 0) return true;
+		result = Option.some({
+			closure: new Formula(store.all),
+			inferred: new Formula(inferred),
+			rounds: round
+		});
+		return false;
+	});
+	if (Option.isSome(result)) return result.value;
+	throw new LimitExceeded(`No fixpoint after ${maxRounds} rounds`);
+};
+/**
+* Computes the deductive closure of a formula under its rules.
+*
+* @example
+* ```ts
+* import { Effect } from 'effect'
+* import { N3, Reasoner } from '@thomasfosterau/effect-rdf/n3'
+*
+* const program = Effect.gen(function* () {
+*   const doc = yield* N3.parse(`@prefix : <http://example.org/> .
+*     :socrates a :Man .
+*     { ?x a :Man } => { ?x a :Mortal } .`)
+*   const { inferred } = yield* Reasoner.reason(doc.formula)
+*   return N3.serializeDocument(inferred) // :socrates a :Mortal .
+* })
+* ```
+*
+* @since 0.1.0
+* @category reasoning
+*/
+const reason = (formula, options) => Effect.sync(() => closureOf(isFormula(formula) ? formula : formula.formula, options)).pipe(Effect.catchDefect((e) => e instanceof Inconsistency ? Effect.fail(new ReasonerError({ message: `Inconsistency derived by rule ${e.rule.key}` })) : e instanceof LimitExceeded ? Effect.fail(new ReasonerError({ message: e.message })) : Effect.die(e)), Effect.tap((result) => Effect.annotateCurrentSpan("n3.statements", result.closure.size)), Effect.withSpan("Reasoner.reason", { attributes: { "n3.input.statements": (isFormula(formula) ? formula : formula.formula).size } }));
+/**
+* Answers a query: all bindings of the variables (and blank nodes) of
+* `pattern` under which every statement of `pattern` holds in `formula`
+* (builtins are evaluated).
+*
+* @since 0.1.0
+* @category reasoning
+*/
+const query = (formula, pattern) => {
+	const store = new Store(formula.statements);
+	const blanks = topBlanks(pattern.statements);
+	const goals = pattern.statements.map((s) => statementBlanksToVariables(s, blanks));
+	return solve(store, goals, noBindings, {
+		builtins: true,
+		document: () => formula,
+		conclusion: (f) => closureOf(f).closure
+	}).map((b) => {
+		const answer = MutableHashMap.empty();
+		b.forEach((v, k) => {
+			if (!k.startsWith(BLANK_VAR)) MutableHashMap.set(answer, k, resolve(v, b));
+		});
+		return answer.backing;
+	});
+};
+export { rules as a, reason as i, Reasoner_exports as n, query as r, ReasonerError as t };
+
+//# sourceMappingURL=Reasoner-Cw90zrjv.mjs.map