@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Engine-DF8PN7g-.mjs

@@ -0,0 +1,872 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, K as isTriple, N as isBlankNode, O as defaultGraph, P as isDefaultGraph, T as blankNode, V as isObject, W as isSubject, X as mapTerms, d as Quad, o as Literal, q as isVariable, rt as triple, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { a as setOf, i as fromEntries, n as empty, r as emptySet, t as copy } from "./stringMap-D5YIpYtR.mjs";
+import { _ as prebind$1, f as join, n as bgp, x as unit } from "./Algebra-CGG4oae3.mjs";
+import { a as empty$1, f as merge, g as sharesVariable, h as set, i as compatible, p as project, t as Bindings } from "./Bindings-Ck3m7JRC.mjs";
+import { n as EvaluationError, r as UpdateError } from "./Errors-CMdV1RhU.mjs";
+import { C as orderCompare, _ as dt, b as fail, f as arithmetic, g as compareTerms, m as catchEvalFailure, w as simple } from "./Functions-AvjNcId_.mjs";
+import { c as makeContext, l as test, o as evaluateOrUndefined } from "./Expression-BIMMvduQ.mjs";
+import { n as optimize } from "./Optimizer-BWWQRQPY.mjs";
+import { i as parseQuery, s as parseUpdate } from "./Parser-xARsOWXk.mjs";
+import { i as layerMemory$1, t as QuadStore } from "./Store-DH3Ow1GO.mjs";
+import { a as translateQuery, i as translatePattern } from "./Translate-gzWPq0Ia.mjs";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Order from "effect/Order";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import * as Result from "effect/Result";
+import * as Cause from "effect/Cause";
+// src/sparql/internal/evaluator.ts
+/**
+* The generic, streaming evaluator of the SPARQL algebra over a `QuadStore`.
+*
+* @internal
+*/
+/**
+* Substitutes bound variables: the ground term, or `None` while a variable
+* is unbound. Plain branches rather than `Match`: it runs for every term of
+* every triple pattern per solution.
+*/
+const ground = (t, b) => {
+	if (isVariable(t)) return Option.fromUndefinedOr(b.map.get(t.value));
+	if (isTriple(t)) {
+		const s = ground(t.subject, b);
+		if (Option.isNone(s)) return s;
+		const p = ground(t.predicate, b);
+		if (Option.isNone(p)) return p;
+		const o = ground(t.object, b);
+		if (Option.isNone(o)) return o;
+		return t.subject === s.value && t.predicate === p.value && t.object === o.value ? Option.some(t) : Option.some(triple(s.value, p.value, o.value));
+	}
+	return isDefaultGraph(t) ? Option.none() : Option.some(t);
+};
+/**
+* Unifies a pattern term with a value, extending `map`; false on mismatch.
+* Plain branches rather than `Match`: it runs for every matched quad.
+*/
+const unify = (t, value, map) => {
+	if (isVariable(t)) {
+		const bound = map.get(t.value);
+		if (bound !== void 0) return bound.key === value.key;
+		map.set(t.value, value);
+		return true;
+	}
+	if (isTriple(t)) return isTriple(value) && unify(t.subject, value.subject, map) && unify(t.predicate, value.predicate, map) && unify(t.object, value.object, map);
+	return t.key === value.key;
+};
+const dedupeTriples = (quads) => Stream.suspend(() => {
+	const seen = emptySet();
+	return Stream.filter(quads, (q) => {
+		const k = `${q.subject.key} ${q.predicate.key} ${q.object.key}`;
+		if (seen.has(k)) return false;
+		seen.set(k, true);
+		return true;
+	});
+});
+/** Matches a quad pattern (without graph) in the active graph. */
+const matchQuads = (env, pattern) => {
+	const active = env.graph;
+	if (Predicate.isTagged(active, "NamedGraph")) return env.store.match({
+		...pattern,
+		graph: active.graph
+	});
+	const def = env.dataset.defaultGraph;
+	if (def === "default") return env.store.match({
+		...pattern,
+		graph: defaultGraph
+	});
+	if (def === "union") return dedupeTriples(env.store.match({
+		...pattern,
+		graph: void 0
+	}));
+	if (!Arr.isReadonlyArrayNonEmpty(def)) return Stream.empty;
+	if (def.length === 1) return env.store.match({
+		...pattern,
+		graph: Arr.headNonEmpty(def)
+	});
+	return dedupeTriples(concatAll(def.map((g) => env.store.match({
+		...pattern,
+		graph: g
+	}))));
+};
+const concatAll = (streams) => Arr.isReadonlyArrayEmpty(streams) ? Stream.empty : streams.reduce((a, b) => Stream.concat(a, b));
+const matchTriple = (pattern, env, b) => {
+	const s = ground(pattern.subject, b);
+	const p = ground(pattern.predicate, b);
+	const o = ground(pattern.object, b);
+	const unifyS = Option.isNone(s);
+	const unifyP = Option.isNone(p);
+	const unifyO = Option.isNone(o);
+	return matchQuads(env, {
+		subject: Option.getOrUndefined(s),
+		predicate: Option.getOrUndefined(p),
+		object: Option.getOrUndefined(o)
+	}).pipe(Stream.filterMap((q) => {
+		const map = copy(b.map);
+		if ((!unifyS || unify(pattern.subject, q.subject, map)) && (!unifyP || unify(pattern.predicate, q.predicate, map)) && (!unifyO || unify(pattern.object, q.object, map))) return Result.succeed(new Bindings(map));
+		return Result.fail(void 0);
+	}));
+};
+const evalBgp = (patterns, env, initial) => {
+	const start = Stream.succeed(initial);
+	return patterns.reduce((stream, p) => Stream.flatMap(stream, (b) => matchTriple(p, env, b)), start);
+};
+/** `Effect.forEach` in order, concatenating each element's results. */
+const forEachFlat = (items, f) => Effect.map(Effect.forEach(items, f, { concurrency: 1 }), (lists) => lists.flat());
+const collect = (env, pattern) => Stream.runCollect(matchQuads(env, pattern));
+const iriValueSet = (list) => setOf(list.map((i) => i.value));
+const distinctTerms = (terms) => {
+	const seen = empty();
+	terms.forEach((t) => {
+		if (!seen.has(t.key)) seen.set(t.key, t);
+	});
+	return Array.from(seen.values());
+};
+/** Nodes reachable from `start` by `path` (forward) or reaching `start` (backward); a bag. */
+const pathFrom = (env, path, start, forward) => {
+	return Match.value(path).pipe(Match.tag("PathLink", (link) => Effect.map(collect(env, forward ? {
+		subject: start,
+		predicate: link.iri
+	} : {
+		predicate: link.iri,
+		object: start
+	}), (qs) => qs.map((q) => forward ? q.object : q.subject))), Match.tag("PathInverse", (inv) => pathFrom(env, inv.path, start, !forward)), Match.tag("PathSequence", (seq) => {
+		const steps = forward ? seq.paths : seq.paths.toReversed();
+		return Effect.reduce(steps, () => [start], (frontier, step) => forEachFlat(frontier, (n) => pathFrom(env, step, n, forward)));
+	}), Match.tag("PathAlternative", (alt) => forEachFlat(alt.paths, (p) => pathFrom(env, p, start, forward))), Match.tag("PathZeroOrOne", (opt) => Effect.map(pathFrom(env, opt.path, start, forward), (ns) => distinctTerms([start, ...ns]))), Match.tag("PathZeroOrMore", "PathOneOrMore", (rep) => closure(env, rep.path, start, forward, Predicate.isTagged(rep, "PathZeroOrMore"))), Match.tag("PathNegated", (neg) => {
+		const parts = [];
+		if (Arr.isReadonlyArrayNonEmpty(neg.iris) || Arr.isReadonlyArrayEmpty(neg.inverse)) {
+			const ex = iriValueSet(neg.iris);
+			parts.push(Effect.map(collect(env, forward ? { subject: start } : { object: start }), (qs) => qs.filter((q) => !ex.has(q.predicate.value)).map((q) => forward ? q.object : q.subject)));
+		}
+		if (Arr.isReadonlyArrayNonEmpty(neg.inverse)) {
+			const ex = iriValueSet(neg.inverse);
+			parts.push(Effect.map(collect(env, forward ? { object: start } : { subject: start }), (qs) => qs.filter((q) => !ex.has(q.predicate.value)).map((q) => forward ? q.subject : q.object)));
+		}
+		return Effect.map(Effect.all(parts, { concurrency: 1 }), (lists) => lists.flat());
+	}), Match.exhaustive);
+};
+const closure = (env, path, start, forward, includeStart) => Effect.suspend(() => {
+	const visited = empty();
+	if (includeStart) visited.set(start.key, start);
+	const expanded = emptySet();
+	/** Expands the frontier's unexpanded nodes, then the nodes they newly reach. */
+	const expand = (frontier) => {
+		if (Arr.isReadonlyArrayEmpty(frontier)) return Effect.void;
+		const next = [];
+		const unexpanded = frontier.filter((n) => {
+			if (expanded.has(n.key)) return false;
+			expanded.set(n.key, true);
+			return true;
+		});
+		return Effect.forEach(unexpanded, (n) => Effect.map(pathFrom(env, path, n, forward), (reached) => reached.forEach((m) => {
+			if (!visited.has(m.key)) {
+				visited.set(m.key, m);
+				next.push(m);
+			}
+		})), {
+			concurrency: 1,
+			discard: true
+		}).pipe(Effect.flatMap(() => expand(next)));
+	};
+	return Effect.map(expand([start]), () => Array.from(visited.values()));
+});
+/** All nodes (subjects and objects) of the active graph. */
+const allNodes = (env) => Effect.map(collect(env, {}), (qs) => distinctTerms(qs.flatMap((q) => [q.subject, q.object])));
+const pathAll = (env, path) => {
+	return Match.value(path).pipe(Match.tag("PathLink", (link) => Effect.map(collect(env, { predicate: link.iri }), (qs) => qs.map((q) => [q.subject, q.object]))), Match.tag("PathInverse", (inv) => Effect.map(pathAll(env, inv.path), (ps) => ps.map(([a, b]) => [b, a]))), Match.tag("PathSequence", (seq) => {
+		const [first, ...rest] = seq.paths;
+		if (first === void 0) return Effect.succeed([]);
+		return Effect.flatMap(pathAll(env, first), (pairs) => forEachFlat(pairs, ([x, m]) => Effect.map(Arr.isReadonlyArrayEmpty(rest) ? Effect.succeed([m]) : pathFrom(env, {
+			_tag: "PathSequence",
+			paths: rest
+		}, m, true), (ys) => ys.map((y) => [x, y]))));
+	}), Match.tag("PathAlternative", (alt) => forEachFlat(alt.paths, (p) => pathAll(env, p))), Match.tag("PathNegated", (neg) => {
+		const out = [];
+		if (Arr.isReadonlyArrayNonEmpty(neg.iris) || Arr.isReadonlyArrayEmpty(neg.inverse)) {
+			const ex = iriValueSet(neg.iris);
+			out.push(Effect.map(collect(env, {}), (qs) => qs.filter((q) => !ex.has(q.predicate.value)).map((q) => [q.subject, q.object])));
+		}
+		if (Arr.isReadonlyArrayNonEmpty(neg.inverse)) {
+			const ex = iriValueSet(neg.inverse);
+			out.push(Effect.map(collect(env, {}), (qs) => qs.filter((q) => !ex.has(q.predicate.value)).map((q) => [q.object, q.subject])));
+		}
+		return Effect.map(Effect.all(out, { concurrency: 1 }), (lists) => lists.flat());
+	}), Match.orElse((p) => Effect.flatMap(allNodes(env), (nodes) => forEachFlat(nodes, (n) => Effect.map(pathFrom(env, p, n, true), (ys) => ys.map((y) => [n, y]))))));
+};
+/** Whether a path can match with zero length. */
+const nullable = Match.type().pipe(Match.tag("PathZeroOrMore", "PathZeroOrOne", () => true), Match.tag("PathInverse", (p) => nullable(p.path)), Match.tag("PathSequence", (p) => p.paths.every(nullable)), Match.tag("PathAlternative", (p) => p.paths.some(nullable)), Match.orElse(() => false));
+const isGraphNode = (env, term) => Effect.map(Effect.all([Stream.runHead(matchQuads(env, { subject: term })), Stream.runHead(matchQuads(env, { object: term }))], { concurrency: 1 }), ([a, b]) => Option.isSome(a) || Option.isSome(b));
+const evalPath = (op, env, initial) => Stream.fromIterableEffect(Effect.gen(function* () {
+	const s = ground(op.subject, initial);
+	const o = ground(op.object, initial);
+	const out = [];
+	if (nullable(op.path)) {
+		const endpoints = [[op.subject, s], [op.object, o]];
+		const outsideGraph = yield* Effect.findFirst(endpoints, ([term, value]) => Option.isSome(value) && !isNamedNode(term) && !isLiteral(term) ? Effect.map(isGraphNode(env, value.value), (isNode) => !isNode) : Effect.succeed(false));
+		if (Option.isSome(outsideGraph)) return out;
+	}
+	const emit = (x, y) => {
+		const map = copy(initial.map);
+		if (unify(op.subject, x, map) && unify(op.object, y, map)) out.push(new Bindings(map));
+	};
+	if (Option.isSome(s)) {
+		const from = s.value;
+		(yield* pathFrom(env, op.path, from, true)).forEach((y) => emit(from, y));
+	} else if (Option.isSome(o)) {
+		const to = o.value;
+		(yield* pathFrom(env, op.path, to, false)).forEach((x) => emit(x, to));
+	} else (yield* pathAll(env, op.path)).forEach(([x, y]) => emit(x, y));
+	return out;
+}));
+const collectExists = Match.fn((e, _out) => e).pipe(Match.tag("Exists", (x, _e, out) => {
+	out.push(x);
+}), Match.tag("Operation", "FunctionCall", (call, _e, out) => call.args.forEach((a) => collectExists(a, out))), Match.orElse(() => void 0));
+/**
+* Prepares an expression for evaluation: returns a function producing the
+* expression context for a solution (precomputing EXISTS patterns).
+*/
+const prepare = (expression, env) => {
+	const nodes = [];
+	collectExists(expression, nodes);
+	if (Arr.isReadonlyArrayEmpty(nodes)) return () => Effect.succeed(env.expr);
+	return (b) => Effect.map(Effect.forEach(nodes, (n) => Effect.map(Stream.runHead(evaluate(n.input, {
+		...env,
+		context: b
+	})), Option.isSome), { concurrency: 1 }), (results) => {
+		const table = /* @__PURE__ */ new WeakMap();
+		Arr.zip(nodes, results).forEach(([n, r]) => table.set(n, r));
+		return {
+			...env.expr,
+			exists: (e) => table.get(e) ?? false
+		};
+	});
+};
+const filterStream = (stream, expression, env) => {
+	const ctxFor = prepare(expression, env);
+	if (!Algebra_containsExists(expression)) return Stream.filter(stream, (b) => test(expression, b, env.expr));
+	return Stream.filterEffect(stream, (b) => Effect.map(ctxFor(b), (ctx) => test(expression, b, ctx)));
+};
+const Algebra_containsExists = (e) => {
+	const out = [];
+	collectExists(e, out);
+	return Arr.isReadonlyArrayNonEmpty(out);
+};
+/** Operators that can be evaluated with an initial solution (bind join). */
+const bindable = (op) => Predicate.isTagged(op, "Bgp") || Predicate.isTagged(op, "Path") || Predicate.isTagged(op, "Service") && isVariable(op.name) || Predicate.isTagged(op, "Join") && bindable(op.left) && bindable(op.right);
+/**
+* Evaluates a bindable operator with an initial solution. Plain branches
+* rather than `Match`: a bind join runs it once per solution of its left
+* side.
+*/
+const evalWith = (op, env, initial) => {
+	if (Predicate.isTagged(op, "Bgp")) return evalBgp(op.patterns, env, initial);
+	if (Predicate.isTagged(op, "Path")) return evalPath(op, env, initial);
+	if (Predicate.isTagged(op, "Join")) return Stream.flatMap(evalWith(op.left, env, initial), (b) => evalWith(op.right, env, b));
+	if (Predicate.isTagged(op, "Service")) return evalBoundService(op, env, initial);
+	return Stream.die(new Cause.IllegalArgumentError("not bindable"));
+};
+const isUnit = (op) => Predicate.isTagged(op, "Bgp") && Arr.isReadonlyArrayEmpty(op.patterns);
+/** An index of solutions by the values of the variables bound in all of them. */
+/** The index key of a solution: its terms for `vars`, all of which it binds. */
+const indexKey = (sig, vars, b) => `${sig}#${vars.map((v) => b.map.get(v)?.key ?? "").join("
")}`;
+var SolutionIndex = class {
+	keyVars;
+	buckets = empty();
+	all;
+	constructor(solutions) {
+		this.all = solutions;
+		const first = solutions[0];
+		this.keyVars = first === void 0 ? [] : Array.from(first.map.keys()).filter((v) => solutions.every((s) => s.map.has(v)));
+	}
+	candidates(b) {
+		const vars = this.keyVars.filter((v) => b.map.has(v));
+		if (Arr.isReadonlyArrayEmpty(vars)) return this.all;
+		const sig = vars.join("|");
+		const built = `${sig}#__built`;
+		if (!this.buckets.has(built)) {
+			this.buckets.set(built, []);
+			this.all.forEach((s) => {
+				const k = indexKey(sig, vars, s);
+				const list = this.buckets.get(k);
+				if (list === void 0) this.buckets.set(k, [s]);
+				else list.push(s);
+			});
+		}
+		return this.buckets.get(indexKey(sig, vars, b)) ?? [];
+	}
+};
+const materialize = (op, env) => Stream.runCollect(evaluate(op, env));
+const evalJoin = (op, env) => {
+	if (isUnit(op.left)) return bindable(op.right) ? evalWith(op.right, env, env.context) : joinWith(Stream.succeed(env.context), op.right, env);
+	if (bindable(op.right)) return Stream.flatMap(evaluate(op.left, env), (b) => evalWith(op.right, env, b));
+	return joinWith(evaluate(op.left, env), op.right, env);
+};
+const joinWith = (left, right, env) => Stream.unwrap(Effect.map(materialize(right, env), (rs) => {
+	const index = new SolutionIndex(rs);
+	return Stream.flatMap(left, (a) => Stream.fromIterable(index.candidates(a).flatMap((r) => {
+		const m = merge(a, r);
+		return m === void 0 ? [] : [m];
+	})));
+}));
+const keepAll = Effect.succeed(true);
+/** Whether a solution passes an `OPTIONAL`'s filter. */
+const keepWhere = (expression, env) => {
+	const ctxFor = prepare(expression, env);
+	return (b) => Effect.map(ctxFor(b), (ctx) => test(expression, b, ctx));
+};
+const evalLeftJoin = (op, env) => {
+	const left = isUnit(op.left) ? Stream.succeed(env.context) : evaluate(op.left, env);
+	const expression = op.expression;
+	const keep = expression === void 0 ? () => keepAll : keepWhere(expression, env);
+	const extend = (a, matches) => Effect.map(Effect.filter(matches, keep), (kept) => Arr.isReadonlyArrayNonEmpty(kept) ? kept : [a]);
+	if (bindable(op.right)) return Stream.flatMap(left, (a) => Stream.fromIterableEffect(Effect.flatMap(Stream.runCollect(evalWith(op.right, env, a)), (ms) => extend(a, ms))));
+	return Stream.unwrap(Effect.map(materialize(op.right, env), (rs) => {
+		const index = new SolutionIndex(rs);
+		return Stream.flatMap(left, (a) => {
+			const merged = index.candidates(a).flatMap((r) => {
+				const m = merge(a, r);
+				return m === void 0 ? [] : [m];
+			});
+			return Stream.fromIterableEffect(extend(a, merged));
+		});
+	}));
+};
+const evalMinus = (op, env) => Stream.unwrap(Effect.map(materialize(op.right, env), (rs) => Stream.filter(isUnit(op.left) ? Stream.succeed(env.context) : evaluate(op.left, env), (a) => !rs.some((r) => sharesVariable(a, r) && compatible(a, r)))));
+const namedGraphs = (env) => env.dataset.namedGraphs === "all" ? Stream.runCollect(env.store.graphs) : Effect.succeed(env.dataset.namedGraphs);
+const evalGraph = (op, env) => {
+	const name = op.name;
+	if (isNamedNode(name)) return Stream.unwrap(Effect.map(namedGraphs(env), (graphs) => graphs.some((g) => g.key === name.key) ? evaluate(op.input, {
+		...env,
+		graph: {
+			_tag: "NamedGraph",
+			graph: name
+		}
+	}) : Stream.empty));
+	const variable = name.value;
+	return Stream.unwrap(Effect.map(namedGraphs(env), (graphs) => concatAll(graphs.map((g) => evaluate(op.input, {
+		...env,
+		graph: {
+			_tag: "NamedGraph",
+			graph: g
+		}
+	}).pipe(Stream.filterMap((b) => {
+		const m = merge(b, new Bindings(fromEntries([[variable, g]])));
+		return m === void 0 ? Result.fail(void 0) : Result.succeed(m);
+	}))))));
+};
+const integerLiteral = (n) => new Literal(String(n), dt.integer);
+/** An aggregate over a group's members; `None` leaves it unbound. */
+const aggregateValue = (agg, members, env) => {
+	if (agg.expression === "*") {
+		if (agg.name !== "COUNT") return Option.none();
+		const n = agg.distinct ? setOf(members.map((m) => m.key)).size : members.length;
+		return Option.some(integerLiteral(n));
+	}
+	const expr = agg.expression;
+	const evaluated = members.map((m) => Option.fromUndefinedOr(evaluateOrUndefined(expr, m, env.expr)));
+	const seen = emptySet();
+	const values = agg.distinct ? evaluated.filter((v) => {
+		const k = Option.isNone(v) ? "" : v.value.key;
+		if (seen.has(k)) return false;
+		seen.set(k, true);
+		return true;
+	}) : evaluated;
+	const defined = Arr.getSomes(values);
+	return Option.flatten(Result.getSuccess(catchEvalFailure(() => aggregateOf(agg, values.length, defined))));
+};
+const sum = (values) => values.reduce((acc, v) => arithmetic("+", acc, v), integerLiteral(0));
+/**
+* An aggregate of the values that evaluated (`defined`, of `count`
+* members); `None` leaves it unbound.
+*/
+const aggregateOf = (agg, count, defined) => {
+	const complete = defined.length === count;
+	return Match.value(agg.name).pipe(Match.when("COUNT", () => Option.some(integerLiteral(defined.length))), Match.when("SUM", () => complete ? Option.some(sum(defined)) : Option.none()), Match.when("AVG", () => {
+		if (!complete) return Option.none();
+		if (Arr.isReadonlyArrayEmpty(defined)) return Option.some(integerLiteral(0));
+		return Option.some(arithmetic("/", sum(defined), integerLiteral(defined.length)));
+	}), Match.when(Match.is("MIN", "MAX"), (name) => Option.map(Arr.head(defined), (first) => defined.slice(1).reduce((best, v) => {
+		const c = compareTerms(v, best);
+		return (name === "MIN" ? c < 0 : c > 0) ? v : best;
+	}, first))), Match.when("SAMPLE", () => Arr.head(defined)), Match.when("GROUP_CONCAT", () => {
+		if (!complete) return Option.none();
+		const lits = defined.map((v) => isLiteral(v) ? v : fail("Not a literal"));
+		const sep = agg.separator ?? " ";
+		return Option.some(simple(lits.map((l) => l.value).join(sep)));
+	}), Match.exhaustive);
+};
+/** Evaluates an expression per solution; `None` on errors. */
+const evaluateOption = (expression, b, ctx) => Option.fromUndefinedOr(evaluateOrUndefined(expression, b, ctx));
+const evalGroup = (op, env) => Stream.fromIterableEffect(Effect.map(materialize(op.input, env), (solutions) => {
+	const groups = empty();
+	solutions.forEach((s) => {
+		const keys = op.keys.map((k) => evaluateOption(k.expression, s, env.expr));
+		const id = keys.map((k) => Option.isNone(k) ? "" : k.value.key).join("
");
+		const g = groups.get(id);
+		if (g === void 0) groups.set(id, {
+			keys,
+			members: [s]
+		});
+		else g.members.push(s);
+	});
+	if (groups.size === 0 && Arr.isReadonlyArrayEmpty(op.keys)) groups.set("", {
+		keys: [],
+		members: []
+	});
+	return Array.from(groups.values(), (g) => {
+		const map = empty();
+		Arr.zip(op.keys, g.keys).forEach(([k, v]) => {
+			if (Option.isSome(v)) map.set(k.variable.value, v.value);
+		});
+		op.aggregates.forEach((a) => {
+			const v = aggregateValue(a.aggregate, g.members, env);
+			if (Option.isSome(v)) map.set(a.variable.value, v.value);
+		});
+		return new Bindings(map);
+	});
+}));
+const unbound = Option.none();
+const evalOrderBy = (op, env) => Stream.fromIterableEffect(Effect.map(materialize(op.input, env), (solutions) => {
+	const keyed = solutions.map((s) => ({
+		s,
+		keys: op.conditions.map((c) => evaluateOption(c.expression, s, env.expr))
+	}));
+	const byConditions = Order.make((a, b) => {
+		let order = 0;
+		op.conditions.some((condition, i) => {
+			const c = orderCompare(a.keys[i] ?? unbound, b.keys[i] ?? unbound);
+			if (c === 0) return false;
+			order = c < 0 === condition.descending ? 1 : -1;
+			return true;
+		});
+		return order;
+	});
+	return Arr.sort(keyed, byConditions).map((k) => k.s);
+}));
+const evalExtend = (op, env) => {
+	const name = op.variable.value;
+	const ctxFor = prepare(op.expression, env);
+	const input = isUnit(op.input) ? Stream.succeed(env.context) : evaluate(op.input, env);
+	return Stream.mapEffect(input, (b) => Effect.map(ctxFor(b), (ctx) => {
+		if (b.map.has(name)) return b;
+		const v = evaluateOrUndefined(op.expression, b, ctx);
+		return v === void 0 ? b : set(b, name, v);
+	}));
+};
+const runService = (op, env, endpoint) => {
+	const handler = env.service;
+	const stream = Option.isNone(handler) ? Stream.fail(new EvaluationError({ message: `SERVICE <${endpoint.value}> is not supported` })) : handler.value(endpoint, op, env);
+	return op.silent ? Stream.catchCause(stream, () => Stream.succeed(empty$1)) : stream;
+};
+const evalService = (op, env) => {
+	const name = op.name;
+	if (isVariable(name)) return Stream.fail(new EvaluationError({ message: `SERVICE ?${name.value} needs the endpoint variable to be bound first` }));
+	return runService(op, env, name);
+};
+/**
+* `SERVICE ?endpoint { … }` with `?endpoint` bound by an earlier pattern:
+* the remote pattern is evaluated at the bound endpoint and joined with the
+* solution.
+*/
+const mergeWith = (initial, solutions) => Stream.flatMap(solutions, (b) => {
+	const m = merge(initial, b);
+	return m === void 0 ? Stream.empty : Stream.succeed(m);
+});
+const evalBoundService = (op, env, initial) => {
+	const name = op.name;
+	if (isNamedNode(name)) return mergeWith(initial, runService(op, env, name));
+	const endpoint = initial.map.get(name.value);
+	if (!isNamedNode(endpoint)) return op.silent ? Stream.succeed(initial) : Stream.fail(new EvaluationError({ message: `SERVICE ?${name.value} is not bound to an IRI` }));
+	return mergeWith(initial, runService(op, env, endpoint));
+};
+/** Evaluates an algebra operator, offering it to the store's query capability first. */
+const evaluate = (op, env) => {
+	const capability = env.store.query;
+	if (capability !== void 0 && env.context.size === 0) {
+		const native = capability.evaluate(op, {
+			dataset: env.dataset,
+			activeGraph: env.graph,
+			evaluate: (o, g) => evaluate(o, g === void 0 ? env : {
+				...env,
+				graph: g
+			})
+		});
+		if (Option.isSome(native)) return native.value;
+	}
+	return evaluateGeneric(op, env);
+};
+const evalDistinct = (op, env) => Stream.suspend(() => {
+	const seen = emptySet();
+	return Stream.filter(evaluate(op.input, env), (b) => {
+		const k = b.key;
+		if (seen.has(k)) return false;
+		seen.set(k, true);
+		return true;
+	});
+});
+const evalSlice = (op, env) => {
+	const input = evaluate(op.input, env);
+	const dropped = op.offset > 0 ? Stream.drop(input, op.offset) : input;
+	return op.limit !== void 0 ? Stream.take(dropped, op.limit) : dropped;
+};
+/**
+* Evaluates an operator by its kind. Plain branches rather than `Match`:
+* `EXISTS` patterns and bind joins run it once per solution.
+*/
+const evaluateGeneric = (op, env) => {
+	if (Predicate.isTagged(op, "Bgp")) return evalBgp(op.patterns, env, Arr.isReadonlyArrayEmpty(op.patterns) ? env.context : empty$1);
+	if (Predicate.isTagged(op, "Join")) return evalJoin(op, env);
+	if (Predicate.isTagged(op, "Filter")) return filterStream(evaluate(op.input, env), op.expression, env);
+	if (Predicate.isTagged(op, "Project")) {
+		const names = op.variables.map((v) => v.value);
+		return Stream.map(evaluate(op.input, env), (b) => project(b, names));
+	}
+	if (Predicate.isTagged(op, "LeftJoin")) return evalLeftJoin(op, env);
+	if (Predicate.isTagged(op, "Union")) return Stream.concat(evaluate(op.left, env), evaluate(op.right, env));
+	if (Predicate.isTagged(op, "Extend")) return evalExtend(op, env);
+	if (Predicate.isTagged(op, "Path")) return evalPath(op, env, empty$1);
+	if (Predicate.isTagged(op, "Graph")) return evalGraph(op, env);
+	if (Predicate.isTagged(op, "Minus")) return evalMinus(op, env);
+	if (Predicate.isTagged(op, "Group")) return evalGroup(op, env);
+	if (Predicate.isTagged(op, "OrderBy")) return evalOrderBy(op, env);
+	if (Predicate.isTagged(op, "Distinct") || Predicate.isTagged(op, "Reduced")) return evalDistinct(op, env);
+	if (Predicate.isTagged(op, "Slice")) return evalSlice(op, env);
+	if (Predicate.isTagged(op, "Values")) return Stream.fromIterable(op.bindings);
+	return evalService(op, env);
+};
+// src/sparql/Engine.ts
+/**
+* The SPARQL engine service: parses, translates, optimises and evaluates
+* queries and updates against the `QuadStore` service.
+*
+* Query evaluation is streaming: `SELECT` results are a lazy `Stream` of
+* solutions, `CONSTRUCT`/`DESCRIBE` a lazy stream of triples, and `ASK`
+* stops at the first solution. Operators that need all solutions
+* (`ORDER BY`, `GROUP BY`, the right side of joins) materialise as needed.
+*
+* @since 0.1.0
+*/
+var Engine_exports = /* @__PURE__ */ __exportAll({
+	SparqlEngine: () => SparqlEngine,
+	layer: () => layer,
+	layerMemory: () => layerMemory,
+	make: () => make
+});
+/**
+* The SPARQL engine service.
+*
+* @since 0.1.0
+* @category services
+*/
+var SparqlEngine = class extends Context.Service()("@thomasfosterau/effect-rdf/sparql/SparqlEngine") {};
+/**
+* A template term instantiated for a solution; `None` where a variable is
+* unbound or a triple term would be ill-formed. Plain branches rather than
+* `Match`: it runs for every template term per solution.
+*/
+const groundTemplateTerm = (t, b, bnodes) => {
+	if (isVariable(t)) return Option.fromUndefinedOr(b.map.get(t.value));
+	if (isBlankNode(t)) {
+		const existing = bnodes.get(t.value);
+		if (existing !== void 0) return Option.some(existing);
+		const n = blankNode();
+		bnodes.set(t.value, n);
+		return Option.some(n);
+	}
+	if (isTriple(t)) return Option.map(groundTriple(t.subject, t.predicate, t.object, b, bnodes), ([s, p, o]) => triple(s, p, o));
+	return Option.some(t);
+};
+/** The instantiated subject, predicate and object, if they form a well-formed triple. */
+const groundTriple = (subject, predicate, object, b, bnodes) => {
+	const s = groundTemplateTerm(subject, b, bnodes);
+	const p = groundTemplateTerm(predicate, b, bnodes);
+	const o = groundTemplateTerm(object, b, bnodes);
+	if (Option.isNone(s) || Option.isNone(p) || Option.isNone(o)) return Option.none();
+	const [sv, pv, ov] = [
+		s.value,
+		p.value,
+		o.value
+	];
+	return isSubject(sv) && isNamedNode(pv) && isObject(ov) ? Option.some([
+		sv,
+		pv,
+		ov
+	]) : Option.none();
+};
+/** The graph of a template quad for a solution: an IRI or the default graph. */
+const groundGraph = (t, b, bnodes, defaultGraph) => {
+	if (isDefaultGraph(t.graph)) return Option.some(defaultGraph);
+	const g = groundTemplateTerm(t.graph, b, bnodes);
+	return Option.isSome(g) && (isNamedNode(g.value) || isDefaultGraph(g.value)) ? Option.some(g.value) : Option.none();
+};
+const instantiate = (template, b, defaultGraph) => {
+	const bnodes = empty();
+	return Arr.filterMap(template, (t) => {
+		const triple = groundTriple(t.subject, t.predicate, t.object, b, bnodes);
+		const g = groundGraph(t, b, bnodes, defaultGraph);
+		if (Option.isNone(triple) || Option.isNone(g)) return Result.failVoid;
+		const [s, p, o] = triple.value;
+		return Result.succeed(new Quad(s, p, o, g.value));
+	});
+};
+/** The options of a request that gave none. */
+const noRequest = {};
+const prebind = (op, request) => request.bindings === void 0 ? op : prebind$1(op, request.bindings);
+const dedupeQuads = (quads) => Stream.suspend(() => {
+	const seen = emptySet();
+	return Stream.filter(quads, (q) => {
+		const k = q.key;
+		if (seen.has(k)) return false;
+		seen.set(k, true);
+		return true;
+	});
+});
+const describeResources = (terms, solutions, env) => {
+	const constants = terms.filter(isNamedNode);
+	const vars = terms.filter(isVariable);
+	const resources = Stream.concat(Stream.fromIterable(constants), Arr.isReadonlyArrayEmpty(vars) ? Stream.empty : Stream.flatMap(solutions, (b) => Stream.fromIterable(vars.flatMap((v) => {
+		const t = b.map.get(v.value);
+		return t === void 0 ? [] : [t];
+	}))));
+	const cbd = (resource, seen) => Stream.flatMap(matchQuads(env, { subject: resource }), (q) => {
+		const quad = new Quad(q.subject, q.predicate, q.object, defaultGraph);
+		const object = q.object;
+		if (isBlankNode(object) && !seen.has(object.key)) {
+			seen.set(object.key, true);
+			return Stream.concat(Stream.succeed(quad), cbd(object, seen));
+		}
+		return Stream.succeed(quad);
+	});
+	return dedupeQuads(Stream.suspend(() => {
+		const described = emptySet();
+		return Stream.flatMap(resources, (r) => {
+			if (described.has(r.key)) return Stream.empty;
+			described.set(r.key, true);
+			return cbd(r, setOf([r.key]));
+		});
+	}));
+};
+const updateFailed = (message) => Effect.fail(new UpdateError({ message }));
+const freshBlankNodes = (quads) => {
+	const map = empty();
+	return quads.map((q) => mapTerms(q, (t) => {
+		if (!isBlankNode(t)) return t;
+		const existing = map.get(t.value);
+		if (existing !== void 0) return existing;
+		const n = blankNode();
+		map.set(t.value, n);
+		return n;
+	}));
+};
+const quadPatternsToAlgebra = (patterns) => {
+	const byGraph = empty();
+	patterns.forEach((p) => {
+		const triple = {
+			_tag: "TriplePattern",
+			subject: p.subject,
+			predicate: p.predicate,
+			object: p.object
+		};
+		const entry = byGraph.get(p.graph.key);
+		if (entry === void 0) byGraph.set(p.graph.key, {
+			graph: p.graph,
+			triples: [triple]
+		});
+		else entry.triples.push(triple);
+	});
+	const parts = Array.from(byGraph.values()).map(({ graph, triples }) => isDefaultGraph(graph) ? bgp(triples) : {
+		_tag: "Graph",
+		name: graph,
+		input: bgp(triples)
+	});
+	return Arr.isReadonlyArrayEmpty(parts) ? unit : parts.reduce((a, b) => join(a, b));
+};
+/**
+* Creates the engine over a quad store.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (store, options = {}) => {
+	const defaultDataset = {
+		defaultGraph: options.unionDefaultGraph === true ? "union" : "default",
+		namedGraphs: "all"
+	};
+	const datasetFor = (clause, request) => Option.isSome(clause) ? {
+		defaultGraph: clause.value.default,
+		namedGraphs: clause.value.named
+	} : request.dataset ?? defaultDataset;
+	const service = Option.map(Option.fromUndefinedOr(options.service), (handler) => (endpoint, op) => handler(endpoint, op));
+	const makeEnv = (dataset, baseIri) => ({
+		store,
+		dataset,
+		graph: { _tag: "DefaultGraph" },
+		context: empty$1,
+		expr: makeContext({
+			baseIri: Option.getOrUndefined(baseIri),
+			functions: options.functions
+		}),
+		service
+	});
+	/** The base IRI of a request: its prologue's, the request's or the engine's. */
+	const baseIriFor = (request, prologue) => Option.fromUndefinedOr(prologue?.base ?? request.baseIri ?? options.baseIri);
+	const parseQuery$1 = (query, request) => Predicate.isString(query) ? parseQuery(query, {
+		baseIri: request.baseIri ?? options.baseIri,
+		prefixes: request.prefixes
+	}) : Effect.succeed(query);
+	const optimize$1 = (op, env) => options.optimize === false ? Effect.succeed(op) : optimize(op, {
+		store,
+		dataset: env.dataset,
+		graph: env.graph
+	});
+	const run = (query, request) => Effect.gen(function* () {
+		const algebra = translateQuery(query);
+		const env = makeEnv(datasetFor(Option.fromUndefinedOr(algebra.dataset), request), baseIriFor(request, query.prologue));
+		return {
+			algebra,
+			env,
+			input: yield* optimize$1(prebind(algebra.input, request), env)
+		};
+	});
+	const textAttributes = (text) => options.traceQueryText === true && Predicate.isString(text) ? { "sparql.query.text": text } : {};
+	const query = (q, request = noRequest) => Effect.gen(function* () {
+		const ast = yield* parseQuery$1(q, request);
+		const { algebra, env, input } = yield* run(ast, request);
+		yield* Effect.annotateCurrentSpan("sparql.query.form", algebra._tag);
+		const solutions = evaluate(input, env);
+		return yield* Match.value(algebra).pipe(Match.tag("Select", (s) => Effect.succeed({
+			_tag: "Select",
+			variables: s.variables,
+			bindings: solutions
+		})), Match.tag("Ask", () => Effect.map(Stream.runHead(solutions), (head) => ({
+			_tag: "Ask",
+			value: Option.isSome(head)
+		}))), Match.tag("Construct", (c) => {
+			const template = c.template.map((t) => ({
+				_tag: "QuadPattern",
+				subject: t.subject,
+				predicate: t.predicate,
+				object: t.object,
+				graph: defaultGraph
+			}));
+			return Effect.succeed({
+				_tag: "Graph",
+				quads: dedupeQuads(Stream.flatMap(solutions, (b) => Stream.fromIterable(instantiate(template, b, defaultGraph))))
+			});
+		}), Match.tag("Describe", (d) => Effect.succeed({
+			_tag: "Graph",
+			quads: describeResources(d.terms, solutions, env)
+		})), Match.exhaustive);
+	}).pipe(Effect.withSpan("SparqlEngine.query", { attributes: textAttributes(q) }));
+	const select = (q, request) => Effect.flatMap(query(q, request), (r) => Predicate.isTagged(r, "Select") ? Effect.succeed(r) : Effect.fail(new EvaluationError({ message: "Not a SELECT query" })));
+	const ask = (q, request) => Effect.flatMap(query(q, request), (r) => Predicate.isTagged(r, "Ask") ? Effect.succeed(r.value) : Effect.fail(new EvaluationError({ message: "Not an ASK query" })));
+	const construct = (q, request) => Effect.flatMap(query(q, request), (r) => Predicate.isTagged(r, "Graph") ? Effect.succeed(r.quads) : Effect.fail(new EvaluationError({ message: "Not a CONSTRUCT or DESCRIBE query" })));
+	const graphExists = (g) => isDefaultGraph(g) ? Effect.succeed(true) : store.hasGraph(g);
+	const graphQuads = (g) => Stream.runCollect(store.match({ graph: g }));
+	const clearTarget = (target, silent, drop) => Effect.gen(function* () {
+		return yield* Match.value(target).pipe(Match.tag("Default", () => store.clear(defaultGraph)), Match.tag("NamedNode", (graph) => Effect.flatMap(store.hasGraph(graph), (exists) => {
+			if (!exists) return silent ? Effect.void : updateFailed(`Graph <${graph.value}> does not exist`);
+			return drop ? store.dropGraph(graph) : store.clear(graph);
+		})), Match.tag("Named", "All", (which) => Effect.gen(function* () {
+			const graphs = yield* Stream.runCollect(store.graphs);
+			yield* Effect.forEach(graphs, (g) => drop ? store.dropGraph(g) : store.clear(g), {
+				concurrency: 1,
+				discard: true
+			});
+			if (Predicate.isTagged(which, "All")) yield* store.clear(defaultGraph);
+		})), Match.exhaustive);
+	});
+	const transfer = (op) => op.source.key === op.destination.key ? Effect.void : Effect.flatMap(graphExists(op.source), (exists) => exists ? copyGraph(op) : op.silent ? Effect.void : updateFailed(`Graph <${op.source.value}> does not exist`));
+	const copyGraph = (op) => Effect.gen(function* () {
+		const quads = yield* graphQuads(op.source);
+		const { source, destination } = op;
+		if (!Predicate.isTagged(op, "Add")) {
+			if (isDefaultGraph(destination)) yield* store.clear(defaultGraph);
+			else yield* store.dropGraph(destination);
+		}
+		if (isNamedNode(destination)) yield* store.createGraph(destination);
+		yield* store.insert(quads.map((q) => new Quad(q.subject, q.predicate, q.object, destination)));
+		if (Predicate.isTagged(op, "Move")) {
+			if (isDefaultGraph(source)) yield* store.clear(defaultGraph);
+			else yield* store.dropGraph(source);
+		}
+	});
+	const modify = (op, where, baseIri, request) => Effect.gen(function* () {
+		const dataset = op.using !== void 0 ? {
+			defaultGraph: op.using.default,
+			namedGraphs: op.using.named
+		} : op.with !== void 0 ? {
+			defaultGraph: [op.with],
+			namedGraphs: "all"
+		} : request.dataset ?? defaultDataset;
+		const env = makeEnv(dataset, baseIri);
+		const input = yield* optimize$1(prebind(where, request), env);
+		const solutions = yield* Stream.runCollect(evaluate(input, env));
+		const target = op.with ?? defaultGraph;
+		const deletes = solutions.flatMap((b) => instantiate(op.delete, b, target));
+		const inserts = solutions.flatMap((b) => instantiate(op.insert, b, target));
+		yield* store.delete(deletes);
+		yield* store.insert(inserts);
+	});
+	const executeOperation = (op, baseIri, request) => {
+		return Match.value(op).pipe(Match.tag("InsertData", (o) => store.insert(freshBlankNodes(o.quads))), Match.tag("DeleteData", (o) => store.delete(o.quads)), Match.tag("DeleteWhere", (o) => modify({
+			_tag: "Modify",
+			delete: o.patterns,
+			insert: [],
+			where: {
+				_tag: "Group",
+				patterns: []
+			}
+		}, quadPatternsToAlgebra(o.patterns), baseIri, request)), Match.tag("Modify", (o) => modify(o, translatePattern(o.where), baseIri, request)), Match.tag("Load", (o) => {
+			const loader = options.load;
+			if (loader === void 0) return o.silent ? Effect.void : updateFailed("LOAD is not supported (no loader configured)");
+			const destination = o.destination ?? defaultGraph;
+			const load = Effect.flatMap(loader(o.source), (quads) => store.insert(Array.from(quads, (q) => new Quad(q.subject, q.predicate, q.object, destination))));
+			return o.silent ? Effect.ignore(load) : load;
+		}), Match.tag("Clear", (o) => clearTarget(o.target, o.silent, false)), Match.tag("Drop", (o) => clearTarget(o.target, o.silent, true)), Match.tag("Create", (o) => Effect.flatMap(store.hasGraph(o.graph), (exists) => exists ? o.silent ? Effect.void : updateFailed(`Graph <${o.graph.value}> already exists`) : store.createGraph(o.graph))), Match.tag("Add", "Move", "Copy", (o) => transfer(o)), Match.exhaustive);
+	};
+	const update = (u, request = noRequest) => Effect.gen(function* () {
+		const ast = Predicate.isString(u) ? yield* parseUpdate(u, {
+			baseIri: request.baseIri ?? options.baseIri,
+			prefixes: request.prefixes
+		}) : u;
+		const baseIri = baseIriFor(request, ast.prologue);
+		yield* Effect.annotateCurrentSpan("sparql.update.operations", ast.operations.length);
+		yield* store.transaction(Effect.forEach(ast.operations, (op) => executeOperation(op, baseIri, request), {
+			concurrency: 1,
+			discard: true
+		}));
+	}).pipe(Effect.withSpan("SparqlEngine.update", { attributes: textAttributes(u) }));
+	const evaluate$1 = (op, request = noRequest) => evaluate(prebind(op, request), makeEnv(request.dataset ?? defaultDataset, baseIriFor(request)));
+	return {
+		query,
+		select,
+		ask,
+		construct,
+		update,
+		evaluate: evaluate$1
+	};
+};
+/**
+* A layer providing the engine over the `QuadStore` service.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layer = (options) => Layer.effect(SparqlEngine, Effect.map(Effect.service(QuadStore), (store) => make(store, options)));
+/**
+* A layer providing the engine together with an in-memory store.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerMemory = (options) => layer(options).pipe(Layer.provideMerge(layerMemory$1()));
+export { make as a, layerMemory as i, SparqlEngine as n, layer as r, Engine_exports as t };
+
+//# sourceMappingURL=Engine-DF8PN7g-.mjs.map