@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Validator-DmUfMbpL.mjs

@@ -0,0 +1,568 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, N as isBlankNode, Y as literal, Z as namedNode, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { A as objectsOf, E as match, U as union, t as DatasetSchema } from "./Dataset-BlmlcI7J.mjs";
+import { t as Vocab_exports } from "./Vocab-DceKywpq.mjs";
+import { S as toValue, v as isWellFormed } from "./Xsd-Cdgx5zRB.mjs";
+import { a as substitute, i as localName, n as display } from "./Message-CK_DGQuu.mjs";
+import { r as sh, t as SH } from "./Vocabulary-CnQl-_Z4.mjs";
+import { a as evaluate, f as toSparql, l as predicate } from "./Path-B20Yp8KE.mjs";
+import { a as isShapesGraph, i as get, o as parse, r as componentOf } from "./Shapes-18GjfyBV.mjs";
+import { t as SparqlConstraintEvaluator } from "./Sparql-BiYFMSpl.mjs";
+import { a as formatResult, i as format, l as make$1, n as ValidationReportSchema, u as makeResult } from "./ValidationReport-DBdJshW5.mjs";
+import * as Arr from "effect/Array";
+import { constVoid, identity, pipe } from "effect/Function";
+import * as Iterable from "effect/Iterable";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as Record from "effect/Record";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as BigDecimal from "effect/BigDecimal";
+// src/shacl/internal/compare.ts
+/**
+* Ordering of RDF terms following the SPARQL `<` operator, as required by the
+* SHACL value range and property pair constraint components.
+*
+* @internal
+*/
+const XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
+const toNum = Match.type().pipe(Match.tag("Integer", (v) => Option.some({
+	kind: "integer",
+	value: v.value
+})), Match.tag("Decimal", (v) => Option.some({
+	kind: "decimal",
+	value: v.value
+})), Match.tag("Float", "Double", (v) => Option.some({
+	kind: "float",
+	value: v.value
+})), Match.orElse(() => Option.none()));
+const sign = (n) => n < 0 ? -1 : n > 0 ? 1 : 0;
+const toFloat = (n) => n.kind === "float" ? n.value : Number(n.kind === "integer" ? n.value : BigDecimal.format(n.value));
+const toDecimal = (n) => n.kind === "integer" ? BigDecimal.fromBigInt(n.value) : n.value;
+const compareNum = (a, b) => {
+	if (a.kind === "float" || b.kind === "float") {
+		const x = toFloat(a);
+		const y = toFloat(b);
+		if (Number.isNaN(x) || Number.isNaN(y)) return Option.none();
+		return Option.some(sign(x - y) || (x < y ? -1 : x > y ? 1 : 0));
+	}
+	if (a.kind === "integer" && b.kind === "integer") return Option.some(a.value < b.value ? -1 : a.value > b.value ? 1 : 0);
+	return Option.some(BigDecimal.Order(toDecimal(a), toDecimal(b)));
+};
+const FOURTEEN_HOURS = 504e5;
+const order = (x, y) => x < y ? -1 : x > y ? 1 : 0;
+const isString$1 = Predicate.isTagged("String");
+const isBoolean = Predicate.isTagged("Boolean");
+const isDateTime = Predicate.isTagged("DateTime");
+const isDuration = Predicate.isTagged("Duration");
+const isOther = Predicate.isTagged("Other");
+/** Simple literals / xsd:string are ordered; language-tagged strings only when they share a tag. */
+const stringsComparable = (a, b) => a.language !== "" || b.language !== "" ? a.language.toLowerCase() === b.language.toLowerCase() : a.datatype.value === XSD_STRING && b.datatype.value === XSD_STRING;
+const none = Option.none();
+const compareDateTimes = (x, y) => {
+	if (x.kind !== y.kind) return none;
+	const d = x.epochMillis - y.epochMillis;
+	return Predicate.isUndefined(x.timezone) === Predicate.isUndefined(y.timezone) || Math.abs(d) > FOURTEEN_HOURS ? Option.some(sign(d)) : none;
+};
+const compareDurations = (x, y) => {
+	const m = sign(x.months - y.months);
+	const s = sign(x.seconds - y.seconds);
+	if (m === 0) return Option.some(s);
+	return s === 0 || s === m ? Option.some(m) : none;
+};
+const compareValues = (va, vb, a, b) => {
+	if (isString$1(va)) return isString$1(vb) && stringsComparable(a, b) ? Option.some(order(va.value, vb.value)) : none;
+	if (isBoolean(va)) return isBoolean(vb) ? Option.some(va.value === vb.value ? 0 : va.value ? 1 : -1) : none;
+	if (isDateTime(va)) return isDateTime(vb) ? compareDateTimes(va, vb) : none;
+	if (isDuration(va)) return isDuration(vb) ? compareDurations(va, vb) : none;
+	return isOther(va) && isOther(vb) && a.key === b.key ? Option.some(0) : none;
+};
+const compareLiterals = (a, b) => {
+	const va = toValue(a);
+	const vb = toValue(b);
+	const na = toNum(va);
+	const nb = toNum(vb);
+	if (Option.isSome(na) && Option.isSome(nb)) return compareNum(na.value, nb.value);
+	if (Option.isSome(na) || Option.isSome(nb)) return Option.none();
+	return compareValues(va, vb, a, b);
+};
+/**
+* Compares two terms. Returns `None` when they are not comparable (in which
+* case every SPARQL comparison yields an error, i.e. false).
+*
+* @internal
+*/
+const compareTerms = (a, b) => isLiteral(a) && isLiteral(b) ? compareLiterals(a, b) : Option.none();
+// src/shacl/Validator.ts
+/**
+* SHACL Core validation (§3–§4): validates a data graph against a shapes
+* graph and produces a `ValidationReport`.
+*
+* ```ts
+* import { Effect } from "effect"
+* import { Validator, ValidationReport } from "@thomasfosterau/effect-rdf/shacl"
+*
+* const program = Effect.gen(function* () {
+*   const report = yield* Validator.validate(dataGraph, shapesGraph)
+*   console.log(ValidationReport.format(report))
+* })
+* ```
+*
+* The `Validator` service pre-compiles a shapes graph once and validates many
+* data graphs against it:
+*
+* ```ts
+* const program = Effect.gen(function* () {
+*   const validator = yield* Validator.Validator
+*   const ok = yield* validator.conforms(dataGraph)
+* }).pipe(Effect.provide(Validator.layer(shapesGraph)))
+* ```
+*
+* @since 0.1.0
+*/
+var Validator_exports = /* @__PURE__ */ __exportAll({
+	ConformanceError: () => ConformanceError,
+	RecursiveShapeError: () => RecursiveShapeError,
+	UnsupportedFeatureError: () => UnsupportedFeatureError,
+	Validator: () => Validator,
+	assertConforms: () => assertConforms,
+	conforms: () => conforms,
+	layer: () => layer,
+	make: () => make,
+	schema: () => schema,
+	severities: () => severities,
+	validate: () => validate,
+	validateNode: () => validateNode
+});
+/** A string as a JSON string literal, for messages. */
+const quote = Schema.encodeSync(Schema.fromJsonString(Schema.String));
+const { rdf, rdfs, xsd } = Vocab_exports;
+/**
+* Validation reached a shape again for the same focus node while still
+* validating it (a recursive shape). The SHACL specification leaves the
+* validation of recursive shapes undefined.
+*
+* @since 0.1.0
+* @category errors
+*/
+var RecursiveShapeError = class extends Schema.TaggedError()("RecursiveShapeError", {
+	message: Schema.String,
+	shape: Schema.String,
+	focusNode: Schema.String
+}) {};
+/**
+* The shapes graph uses a feature this validator cannot evaluate (currently:
+* SHACL-SPARQL constraints and targets when no
+* `Sparql.SparqlConstraintEvaluator` is provided).
+*
+* @since 0.1.0
+* @category errors
+*/
+var UnsupportedFeatureError = class extends Schema.TaggedError()("UnsupportedFeatureError", {
+	message: Schema.String,
+	feature: Schema.String,
+	shape: Schema.String
+}) {};
+/**
+* The data graph does not conform to the shapes graph (raised by
+* `Validator.check` and `assertConforms`).
+*
+* @since 0.1.0
+* @category errors
+*/
+var ConformanceError = class extends Schema.TaggedError()("ConformanceError", {
+	message: Schema.String,
+	report: ValidationReportSchema
+}) {};
+const langMatches = (tag, range) => {
+	if (tag === "") return false;
+	if (range === "*") return true;
+	const t = tag.toLowerCase();
+	const r = range.toLowerCase();
+	return t === r || t.startsWith(`${r}-`);
+};
+const IRI = Option.some("IRI");
+const BLANK_NODE = Option.some("BlankNode");
+const LITERAL = Option.some("Literal");
+const nodeKindOf = (t) => isNamedNode(t) ? IRI : isBlankNode(t) ? BLANK_NODE : isLiteral(t) ? LITERAL : Option.none();
+const matchesNodeKind = (t, kind) => Option.exists(nodeKindOf(t), (k) => kind.includes(k));
+const hasDatatype = (v, datatype) => {
+	if (!isLiteral(v) || v.datatype.value !== datatype.value) return false;
+	if (datatype.value === rdf.langString.value || datatype.value === rdf.dirLangString.value) return v.language !== "";
+	if (v.language !== "") return false;
+	return isWellFormed(v);
+};
+const stringValue = (v) => isNamedNode(v) || isLiteral(v) ? Option.some(v.value) : Option.none();
+/** Whether a value node has no string value, or one that fails `ok`. */
+const failsString = (v, ok) => !Option.exists(stringValue(v), ok);
+const show = (t) => t.key;
+/** A high surrogate and the code unit after it: one code point. */
+const surrogatePair = /[\uD800-\uDBFF][\s\S]/g;
+/** The length of a string in Unicode code points (as XPath `fn:string-length`). */
+const codePointLength = (s) => s.replace(surrogatePair, "_").length;
+/** Whether `a` and `b` are comparable and their order satisfies `ok`. */
+const ordered = (a, b, ok) => Option.exists(compareTerms(a, b), ok);
+const defaultMessage = (constraint, value) => {
+	const v = Option.match(value, {
+		onNone: () => "Value",
+		onSome: (t) => `Value ${show(t)}`
+	});
+	return Match.value(constraint).pipe(Match.tag("Class", (c) => `${v} is not an instance of ${show(c.class)}`), Match.tag("Datatype", (c) => `${v} does not have datatype ${show(c.datatype)}`), Match.tag("NodeKind", (c) => `${v} does not have node kind sh:${c.nodeKind}`), Match.tag("MinCount", (c) => `Less than ${c.minCount} values`), Match.tag("MaxCount", (c) => `More than ${c.maxCount} values`), Match.tag("MinExclusive", (c) => `${v} is not greater than ${show(c.value)}`), Match.tag("MinInclusive", (c) => `${v} is not greater than or equal to ${show(c.value)}`), Match.tag("MaxExclusive", (c) => `${v} is not less than ${show(c.value)}`), Match.tag("MaxInclusive", (c) => `${v} is not less than or equal to ${show(c.value)}`), Match.tag("MinLength", (c) => `${v} is shorter than ${c.minLength} characters`), Match.tag("MaxLength", (c) => `${v} is longer than ${c.maxLength} characters`), Match.tag("Pattern", (c) => `${v} does not match pattern ${quote(c.pattern)}`), Match.tag("LanguageIn", (c) => `${v} does not have a language tag in [${c.languages.join(", ")}]`), Match.tag("UniqueLang", () => "Language tag used by more than one value"), Match.tag("Equals", (c) => `${v} is not equal to the values of ${show(c.predicate)}`), Match.tag("Disjoint", (c) => `${v} is also a value of ${show(c.predicate)}`), Match.tag("LessThan", (c) => `${v} is not less than the values of ${show(c.predicate)}`), Match.tag("LessThanOrEquals", (c) => `${v} is not less than or equal to the values of ${show(c.predicate)}`)).pipe(Match.tag("Not", (c) => `${v} conforms to the negated shape ${show(c.shape)}`), Match.tag("And", () => `${v} does not conform to all of the shapes`), Match.tag("Or", () => `${v} does not conform to any of the shapes`), Match.tag("Xone", () => `${v} does not conform to exactly one of the shapes`), Match.tag("Node", (c) => `${v} does not conform to shape ${show(c.shape)}`), Match.tag("Property", (c) => `${v} does not conform to property shape ${show(c.shape)}`), Match.tag("QualifiedMinCount", (c) => `Less than ${c.count} values conform to shape ${show(c.shape)}`), Match.tag("QualifiedMaxCount", (c) => `More than ${c.count} values conform to shape ${show(c.shape)}`), Match.tag("Closed", () => `Predicate is not allowed by the closed shape (value ${Option.match(value, {
+		onNone: () => "",
+		onSome: show
+	})})`), Match.tag("HasValue", (c) => `Missing expected value ${show(c.value)}`), Match.tag("In", () => `${v} is not one of the allowed values`), Match.tag("Sparql", "Component", () => `${v} violates a SPARQL-based constraint`), Match.exhaustive);
+};
+const integer = (n) => literal(String(n), xsd.integer);
+const boolean = (b) => literal(String(b), xsd.boolean);
+const listText = (terms) => literal(terms.map(display).join(", "));
+/** The parameter values of a core constraint by parameter name (for message templates). */
+const coreParameters = (constraint) => {
+	return Match.value(constraint).pipe(Match.withReturnType(), Match.tag("Class", (c) => [["class", c.class]]), Match.tag("Datatype", (c) => [["datatype", c.datatype]]), Match.tag("NodeKind", (c) => [["nodeKind", namedNode(SH + c.nodeKind)]]), Match.tag("MinCount", (c) => [["minCount", integer(c.minCount)]]), Match.tag("MaxCount", (c) => [["maxCount", integer(c.maxCount)]]), Match.tag("MinExclusive", (c) => [["minExclusive", c.value]]), Match.tag("MinInclusive", (c) => [["minInclusive", c.value]]), Match.tag("MaxExclusive", (c) => [["maxExclusive", c.value]]), Match.tag("MaxInclusive", (c) => [["maxInclusive", c.value]]), Match.tag("MinLength", (c) => [["minLength", integer(c.minLength)]]), Match.tag("MaxLength", (c) => [["maxLength", integer(c.maxLength)]]), Match.tag("Pattern", (c) => [["pattern", literal(c.pattern)], ["flags", literal(c.flags)]]), Match.tag("LanguageIn", (c) => [["languageIn", literal(c.languages.join(", "))]]), Match.tag("UniqueLang", () => [["uniqueLang", boolean(true)]]), Match.tag("Equals", (c) => [["equals", c.predicate]]), Match.tag("Disjoint", (c) => [["disjoint", c.predicate]]), Match.tag("LessThan", (c) => [["lessThan", c.predicate]]), Match.tag("LessThanOrEquals", (c) => [["lessThanOrEquals", c.predicate]])).pipe(Match.tag("Not", (c) => [["not", c.shape]]), Match.tag("And", (c) => [["and", listText(c.shapes)]]), Match.tag("Or", (c) => [["or", listText(c.shapes)]]), Match.tag("Xone", (c) => [["xone", listText(c.shapes)]]), Match.tag("Node", (c) => [["node", c.shape]]), Match.tag("Property", (c) => [["property", c.shape]]), Match.tag("QualifiedMinCount", (c) => [
+		["qualifiedValueShape", c.shape],
+		["qualifiedMinCount", integer(c.count)],
+		["qualifiedValueShapesDisjoint", boolean(c.disjoint)]
+	]), Match.tag("QualifiedMaxCount", (c) => [
+		["qualifiedValueShape", c.shape],
+		["qualifiedMaxCount", integer(c.count)],
+		["qualifiedValueShapesDisjoint", boolean(c.disjoint)]
+	]), Match.tag("Closed", (c) => [["closed", boolean(true)], ["ignoredProperties", listText(c.ignoredProperties)]]), Match.tag("HasValue", (c) => [["hasValue", c.value]]), Match.tag("In", (c) => [["in", listText(c.values)]]), Match.tag("Sparql", () => []), Match.tag("Component", (c) => c.parameters.map((p) => [localName(p.path), p.value])), Match.exhaustive);
+};
+/** The `path` variable of message templates: the predicate, or the path in SPARQL syntax. */
+const pathTerm = (path) => Predicate.isTagged(path, "PredicatePath") ? path.predicate : literal(toSparql(path));
+/** Substitutes `{?var}` / `{$var}` placeholders of result messages. */
+const substituteMessages = (messages, lookup) => messages.map((m) => substitute(m, (name) => Option.getOrUndefined(lookup(name))));
+/** The value of the last parameter of that name. */
+const parameterNamed = (parameters, name) => Option.map(Arr.findLast(parameters, ([n]) => n === name), ([, t]) => t);
+/** The built-in template variables `this`, `value` and `path`. */
+const builtinVariable = (name, focus, value, resultPath) => Match.value(name).pipe(Match.withReturnType(), Match.when("this", () => Option.some(Option.some(focus))), Match.when("value", () => Option.some(value)), Match.when("path", () => Option.some(Option.map(resultPath, pathTerm))), Match.orElse(() => Option.none()));
+const noValue = Option.none();
+const keysOf = (terms) => MutableHashSet.fromIterable(Arr.map(terms, (t) => t.key));
+const addNew = (out) => (t) => {
+	if (!MutableHashMap.has(out, t.key)) MutableHashMap.set(out, t.key, t);
+};
+const valuesOf = (nodes) => Arr.fromIterable(MutableHashMap.values(nodes));
+const andFails = (conforming, members) => conforming < members;
+const orFails = (conforming) => conforming === 0;
+const xoneFails = (conforming) => conforming !== 1;
+const makeEngine = (data, shapes, options, evaluator) => {
+	const memo = MutableHashMap.empty();
+	const active = MutableHashSet.empty();
+	const superClassCache = MutableHashMap.empty();
+	const withDetails = options.details === true;
+	const computeSuperClasses = (cls) => {
+		const seen = MutableHashSet.make(cls.key);
+		const unseen = (sup) => {
+			if (MutableHashSet.has(seen, sup.key)) return false;
+			MutableHashSet.add(seen, sup.key);
+			return true;
+		};
+		const nextLevel = (frontier) => Arr.isReadonlyArrayEmpty(frontier) ? Option.none() : Option.some([void 0, Arr.flatMap(frontier, (c) => isLiteral(c) ? [] : Arr.filter(objectsOf(data, c, rdfs.subClassOf), unseen))]);
+		Iterable.forEach(Iterable.unfold([cls], nextLevel), constVoid);
+		MutableHashMap.set(superClassCache, cls.key, seen);
+		return seen;
+	};
+	const superClassesOf = (cls) => Option.getOrElse(MutableHashMap.get(superClassCache, cls.key), () => computeSuperClasses(cls));
+	const isInstanceOf = (node, cls) => !isLiteral(node) && objectsOf(data, node, rdf.type).some((t) => MutableHashSet.has(superClassesOf(t), cls.key));
+	const instancesOf = (cls) => {
+		const out = MutableHashMap.empty();
+		Arr.forEach(match(data, { predicate: rdf.type }), (q) => {
+			if (!MutableHashMap.has(out, q.subject.key) && MutableHashSet.has(superClassesOf(q.object), cls.key)) MutableHashMap.set(out, q.subject.key, q.subject);
+		});
+		return valuesOf(out);
+	};
+	const objectsOf$1 = (s, p) => isLiteral(s) ? [] : objectsOf(data, s, p);
+	const shapeById = (id) => Option.getOrElse(get(shapes, id), () => ({
+		_tag: "NodeShape",
+		id,
+		targets: [],
+		constraints: [],
+		severity: sh.Violation,
+		messages: [],
+		deactivated: false
+	}));
+	const unsupported = (shape, feature) => options.sparql === "ignore" ? Effect.succeed([]) : Effect.fail(new UnsupportedFeatureError({
+		message: `${feature} used by shape ${shape.id.key} requires a SparqlConstraintEvaluator`,
+		feature,
+		shape: shape.id.key
+	}));
+	const recursive = (shape, focus) => options.recursion === "ignore" ? Effect.succeed([]) : Effect.fail(new RecursiveShapeError({
+		message: `shape ${shape.id.key} is recursive for focus node ${focus.key}`,
+		shape: shape.id.key,
+		focusNode: focus.key
+	}));
+	const validateShape = (shape, focus) => Effect.suspend(() => {
+		if (shape.deactivated) return Effect.succeed([]);
+		const key = `${shape.id.key} ${focus.key}`;
+		const cached = MutableHashMap.get(memo, key);
+		if (Option.isSome(cached)) return Effect.succeed(cached.value);
+		if (MutableHashSet.has(active, key)) return recursive(shape, focus);
+		MutableHashSet.add(active, key);
+		const valueNodes = Predicate.isTagged(shape, "PropertyShape") ? evaluate(data, focus, shape.path) : [focus];
+		return Effect.forEach(shape.constraints, (c) => evaluate$1(shape, focus, valueNodes, c), { concurrency: 1 }).pipe(Effect.map((rs) => {
+			const results = rs.flat();
+			MutableHashSet.remove(active, key);
+			MutableHashMap.set(memo, key, results);
+			return results;
+		}));
+	});
+	const conforms = (id, node) => Effect.map(validateShape(shapeById(id), node), (rs) => Arr.isReadonlyArrayEmpty(rs));
+	const nestedResults = (id, v) => validateShape(shapeById(id), v);
+	const evaluate$1 = Effect.fnUntraced(function* (shape, focus, valueNodes, constraint) {
+		const component = componentOf(constraint);
+		const shapePath = Predicate.isTagged(shape, "PropertyShape") ? Option.some(shape.path) : Option.none();
+		const parameters = coreParameters(constraint);
+		const result = (value, extra = {}) => {
+			const resultPath = extra.path === void 0 ? shapePath : Option.some(extra.path);
+			return makeResult({
+				focusNode: focus,
+				sourceShape: shape.id,
+				sourceConstraintComponent: component,
+				severity: shape.severity,
+				resultPath,
+				value,
+				messages: Arr.isReadonlyArrayNonEmpty(shape.messages) ? substituteMessages(shape.messages, (name) => Option.getOrElse(builtinVariable(name, focus, value, resultPath), () => parameterNamed(parameters, name))) : [literal(defaultMessage(constraint, value))],
+				details: withDetails ? extra.details ?? [] : []
+			});
+		};
+		const each = (failed) => valueNodes.filter(failed).map((v) => result(Option.some(v)));
+		const logical = (members, fails) => Effect.map(Effect.forEach(valueNodes, (v) => Effect.map(Effect.forEach(members, (s) => nestedResults(s, v), { concurrency: 1 }), (nested) => {
+			const conforming = nested.filter((rs) => Arr.isReadonlyArrayEmpty(rs)).length;
+			return fails(conforming, members.length) ? [result(Option.some(v), { details: nested.flat() })] : [];
+		}), { concurrency: 1 }), (perNode) => perNode.flat());
+		const qualifiedCount = (c) => Effect.map(Effect.filter(valueNodes, (v) => Effect.flatMap(conforms(c.shape, v), (ok) => !ok || !c.disjoint ? Effect.succeed(ok) : Effect.map(Effect.findFirst(c.siblings, (s) => conforms(s, v)), Option.isNone))), (counted) => counted.length);
+		const lessThan = (predicate, ok) => Effect.sync(() => {
+			const others = objectsOf$1(focus, predicate);
+			return Arr.flatMap(valueNodes, (v) => Arr.map(Arr.filter(others, (o) => !ordered(v, o, ok)), () => result(Option.some(v))));
+		});
+		return yield* Match.value(constraint).pipe(Match.tag("Class", (c) => Effect.sync(() => each((v) => !isInstanceOf(v, c.class)))), Match.tag("Datatype", (c) => Effect.sync(() => each((v) => !hasDatatype(v, c.datatype)))), Match.tag("NodeKind", (c) => Effect.sync(() => each((v) => !matchesNodeKind(v, c.nodeKind)))), Match.tag("MinCount", (c) => Effect.sync(() => valueNodes.length < c.minCount ? [result(noValue)] : [])), Match.tag("MaxCount", (c) => Effect.sync(() => valueNodes.length > c.maxCount ? [result(noValue)] : [])), Match.tag("MinExclusive", (c) => Effect.sync(() => each((v) => !ordered(v, c.value, (s) => s === 1)))), Match.tag("MinInclusive", (c) => Effect.sync(() => each((v) => !ordered(v, c.value, (s) => s !== -1)))), Match.tag("MaxExclusive", (c) => Effect.sync(() => each((v) => !ordered(v, c.value, (s) => s === -1)))), Match.tag("MaxInclusive", (c) => Effect.sync(() => each((v) => !ordered(v, c.value, (s) => s !== 1)))), Match.tag("MinLength", (c) => Effect.sync(() => each((v) => failsString(v, (s) => codePointLength(s) >= c.minLength)))), Match.tag("MaxLength", (c) => Effect.sync(() => each((v) => failsString(v, (s) => codePointLength(s) <= c.maxLength)))), Match.tag("Pattern", (c) => Effect.sync(() => each((v) => failsString(v, (s) => c.regex.test(s))))), Match.tag("LanguageIn", (c) => Effect.sync(() => each((v) => !isLiteral(v) || !c.languages.some((range) => langMatches(v.language, range))))), Match.tag("UniqueLang", () => Effect.sync(() => {
+			const languages = Arr.flatMap(valueNodes, (v) => isLiteral(v) && v.language !== "" ? [v.language.toLowerCase()] : []);
+			return Arr.map(Arr.filter(Record.values(Arr.groupBy(languages, identity)), (g) => g.length > 1), () => result(noValue));
+		})), Match.tag("Equals", (c) => Effect.sync(() => {
+			const others = objectsOf$1(focus, c.predicate);
+			const otherKeys = keysOf(others);
+			const valueKeys = keysOf(valueNodes);
+			return [...valueNodes.filter((v) => !MutableHashSet.has(otherKeys, v.key)).map((v) => result(Option.some(v))), ...others.filter((o) => !MutableHashSet.has(valueKeys, o.key)).map((o) => result(Option.some(o)))];
+		})), Match.tag("Disjoint", (c) => Effect.sync(() => {
+			const otherKeys = keysOf(objectsOf$1(focus, c.predicate));
+			return each((v) => MutableHashSet.has(otherKeys, v.key));
+		})), Match.tag("LessThan", (c) => lessThan(c.predicate, (s) => s === -1)), Match.tag("LessThanOrEquals", (c) => lessThan(c.predicate, (s) => s !== 1)), Match.tag("Not", (c) => Effect.gen(function* () {
+			return (yield* Effect.filter(valueNodes, (v) => conforms(c.shape, v))).map((v) => result(Option.some(v)));
+		}))).pipe(Match.tag("And", (c) => logical(c.shapes, andFails)), Match.tag("Or", (c) => logical(c.shapes, orFails)), Match.tag("Xone", (c) => logical(c.shapes, xoneFails)), Match.tag("Node", (c) => Effect.gen(function* () {
+			const nested = c.shape;
+			return (yield* Effect.forEach(valueNodes, (v) => Effect.map(nestedResults(nested, v), (rs) => Arr.isReadonlyArrayNonEmpty(rs) ? [result(Option.some(v), { details: rs })] : []), { concurrency: 1 })).flat();
+		})), Match.tag("Property", (c) => Effect.gen(function* () {
+			const property = shapeById(c.shape);
+			return (yield* Effect.forEach(valueNodes, (v) => validateShape(property, v), { concurrency: 1 })).flat();
+		})), Match.tag("QualifiedMinCount", (c) => Effect.map(qualifiedCount(c), (count) => count < c.count ? [result(noValue)] : [])), Match.tag("QualifiedMaxCount", (c) => Effect.map(qualifiedCount(c), (count) => count > c.count ? [result(noValue)] : [])), Match.tag("Closed", (c) => Effect.sync(() => {
+			const allowed = keysOf(c.allowedProperties);
+			return Arr.flatMap(valueNodes, (v) => isLiteral(v) ? [] : Arr.flatMap(match(data, { subject: v }), (q) => MutableHashSet.has(allowed, q.predicate.key) ? [] : [result(Option.some(q.object), { path: predicate(q.predicate) })]));
+		})), Match.tag("HasValue", (c) => Effect.sync(() => valueNodes.some((v) => v.key === c.value.key) ? [] : [result(noValue)])), Match.tag("In", (c) => Effect.sync(() => {
+			const allowed = keysOf(c.values);
+			return each((v) => !MutableHashSet.has(allowed, v.key));
+		})), Match.tag("Sparql", "Component", (c) => Effect.gen(function* () {
+			if (Option.isNone(evaluator)) return yield* unsupported(shape, Predicate.isTagged(c, "Sparql") ? "sh:sparql" : `constraint component ${c.component.key}`);
+			return (yield* evaluator.value.evaluateConstraint({
+				dataGraph: data,
+				shapesGraph: shapes,
+				shape,
+				constraint: c,
+				focusNode: focus,
+				valueNodes
+			})).map((violation) => {
+				const focusNode = violation.focusNode ?? focus;
+				const value = Option.fromNullishOr(violation.value);
+				const resultPath = violation.path !== void 0 ? Option.some(violation.path) : shapePath;
+				const lookup = (name) => pipe(Option.fromNullishOr(violation.bindings?.get(name)), Option.orElse(() => parameterNamed(parameters, name)), Option.orElse(() => Option.flatten(builtinVariable(name, focusNode, value, resultPath))));
+				const templates = violation.messages !== void 0 && Arr.isReadonlyArrayNonEmpty(violation.messages) ? violation.messages : shape.messages;
+				return makeResult({
+					focusNode,
+					sourceShape: shape.id,
+					sourceConstraintComponent: component,
+					sourceConstraint: Predicate.isTagged(c, "Sparql") ? Option.some(c.node) : Option.none(),
+					severity: violation.severity ?? shape.severity,
+					resultPath,
+					value,
+					messages: Arr.isReadonlyArrayNonEmpty(templates) ? substituteMessages(templates, lookup) : [literal(defaultMessage(c, value))]
+				});
+			});
+		})), Match.exhaustive);
+	});
+	return {
+		validateShape,
+		focusNodes: Effect.fnUntraced(function* (shape) {
+			const out = MutableHashMap.empty();
+			const add = addNew(out);
+			yield* Effect.forEach(shape.targets, Effect.fnUntraced(function* (target) {
+				yield* Match.value(target).pipe(Match.tag("TargetNode", (t) => Effect.sync(() => add(t.node))), Match.tag("TargetClass", (t) => Effect.sync(() => Arr.forEach(instancesOf(t.class), add))), Match.tag("TargetSubjectsOf", (t) => Effect.sync(() => Arr.forEach(match(data, { predicate: t.predicate }), (q) => add(q.subject)))), Match.tag("TargetObjectsOf", (t) => Effect.sync(() => Arr.forEach(match(data, { predicate: t.predicate }), (q) => add(q.object)))), Match.tag("SparqlTarget", (t) => Option.match(evaluator, {
+					onNone: () => unsupported(shape, "sh:target"),
+					onSome: (ev) => Effect.map(ev.selectTargets({
+						dataGraph: data,
+						shapesGraph: shapes,
+						shape,
+						target: t.node
+					}), (nodes) => Arr.forEach(nodes, add))
+				})), Match.exhaustive);
+			}), {
+				concurrency: 1,
+				discard: true
+			});
+			return valuesOf(out);
+		})
+	};
+};
+const resolveShapes = (shapes) => isShapesGraph(shapes) ? Effect.succeed(shapes) : parse(shapes);
+/** Parses the shapes graph (if needed) and builds the engine over the data graph. */
+const prepare = Effect.fnUntraced(function* (dataGraph, shapesGraph, options) {
+	const shapes = yield* resolveShapes(shapesGraph);
+	const data = options.includeShapesGraph === true ? union(dataGraph, shapes.dataset) : dataGraph;
+	const evaluator = yield* Effect.serviceOption(SparqlConstraintEvaluator);
+	return {
+		shapes,
+		engine: makeEngine(data, shapes, options, evaluator)
+	};
+});
+/**
+* Validates a data graph against a shapes graph (either an RDF dataset, which
+* is parsed first, or a pre-parsed `Shapes.ShapesGraph`).
+*
+* SPARQL-based constraints and targets are delegated to a
+* `Sparql.SparqlConstraintEvaluator` when one is present in the context.
+*
+* @since 0.1.0
+* @category validation
+*/
+const validate = Effect.fn("Shacl.validate")(function* (dataGraph, shapesGraph, options = {}) {
+	const { shapes, engine } = yield* prepare(dataGraph, shapesGraph, options);
+	yield* Effect.annotateCurrentSpan({
+		"shacl.shapes": shapes.shapes.length,
+		"rdf.quads": dataGraph.size
+	});
+	const perShape = yield* Effect.forEach(shapes.shapes, (shape) => shape.deactivated || Arr.isReadonlyArrayEmpty(shape.targets) ? Effect.succeed([]) : Effect.flatMap(engine.focusNodes(shape), (foci) => Effect.map(Effect.forEach(foci, (focus) => engine.validateShape(shape, focus), { concurrency: 1 }), (rs) => rs.flat())), { concurrency: 1 });
+	const report = make$1(perShape.flat());
+	yield* Effect.annotateCurrentSpan({
+		"shacl.results": report.results.length,
+		"shacl.conforms": report.conforms
+	});
+	return report;
+});
+/**
+* Validates a single focus node against one shape of a shapes graph,
+* ignoring targets.
+*
+* @since 0.1.0
+* @category validation
+*/
+const validateNode = Effect.fnUntraced(function* (dataGraph, shapesGraph, shapeId, focusNode, options = {}) {
+	const { shapes, engine } = yield* prepare(dataGraph, shapesGraph, options);
+	const shape = Option.getOrUndefined(get(shapes, shapeId));
+	if (shape === void 0) return make$1([]);
+	return make$1(yield* engine.validateShape(shape, focusNode));
+});
+/**
+* Whether a data graph conforms to a shapes graph.
+*
+* @since 0.1.0
+* @category validation
+*/
+const conforms = (dataGraph, shapesGraph, options) => Effect.map(validate(dataGraph, shapesGraph, options), (r) => r.conforms);
+/**
+* Validates and fails with a `ConformanceError` (carrying the report) when
+* the data graph does not conform; succeeds with the data graph otherwise.
+*
+* @since 0.1.0
+* @category validation
+*/
+const assertConforms = (dataGraph, shapesGraph, options) => Effect.flatMap(validate(dataGraph, shapesGraph, options), (report) => report.conforms ? Effect.succeed(dataGraph) : Effect.fail(new ConformanceError({
+	message: format(report),
+	report
+})));
+/**
+* A validator bound to a pre-compiled shapes graph.
+*
+* @since 0.1.0
+* @category services
+*/
+var Validator = class extends Context.Service()("@thomasfosterau/effect-rdf/shacl/Validator") {};
+/**
+* Compiles a shapes graph into a `Validator` service implementation. The
+* given options are defaults that individual calls may override.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = Effect.fnUntraced(function* (shapesGraph, defaults = {}) {
+	const compiled = yield* resolveShapes(shapesGraph);
+	const merge = (options) => ({
+		...defaults,
+		...options
+	});
+	return Validator.of({
+		shapesGraph: compiled,
+		validate: (data, options) => validate(data, compiled, merge(options)),
+		conforms: (data, options) => conforms(data, compiled, merge(options)),
+		check: (data, options) => assertConforms(data, compiled, merge(options))
+	});
+});
+/**
+* A layer providing a `Validator` for the given shapes graph.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layer = (shapesGraph, defaults) => Layer.effect(Validator, make(shapesGraph, defaults));
+const severityRank = (severity) => severity.value === sh.Info.value ? 0 : severity.value === sh.Warning.value ? 1 : 2;
+const thresholdRank = {
+	info: 0,
+	warning: 1,
+	violation: 2
+};
+/**
+* A `Schema` that accepts a `Dataset` only if it conforms to the given shapes
+* graph. Decoding fails with a `SchemaIssue.Composite` holding one
+* `InvalidValue` issue per failing result: its `message` annotation is the
+* formatted result (`ValidationReport.formatResult`) and its `result`
+* annotation the `ValidationResult` itself, for consumers that inspect
+* failures (focus node, path, constraint component, severity, messages). By
+* default only `sh:Violation` results fail (see `SchemaOptions.failOn`).
+* Encoding is the identity.
+*
+* Compose it with a syntax codec to parse and validate in one decode:
+* `Turtle.codec.schema.pipe(Schema.decodeTo(Validator.schema(shapes)))`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const schema = (shapesGraph, options) => {
+	const threshold = thresholdRank[options?.failOn ?? "violation"];
+	return DatasetSchema.pipe(Schema.decodeTo(DatasetSchema, SchemaTransformation.transformEffect({
+		decode: (data, parseOptions) => validate(data, shapesGraph, options).pipe(Effect.mapError((e) => new SchemaIssue.InvalidValue({ message: e.message }, data, parseOptions)), Effect.flatMap((report) => Arr.match(Arr.filter(report.results, (r) => severityRank(r.severity) >= threshold), {
+			onEmpty: () => Effect.succeed(data),
+			onNonEmpty: (failing) => Effect.fail(new SchemaIssue.Composite(DatasetSchema.ast, Arr.map(failing, (r) => new SchemaIssue.InvalidValue({
+				message: formatResult(r),
+				result: r
+			}, r, parseOptions)), data))
+		}))),
+		encode: (data) => Effect.succeed(data)
+	})));
+};
+/**
+* The SHACL `sh:Violation`, `sh:Warning` and `sh:Info` severities.
+*
+* @since 0.1.0
+* @category constants
+*/
+const severities = {
+	Violation: sh.Violation,
+	Warning: sh.Warning,
+	Info: sh.Info
+};
+export { Validator_exports as a, layer as c, severities as d, validate as f, Validator as i, make as l, RecursiveShapeError as n, assertConforms as o, validateNode as p, UnsupportedFeatureError as r, conforms as s, ConformanceError as t, schema as u };
+
+//# sourceMappingURL=Validator-DmUfMbpL.mjs.map