@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Validator-BzXMKDeJ.mjs

@@ -0,0 +1,1162 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, K as isTriple, N as isBlankNode, P as isDefaultGraph, U as isResource, q as isVariable, rt as triple, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { E as match, t as DatasetSchema } from "./Dataset-BlmlcI7J.mjs";
+import { _ as isValidLexical, g as isNumericDatatype } from "./Xsd-Cdgx5zRB.mjs";
+import { c as withExternalCode, t as SemActHandler } from "./SemAct-CmyT4yI8.mjs";
+import { n as ShExImportError, o as ShExValidationError } from "./ShExError-CVtq2NnM.mjs";
+import { A as cardinality } from "./ShExJ-COiPd9Xw.mjs";
+import { a as isStart, c as resolve } from "./ShapeMap-CsgKxB2G.mjs";
+import { n as check, o as iterate, r as makeIndex } from "./Structure-BjMo4Bkc.mjs";
+import * as Arr from "effect/Array";
+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 Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Result from "effect/Result";
+// src/shex/internal/xpathRegex.ts
+/**
+* Translation of XPath / XML Schema regular expressions (as used by the
+* ShEx `pattern` facet and `fn:matches`) to JavaScript `RegExp`s.
+*
+* Handled differences: `.` excludes only `\n` and `\r`; `\d`, `\w`, `\i`,
+* `\c` and their complements use the XML Schema definitions; character class
+* subtraction (`[a-z-[aeiou]]`); `\p{IsBlock}` names; the `x` flag removes
+* whitespace; escapes JavaScript rejects in Unicode mode are normalised.
+*
+* @internal
+*/
+const NAME_START = ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u{10000}-\\u{EFFFF}";
+const NAME_CHAR = `${NAME_START}\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040`;
+/** Class body fragments for the multi-character escapes. */
+const CLASS_ESCAPES = {
+	d: {
+		body: "\\p{Nd}",
+		negated: false
+	},
+	D: {
+		body: "\\p{Nd}",
+		negated: true
+	},
+	w: {
+		body: "\\p{L}\\p{M}\\p{N}\\p{S}",
+		negated: false
+	},
+	W: {
+		body: "\\p{L}\\p{M}\\p{N}\\p{S}",
+		negated: true
+	},
+	s: {
+		body: " \\t\\n\\r",
+		negated: false
+	},
+	S: {
+		body: " \\t\\n\\r",
+		negated: true
+	},
+	i: {
+		body: NAME_START,
+		negated: false
+	},
+	I: {
+		body: NAME_START,
+		negated: true
+	},
+	c: {
+		body: NAME_CHAR,
+		negated: false
+	},
+	C: {
+		body: NAME_CHAR,
+		negated: true
+	}
+};
+const BLOCKS = {
+	BasicLatin: "\\u0000-\\u007F",
+	"Latin-1Supplement": "\\u0080-\\u00FF",
+	LatinExtended_A: "\\u0100-\\u017F",
+	"LatinExtended-A": "\\u0100-\\u017F",
+	"LatinExtended-B": "\\u0180-\\u024F",
+	IPAExtensions: "\\u0250-\\u02AF",
+	Greek: "\\u0370-\\u03FF",
+	GreekandCoptic: "\\u0370-\\u03FF",
+	Cyrillic: "\\u0400-\\u04FF",
+	Hebrew: "\\u0590-\\u05FF",
+	Arabic: "\\u0600-\\u06FF",
+	CJKUnifiedIdeographs: "\\u4E00-\\u9FFF",
+	Hiragana: "\\u3040-\\u309F",
+	Katakana: "\\u30A0-\\u30FF"
+};
+const SYNTAX = MutableHashSet.make("^", "$", "\\", ".", "*", "+", "?", "(", ")", "[", "]", "{", "}", "|", "/");
+const escapeOf = Match.fn((c, _t) => c).pipe(Match.withReturnType(), Match.when("n", () => ({
+	kind: "char",
+	text: "\\n"
+})), Match.when("r", () => ({
+	kind: "char",
+	text: "\\r"
+})), Match.when("t", () => ({
+	kind: "char",
+	text: "\\t"
+})), Match.when(Match.is("p", "P"), (c, _c, t) => {
+	return {
+		kind: "class",
+		...t.property(c === "P")
+	};
+}), Match.orElse((c, _c, t) => {
+	const ce = CLASS_ESCAPES[c];
+	if (ce !== void 0) return {
+		kind: "class",
+		...ce
+	};
+	if (/[0-9]/.test(c)) return {
+		kind: "char",
+		text: `\\${c}`
+	};
+	if (c === "-") return {
+		kind: "char",
+		text: "\\-"
+	};
+	if (MutableHashSet.has(SYNTAX, c)) return {
+		kind: "char",
+		text: `\\${c}`
+	};
+	return t.fail(`invalid escape \\${c}`);
+}));
+var Translator = class {
+	i = 0;
+	src;
+	dotAll;
+	extended;
+	constructor(src, dotAll, extended) {
+		this.src = src;
+		this.dotAll = dotAll;
+		this.extended = extended;
+	}
+	fail(msg) {
+		throw new SyntaxError(`${msg} at ${this.i} in /${this.src}/`);
+	}
+	/** Translates a property escape `\p{..}` / `\P{..}` (cursor after `p`/`P`). */
+	property(negated) {
+		if (this.src[this.i] !== "{") this.fail("expected {");
+		const end = this.src.indexOf("}", this.i);
+		if (end === -1) this.fail("unterminated property escape");
+		const name = this.src.slice(this.i + 1, end);
+		this.i = end + 1;
+		if (name.startsWith("Is")) {
+			const block = BLOCKS[name.slice(2)];
+			if (block === void 0) this.fail(`unsupported block ${name}`);
+			return {
+				body: block,
+				negated
+			};
+		}
+		return {
+			body: `\\p{${name}}`,
+			negated
+		};
+	}
+	/** Reads an escape inside or outside a class (cursor after the backslash). */
+	escape() {
+		const c = this.src[this.i++];
+		if (c === void 0) this.fail("dangling backslash");
+		return escapeOf(c, this);
+	}
+	/** Translates a character class (cursor after `[`); returns a JS fragment. */
+	charClass() {
+		const negated = this.src[this.i] === "^";
+		if (negated) this.i++;
+		const state = {
+			extra: [],
+			subtraction: Option.none()
+		};
+		const raw = Arr.unfold(true, (first) => Option.map(this.classAtom(first, state), (fragment) => [fragment, false])).join("");
+		const body = restoreRanges(raw);
+		const { extra } = state;
+		const set = Arr.isReadonlyArrayEmpty(extra) ? `[${negated ? "^" : ""}${body}]` : this.union(negated, [...body === "" ? [] : [`[${body}]`], ...extra]);
+		return Option.match(state.subtraction, {
+			onNone: () => set,
+			onSome: (subtraction) => `(?:(?!${subtraction})${set})`
+		});
+	}
+	/** A class with complemented escapes: the union of its alternatives (or its complement). */
+	union(negated, alts) {
+		const union = `(?:${alts.join("|")})`;
+		return negated ? `(?:(?!${union})[\\s\\S])` : union;
+	}
+	/**
+	* Reads the next atom of a character class, returning its body fragment,
+	* or none once the class ends (`]`, or a subtraction, which ends it).
+	*/
+	classAtom(first, state) {
+		const c = this.src[this.i];
+		if (c === void 0) this.fail("unterminated character class");
+		if (c === "]" && !first) {
+			this.i++;
+			return Option.none();
+		}
+		if (c === "-" && this.src[this.i + 1] === "[") {
+			this.i += 2;
+			state.subtraction = Option.some(this.charClass());
+			if (this.src[this.i] !== "]") this.fail("expected ] after class subtraction");
+			this.i++;
+			return Option.none();
+		}
+		this.i++;
+		if (c === "\\") {
+			const e = this.escape();
+			if (e.kind === "char") return Option.some(e.text);
+			if (!e.negated) return Option.some(e.body);
+			state.extra.push(`[^${e.body}]`);
+			return Option.some("");
+		}
+		if (c === "[" || c === "/" || c === "{" || c === "}" || c === "(" || c === ")" || c === "|") return Option.some(`\\${c}`);
+		return Option.some(c === "-" ? "\\-" : c);
+	}
+	/** Translates the atom at the cursor (outside a class). */
+	atom() {
+		const c = this.src.charAt(this.i);
+		if (this.extended && /\s/.test(c)) {
+			this.i++;
+			return "";
+		}
+		if (c === "\\") {
+			this.i++;
+			const e = this.escape();
+			return e.kind === "char" ? e.text === "\\-" ? "-" : e.text : `[${e.negated ? "^" : ""}${e.body}]`;
+		}
+		if (c === "[") {
+			this.i++;
+			return this.charClass();
+		}
+		if (c === "{") {
+			const q = /^\{\d+(?:,\d*)?\}/.exec(this.src.slice(this.i));
+			if (q !== null) {
+				this.i += q[0].length;
+				return q[0];
+			}
+			this.i++;
+			return "\\{";
+		}
+		this.i++;
+		if (c === ".") return this.dotAll ? "[\\s\\S]" : "[^\\n\\r]";
+		if (c === "/") return "\\/";
+		if (c === "]" || c === "}") return `\\${c}`;
+		return c;
+	}
+	translate() {
+		return Arr.unfold(this, (t) => t.i < t.src.length ? Option.some([t.atom(), t]) : Option.none()).join("");
+	}
+};
+/**
+* Inside a translated class body, a `-` between two class atoms that was
+* written unescaped is a range; we escaped every `-` while scanning, so turn
+* back those that had atoms on both sides in the source.
+*/
+const restoreRanges = (body) => {
+	const atoms = body.match(CLASS_ATOM) ?? [];
+	const endpointAt = (k) => {
+		const a = atoms[k];
+		return a !== void 0 && isRangeEndpoint(a);
+	};
+	return Arr.map(atoms, (a, k) => a === "\\-" && endpointAt(k - 1) && endpointAt(k + 1) ? "-" : a).join("");
+};
+const CLASS_ATOM = /\\(?:[pP]\{[^}]*\}|u\{[0-9A-Fa-f]+\}|u[0-9A-Fa-f]{4}|.)|./gsu;
+const isRangeEndpoint = (atom) => !/^\\[pPdDwWsS]/.test(atom) && atom !== "\\-";
+/**
+* Compiles an XPath regular expression with XPath flags (`s`, `m`, `i`, `x`,
+* `q`) to a JavaScript `RegExp` (Unicode mode).
+*
+* @internal
+*/
+const compileXPathRegex = (pattern, flags) => {
+	if (flags.includes("q")) {
+		const escaped = pattern.replace(/[\\^$.*+?()[\]{}|/-]/g, "\\$&");
+		return new RegExp(escaped, `u${flags.includes("i") ? "i" : ""}`);
+	}
+	const source = new Translator(pattern, flags.includes("s"), flags.includes("x")).translate();
+	let jsFlags = "u";
+	if (flags.includes("i")) jsFlags += "i";
+	if (flags.includes("m")) jsFlags += "m";
+	return new RegExp(source, jsFlags);
+};
+// src/shex/internal/nodeConstraint.ts
+/**
+* Node constraint evaluation (`satisfies2`): node kinds, datatypes, XML
+* Schema string and numeric facets, and value sets.
+*
+* @internal
+*/
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+const XSD_STRING = `${XSD}string`;
+const RDF_LANG_STRING = "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString";
+const decimalDerived = MutableHashSet.fromIterable([
+	"decimal",
+	"integer",
+	"nonPositiveInteger",
+	"negativeInteger",
+	"long",
+	"int",
+	"short",
+	"byte",
+	"nonNegativeInteger",
+	"unsignedLong",
+	"unsignedInt",
+	"unsignedShort",
+	"unsignedByte",
+	"positiveInteger"
+].map((l) => XSD + l));
+/** The string a string facet applies to. */
+const lexicalForm = (n) => isLiteral(n) || isNamedNode(n) || isBlankNode(n) ? n.value : n.key;
+/** The number of code points (a lone surrogate counts as one, as string iteration does). */
+const codePointLength = (s) => s.length - (s.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g)?.length ?? 0);
+const regexCache = MutableHashMap.empty();
+/** Compiles (once) an XPath pattern; fails with the reason it is invalid. */
+const getRegex = (pattern, flags) => {
+	const key = `${flags}/${pattern}`;
+	return Option.getOrElse(MutableHashMap.get(regexCache, key), () => {
+		const re = Result.try({
+			try: () => compileXPathRegex(pattern, flags),
+			catch: (e) => Predicate.hasProperty(e, "message") && Predicate.isString(e.message) ? e.message : String(e)
+		});
+		MutableHashMap.set(regexCache, key, re);
+		return re;
+	});
+};
+const decimalParts = (lexical) => {
+	const m = /^([+-]?)(\d*)(?:\.(\d*))?$/.exec(lexical.trim());
+	if (m === null || (m[2] ?? "") === "" && (m[3] ?? "") === "") return Option.none();
+	const int = (m[2] ?? "").replace(/^0+/, "");
+	const frac = (m[3] ?? "").replace(/0+$/, "");
+	return Option.some({
+		negative: m[1] === "-" && (int !== "" || frac !== ""),
+		int,
+		frac
+	});
+};
+const compareDecimalParts = (a, b) => {
+	if (a.negative !== b.negative) return a.negative ? -1 : 1;
+	const sign = a.negative ? -1 : 1;
+	if (a.int.length !== b.int.length) return sign * (a.int.length < b.int.length ? -1 : 1);
+	if (a.int !== b.int) return sign * (a.int < b.int ? -1 : 1);
+	const len = Math.max(a.frac.length, b.frac.length);
+	const fa = a.frac.padEnd(len, "0");
+	const fb = b.frac.padEnd(len, "0");
+	if (fa === fb) return 0;
+	return sign * (fa < fb ? -1 : 1);
+};
+const numberToDecimalParts = (n) => {
+	if (!Number.isFinite(n)) return Option.none();
+	const s = String(n);
+	if (/e/i.test(s)) {
+		const m = /^(-?)(\d+)(?:\.(\d+))?e([+-]\d+)$/i.exec(s);
+		if (m === null) return Option.none();
+		const digits = (m[2] ?? "") + (m[3] ?? "");
+		const exp = parseInt(m[4] ?? "", 10) - (m[3] ?? "").length;
+		const body = exp >= 0 ? digits + "0".repeat(exp) : (() => {
+			const padded = digits.padStart(-exp + 1, "0");
+			return `${padded.slice(0, exp)}.${padded.slice(exp)}`;
+		})();
+		return decimalParts(m[1] + body);
+	}
+	return decimalParts(s);
+};
+const numericValue = (n) => {
+	if (!isLiteral(n)) return Option.none();
+	const dt = n.datatype.value;
+	if (!isNumericDatatype(dt) || !isValidLexical(dt, n.value)) return Option.none();
+	if (MutableHashSet.has(decimalDerived, dt)) return Option.map(decimalParts(n.value), (parts) => ({
+		kind: "decimal",
+		parts
+	}));
+	const v = n.value.trim();
+	const value = v === "INF" || v === "+INF" ? Infinity : v === "-INF" ? -Infinity : v === "NaN" ? NaN : Number(v);
+	return Option.some({
+		kind: "float",
+		value
+	});
+};
+/** Compares a numeric value with a facet; returns NaN when incomparable. */
+const compareWith = (v, facet) => {
+	if (v.kind === "decimal") {
+		const { parts } = v;
+		return Option.match(numberToDecimalParts(facet), {
+			onNone: () => Number.isNaN(facet) ? NaN : facet === Infinity ? -1 : 1,
+			onSome: (f) => compareDecimalParts(parts, f)
+		});
+	}
+	if (Number.isNaN(v.value) || Number.isNaN(facet)) return NaN;
+	return v.value < facet ? -1 : v.value > facet ? 1 : 0;
+};
+const lowerEq = (a, b) => a.toLowerCase() === b.toLowerCase();
+/** Basic language-range filtering (RFC 4647 §3.3.1). */
+const languageMatches = (tag, range) => {
+	if (range === "" || range === "*") return tag !== "";
+	const t = tag.toLowerCase();
+	const r = range.toLowerCase();
+	return t === r || t.startsWith(`${r}-`);
+};
+const literalEquals = (n, v) => {
+	if (n.value !== v.value) return false;
+	if (v.language !== void 0) return n.language !== "" && lowerEq(n.language, v.language);
+	if (n.language !== "") return false;
+	return n.datatype.value === (v.type ?? XSD_STRING);
+};
+/**
+* Whether a value is in an IRI or literal stem range: under its stem (any
+* value, for a wildcard) and under none of its exclusions.
+*/
+const inStemRange = (value, range) => (!Predicate.isString(range.stem) || value.startsWith(range.stem)) && !range.exclusions.some((e) => Predicate.isString(e) ? value === e : value.startsWith(e.stem));
+const stemValueMatches = Match.fn((v, _n) => v).pipe(Match.withReturnType(), Match.when({ type: "IriStem" }, (v, _v, n) => isNamedNode(n) && n.value.startsWith(v.stem)), Match.when({ type: "IriStemRange" }, (v, _v, n) => isNamedNode(n) && inStemRange(n.value, v)), Match.when({ type: "LiteralStem" }, (v, _v, n) => isLiteral(n) && n.value.startsWith(v.stem)), Match.when({ type: "LiteralStemRange" }, (v, _v, n) => isLiteral(n) && inStemRange(n.value, v)), Match.when({ type: "Language" }, (v, _v, n) => isLiteral(n) && n.language !== "" && lowerEq(n.language, v.languageTag)), Match.when({ type: "LanguageStem" }, (v, _v, n) => isLiteral(n) && n.language !== "" && languageMatches(n.language, v.stem)), Match.when({ type: "LanguageStemRange" }, (v, _v, n) => {
+	if (!isLiteral(n) || n.language === "") return false;
+	if (Predicate.isString(v.stem) && !languageMatches(n.language, v.stem)) return false;
+	return !v.exclusions.some((e) => Predicate.isString(e) ? lowerEq(n.language, e) : languageMatches(n.language, e.stem));
+}), Match.orElse(() => false));
+/**
+* Whether a term matches a value set value.
+*
+* @internal
+*/
+const valueMatches = (n, v) => {
+	if (Predicate.isString(v)) return isNamedNode(n) && n.value === v;
+	if (!("type" in v) || "value" in v) return isLiteral(n) && literalEquals(n, v);
+	return stemValueMatches(v, n);
+};
+const failure = (cond, message) => cond ? Option.some(message()) : Option.none();
+const nodeKindFailure = Match.fn((nc, _n) => nc.nodeKind).pipe(Match.withReturnType(), Match.when("iri", (_kind, _nc, n) => failure(!isNamedNode(n), () => `${n.key} is not an IRI`)), Match.when("bnode", (_kind, _nc, n) => failure(!isBlankNode(n), () => `${n.key} is not a blank node`)), Match.when("literal", (_kind, _nc, n) => failure(!isLiteral(n), () => `${n.key} is not a literal`)), Match.when("nonliteral", (_kind, _nc, n) => failure(!isResource(n), () => `${n.key} is not an IRI or blank node`)), Match.orElse(() => Option.none()));
+/** The numeric range facets: how each reads its limit, and which comparisons it accepts. */
+const numericFacets = [
+	[
+		"mininclusive",
+		(nc) => Option.fromUndefinedOr(nc.mininclusive),
+		(c) => c >= 0
+	],
+	[
+		"minexclusive",
+		(nc) => Option.fromUndefinedOr(nc.minexclusive),
+		(c) => c > 0
+	],
+	[
+		"maxinclusive",
+		(nc) => Option.fromUndefinedOr(nc.maxinclusive),
+		(c) => c <= 0
+	],
+	[
+		"maxexclusive",
+		(nc) => Option.fromUndefinedOr(nc.maxexclusive),
+		(c) => c < 0
+	]
+];
+/** The datatype check of a node constraint with a `datatype`. */
+const datatypeFailure = (n, datatype) => {
+	if (!isLiteral(n)) return Option.some(`${n.key} is not a literal of datatype <${datatype}>`);
+	if ((n.language !== "" ? RDF_LANG_STRING : n.datatype.value) !== datatype && !(n.language !== "" && n.datatype.value === datatype)) return Option.some(`${n.key} does not have datatype <${datatype}>`);
+	return failure(n.language === "" && (!isValidLexical(datatype, n.value) || (datatype === `${XSD}float` || datatype === `${XSD}double`) && n.value === "+INF"), () => `${n.key} is not a valid <${datatype}>`);
+};
+/** The string facets (`length`, `minlength`, `maxlength`, `pattern`). */
+const stringFacetFailure = (n, nc) => {
+	const lex = lexicalForm(n);
+	const len = codePointLength(lex);
+	if (nc.length !== void 0 && len !== nc.length) return Option.some(`${n.key} has length ${len}, expected ${nc.length}`);
+	if (nc.minlength !== void 0 && len < nc.minlength) return Option.some(`${n.key} has length ${len}, expected at least ${nc.minlength}`);
+	if (nc.maxlength !== void 0 && len > nc.maxlength) return Option.some(`${n.key} has length ${len}, expected at most ${nc.maxlength}`);
+	if (nc.pattern === void 0) return Option.none();
+	const compiled = getRegex(nc.pattern, nc.flags ?? "");
+	if (Result.isFailure(compiled)) return Option.some(`invalid pattern /${nc.pattern}/: ${compiled.failure}`);
+	const re = compiled.success;
+	re.lastIndex = 0;
+	return failure(!re.test(lex), () => `${n.key} does not match /${nc.pattern}/${nc.flags ?? ""}`);
+};
+/** The numeric range facets, in order: the first one the node violates. */
+const numericFacetFailure = (n, nc) => Arr.findFirst(numericFacets, ([facet, limitOf, ok]) => Option.flatMap(limitOf(nc), (limit) => Option.match(numericValue(n), {
+	onNone: () => Option.some(`${n.key} is not numeric (${facet})`),
+	onSome: (v) => failure(!ok(compareWith(v, limit)), () => `${n.key} violates ${facet} ${limit}`)
+})));
+/** The digits facets (`totaldigits`, `fractiondigits`). */
+const digitsFailure = (n, nc) => {
+	const parts = isLiteral(n) && MutableHashSet.has(decimalDerived, n.datatype.value) && isValidLexical(n.datatype.value, n.value) ? decimalParts(n.value) : Option.none();
+	return Option.match(parts, {
+		onNone: () => Option.some(`${n.key} is not an xsd:decimal value`),
+		onSome: ({ int, frac }) => {
+			const total = Math.max(1, int.length + frac.length);
+			if (nc.totaldigits !== void 0 && total > nc.totaldigits) return Option.some(`${n.key} has ${total} digits, expected at most ${nc.totaldigits}`);
+			return failure(nc.fractiondigits !== void 0 && frac.length > nc.fractiondigits, () => `${n.key} has ${frac.length} fraction digits, expected at most ${nc.fractiondigits}`);
+		}
+	});
+};
+/**
+* Evaluates a node constraint (without its semantic actions): none on
+* success, or the reason it fails.
+*
+* @internal
+*/
+const checkNodeConstraint = (n, nc) => {
+	const kindFailure = nodeKindFailure(nc, n);
+	if (Option.isSome(kindFailure)) return kindFailure;
+	if (nc.datatype !== void 0) {
+		const f = datatypeFailure(n, nc.datatype);
+		if (Option.isSome(f)) return f;
+	}
+	if (nc.length !== void 0 || nc.minlength !== void 0 || nc.maxlength !== void 0 || nc.pattern !== void 0) {
+		const f = stringFacetFailure(n, nc);
+		if (Option.isSome(f)) return f;
+	}
+	const numeric = numericFacetFailure(n, nc);
+	if (Option.isSome(numeric)) return numeric;
+	if (nc.totaldigits !== void 0 || nc.fractiondigits !== void 0) {
+		const f = digitsFailure(n, nc);
+		if (Option.isSome(f)) return f;
+	}
+	return failure(nc.values !== void 0 && !nc.values.some((v) => valueMatches(n, v)), () => `${n.key} is not in the value set`);
+};
+// src/shex/internal/engine.ts
+/**
+* The ShEx validation engine: a synchronous evaluator of `satisfies` with
+* memoisation and coinductive (greatest fixed point) handling of recursive
+* references, partition search for triple expressions over bags of triple
+* constraint assignments, and ShEx 2.2 `EXTENDS` / `ABSTRACT` /
+* `RESTRICTS` semantics.
+*
+* @internal
+*/
+const FULL = {
+	arcs: Option.none(),
+	target: Option.none(),
+	partitionClosed: false
+};
+const success = Option.none();
+const unused = {
+	used: false,
+	r: success
+};
+/** A failure reason as the messages print it (`undefined` when there is none). */
+const show = (o) => Option.getOrElse(o, () => "undefined");
+const bagKey = (bag) => bag.join(",");
+const dedupe = (bags) => Arr.fromIterable(MutableHashMap.values(MutableHashMap.fromIterable(Arr.map(bags, (b) => [bagKey(b), b]))));
+/** The first of the alternatives of a `ShapeOr` that `n` satisfies, preferring the target. */
+const satisfiesOr = (e, engine, n, ctx, deps) => {
+	let first = Option.none();
+	let passed = false;
+	return Arr.some(e.shapeExprs, (c) => {
+		const before = Option.match(ctx.target, {
+			onNone: () => 0,
+			onSome: (t) => t.count
+		});
+		const r = engine.satisfies(n, c, ctx, deps, Option.none());
+		if (Option.isNone(r)) {
+			if (Option.match(ctx.target, {
+				onNone: () => true,
+				onSome: (t) => t.count > before
+			})) return true;
+			passed = true;
+		} else if (Option.isNone(first)) first = r;
+		return false;
+	}) || passed ? success : Option.some(`${n.key} matches none of the alternatives (${show(first)})`);
+};
+const satisfiesExpr = Match.fn((e, _engine, _n, _ctx, _deps, _declLabel) => e).pipe(Match.withReturnType(), Match.when({ type: "ShapeAnd" }, (e, _e, engine, n, ctx, deps) => Arr.findFirst(e.shapeExprs, (c) => engine.satisfies(n, c, ctx, deps, Option.none()))), Match.when({ type: "ShapeOr" }, (e, _e, engine, n, ctx, deps) => satisfiesOr(e, engine, n, ctx, deps)), Match.when({ type: "ShapeNot" }, (e, _e, engine, n, ctx, deps) => Option.isNone(engine.satisfies(n, e.shapeExpr, ctx, deps, Option.none())) ? Option.some(`${n.key} matches a negated shape expression`) : success), Match.when({ type: "NodeConstraint" }, (e, _e, engine, n) => {
+	const r = checkNodeConstraint(n, e);
+	if (Option.isSome(r)) return r;
+	return engine.runSemActs(e.semActs, {
+		site: "nodeConstraint",
+		node: n
+	});
+}), Match.when({ type: "ShapeExternal" }, (_e, _input, engine, n, ctx, deps, declLabel) => Option.match(Option.flatMap(declLabel, (l) => MutableHashMap.get(engine.externs, l)), {
+	onNone: () => Option.some(`no definition available for external shape ${Option.getOrElse(declLabel, () => "undefined")}`),
+	onSome: (ext) => engine.satisfies(n, ext.shapeExpr, ctx, deps, Option.none())
+})), Match.when({ type: "Shape" }, (e, _e, engine, n, ctx, deps) => engine.matchesShape(n, e, ctx, deps)), Match.exhaustive);
+/** Appends to `out` the triple constraints of `tcs` it does not have yet. */
+const addAll = (out, tcs) => tcs.forEach((tc) => {
+	if (!out.includes(tc)) out.push(tc);
+});
+const extensionTcsOf = Match.fn((e, _engine, _out, _seen) => e).pipe(Match.when({ type: "Shape" }, (e, _e, engine, out, seen) => {
+	addAll(out, engine.localTcs(e));
+	e.extends?.forEach((x) => engine.extensionTcs(x, out, seen));
+}), Match.when({ type: Match.is("ShapeAnd", "ShapeOr") }, (e, _e, engine, out, seen) => {
+	e.shapeExprs.forEach((c) => engine.extensionTcs(c, out, seen));
+}), Match.when({ type: "ShapeNot" }, (e, _e, engine, out, seen) => {
+	engine.extensionTcs(e.shapeExpr, out, seen);
+}), Match.orElse(() => void 0));
+/** The arcs of `quads` in one direction, each triple once. */
+const arcsOf = (quads, dir, valueOf) => {
+	const seen = MutableHashSet.empty();
+	return Arr.filterMap(Arr.fromIterable(quads), (q) => {
+		const t = triple(q.subject, q.predicate, q.object);
+		if (MutableHashSet.has(seen, t.key)) return Result.failVoid;
+		MutableHashSet.add(seen, t.key);
+		return Result.succeed({
+			triple: t,
+			dir,
+			predicate: q.predicate.value,
+			value: valueOf(q)
+		});
+	});
+};
+var Engine = class {
+	cache = MutableHashMap.empty();
+	inProgress = MutableHashSet.empty();
+	neighbourhoods = MutableHashMap.empty();
+	shapeTcs = /* @__PURE__ */ new WeakMap();
+	index;
+	dataset;
+	handler;
+	externs;
+	constructor(index, dataset, handler, externs) {
+		this.index = index;
+		this.dataset = dataset;
+		this.handler = handler;
+		this.externs = externs;
+	}
+	neighbourhood(n) {
+		return Option.getOrElse(MutableHashMap.get(this.neighbourhoods, n.key), () => {
+			const arcs = [...isResource(n) || isTriple(n) ? arcsOf(match(this.dataset, { subject: n }), "out", (q) => q.object) : [], ...!isVariable(n) && !isDefaultGraph(n) ? arcsOf(match(this.dataset, { object: n }), "in", (q) => q.subject) : []];
+			MutableHashMap.set(this.neighbourhoods, n.key, arcs);
+			return arcs;
+		});
+	}
+	runSemActs(acts = [], context) {
+		return Arr.findFirst(acts, (act) => {
+			const r = this.handler(act, context);
+			return Option.isSome(r) && !r.value ? Option.some(`semantic action <${act.name}> failed`) : Option.none();
+		});
+	}
+	/** Validates `n` against a shape label (or a descendant) on its full neighbourhood. */
+	validateLabel(n, label, deps) {
+		return this.memoized(`${n.key}\u0000${label}`, deps, (local) => this.satisfiesDescendant(n, label, local));
+	}
+	/** Validates `n` against the start shape expression. */
+	validateStart(n, deps) {
+		const start = this.index.schema.start;
+		if (start === void 0) return Option.some("the schema has no start shape");
+		return this.memoized(`${n.key}\u0000\u0000START`, deps, (local) => this.satisfies(n, start, FULL, local, Option.none()));
+	}
+	/**
+	* Runs `check` once per `key` (a node and shape pair), caching its outcome.
+	* A key already in progress is a recursive reference: it succeeds for now
+	* and is reported to the caller in `deps`, and an outcome is cached only
+	* once it no longer depends on an unfinished key.
+	*/
+	memoized(key, deps, check) {
+		const cached = MutableHashMap.get(this.cache, key);
+		if (Option.isSome(cached)) return cached.value;
+		if (MutableHashSet.has(this.inProgress, key)) {
+			MutableHashSet.add(deps, key);
+			return success;
+		}
+		MutableHashSet.add(this.inProgress, key);
+		const local = MutableHashSet.empty();
+		const result = Result.try(() => check(local));
+		MutableHashSet.remove(this.inProgress, key);
+		if (Result.isFailure(result)) throw result.failure;
+		const r = result.success;
+		MutableHashSet.remove(local, key);
+		if (Option.isSome(r) || MutableHashSet.size(local) === 0) MutableHashMap.set(this.cache, key, r);
+		Iterable.forEach(local, (d) => MutableHashSet.add(deps, d));
+		return r;
+	}
+	satisfiesDescendant(n, label, deps) {
+		if (this.index.shapes.get(label) === void 0) return Option.some(`unknown shape ${label}`);
+		const candidates = [label, ...this.index.descendants.get(label) ?? []].filter((l) => this.index.shapes.get(l)?.abstract !== true);
+		if (Arr.isReadonlyArrayEmpty(candidates)) return Option.some(`${label} is abstract and has no concrete extension`);
+		let first = Option.none();
+		return Arr.some(candidates, (c) => {
+			const target = c === label ? Option.none() : Option.some({
+				label,
+				count: 0
+			});
+			const r = this.satisfiesDecl(n, c, {
+				arcs: Option.none(),
+				target,
+				partitionClosed: false
+			}, deps);
+			if (Option.isNone(r) && Option.match(target, {
+				onNone: () => true,
+				onSome: (t) => t.count > 0
+			})) return true;
+			if (Option.isNone(first)) first = Option.orElse(r, () => Option.some(`${n.key} matches ${c} but not through ${label}`));
+			return false;
+		}) ? success : first;
+	}
+	satisfiesDecl(n, label, ctx, deps) {
+		const decl = this.index.shapes.get(label);
+		if (decl === void 0) return Option.some(`unknown shape ${label}`);
+		return Arr.findFirst([...decl.restricts ?? [], decl.shapeExpr], (e) => this.satisfies(n, e, ctx, deps, Option.some(label)));
+	}
+	satisfies(n, e, ctx, deps, declLabel) {
+		if (Predicate.isString(e)) {
+			if (Option.isNone(ctx.arcs)) return this.validateLabel(n, e, deps);
+			const r = this.satisfiesDecl(n, e, ctx, deps);
+			if (Option.isNone(r) && Option.isSome(ctx.target) && ctx.target.value.label === e) ctx.target.value.count++;
+			return r;
+		}
+		return satisfiesExpr(e, this, n, ctx, deps, declLabel);
+	}
+	/** The triple constraints of a triple expression (through inclusions). */
+	tcsOf(te, out, seen) {
+		if (Predicate.isString(te)) {
+			if (MutableHashSet.has(seen, te)) return;
+			MutableHashSet.add(seen, te);
+			const included = this.index.tripleExprs.get(te);
+			if (included !== void 0) this.tcsOf(included, out, seen);
+			return;
+		}
+		if (te.type === "TripleConstraint") {
+			if (!out.includes(te)) out.push(te);
+		} else te.expressions.forEach((c) => this.tcsOf(c, out, seen));
+	}
+	localTcs(shape) {
+		const cached = this.shapeTcs.get(shape);
+		if (cached !== void 0) return cached;
+		const out = [];
+		if (shape.expression !== void 0) this.tcsOf(shape.expression, out, MutableHashSet.empty());
+		this.shapeTcs.set(shape, out);
+		return out;
+	}
+	/** All triple constraints of the shapes an extension refers to (recursively). */
+	extensionTcs(e, out, seen) {
+		if (Predicate.isString(e)) {
+			if (MutableHashSet.has(seen, e)) return;
+			MutableHashSet.add(seen, e);
+			const decl = this.index.shapes.get(e);
+			if (decl !== void 0) {
+				decl.restricts?.forEach((r) => this.extensionTcs(r, out, seen));
+				this.extensionTcs(decl.shapeExpr, out, seen);
+			}
+			return;
+		}
+		extensionTcsOf(e, this, out, seen);
+	}
+	matchesShape(n, shape, ctx, deps) {
+		const arcs = Option.getOrElse(ctx.arcs, () => this.neighbourhood(n));
+		const closed = shape.closed === true || ctx.partitionClosed;
+		const local = this.localTcs(shape);
+		const extensions = shape.extends ?? [];
+		const extTcs = Arr.map(extensions, (x) => {
+			const out = [];
+			this.extensionTcs(x, out, MutableHashSet.empty());
+			return out;
+		});
+		const all = Arr.dedupeWith([...local, ...Arr.flatten(extTcs)], (a, b) => a === b);
+		const localIndex = new WeakMap(Arr.map(local, (tc, i) => [tc, i]));
+		const extGroupsOf = /* @__PURE__ */ new WeakMap();
+		extTcs.forEach((group, i) => group.forEach((tc) => {
+			if (localIndex.has(tc)) return;
+			const g = extGroupsOf.get(tc);
+			if (g === void 0) extGroupsOf.set(tc, [i]);
+			else g.push(i);
+		}));
+		const byPredicate = Arr.groupBy(all, (tc) => `${tc.inverse === true ? "in" : "out"} ${tc.predicate}`);
+		const extra = MutableHashSet.fromIterable(shape.extra ?? []);
+		const choices = [];
+		const valueCache = MutableHashMap.empty();
+		const valueOutcome = (tc, valueExpr, arc) => {
+			const ck = `${all.indexOf(tc)} ${arc.value.key}`;
+			return Option.getOrElse(MutableHashMap.get(valueCache, ck), () => {
+				const r = this.satisfies(arc.value, valueExpr, FULL, deps, Option.none());
+				MutableHashMap.set(valueCache, ck, r);
+				return r;
+			});
+		};
+		const arcFailure = Arr.findFirst(arcs, (arc) => {
+			const tcs = byPredicate[`${arc.dir} ${arc.predicate}`];
+			if (tcs === void 0) return arc.dir === "out" && closed ? Option.some(`closed shape does not allow ${arc.triple.key}`) : success;
+			let firstReason = Option.none();
+			const ok = Arr.filter(tcs, (tc) => {
+				if (tc.valueExpr === void 0) return true;
+				const r = valueOutcome(tc, tc.valueExpr, arc);
+				if (Option.isNone(r)) return true;
+				if (Option.isNone(firstReason)) firstReason = r;
+				return false;
+			});
+			if (Arr.isReadonlyArrayEmpty(ok)) return MutableHashSet.has(extra, arc.predicate) ? success : Option.some(`${arc.triple.key} does not match its triple constraint: ${show(firstReason)}`);
+			choices.push({
+				arc,
+				tcs: ok
+			});
+			return success;
+		});
+		if (Option.isSome(arcFailure)) return arcFailure;
+		const hasTcSemActs = local.some((tc) => tc.semActs !== void 0);
+		const tried = MutableHashSet.empty();
+		const assignment = [];
+		let firstFailure = Option.none();
+		const tryAssignment = () => {
+			const counts = Array.from({ length: local.length }, () => 0);
+			const partitions = extensions.map(() => []);
+			const keyParts = Arr.filterMap(assignment, ({ arc, tc }) => {
+				const li = localIndex.get(tc);
+				if (li !== void 0) {
+					counts[li] = (counts[li] ?? 0) + 1;
+					return hasTcSemActs ? Result.succeed(`L${li}`) : Result.failVoid;
+				}
+				const groups = extGroupsOf.get(tc) ?? [];
+				groups.forEach((g) => partitions[g]?.push(arc));
+				return Result.succeed(`E${groups.join(".")}`);
+			});
+			const key = `${counts.join(",")}|${keyParts.join("-")}`;
+			if (MutableHashSet.has(tried, key)) return Option.some("duplicate partition");
+			MutableHashSet.add(tried, key);
+			if (shape.expression !== void 0) {
+				if (!this.matchBag(shape.expression, counts, localIndex)) return Option.some(`the triples of ${n.key} do not match the triple expression`);
+			} else if (counts.some((c) => c > 0)) return Option.some("unexpected triples");
+			const extFailure = Arr.findFirst(extensions, (x, i) => this.satisfies(n, x, {
+				arcs: Option.some(partitions[i] ?? []),
+				target: ctx.target,
+				partitionClosed: closed
+			}, deps, Option.none()));
+			if (Option.isSome(extFailure)) return extFailure;
+			const matched = Arr.map(assignment, ({ arc }) => arc.triple);
+			const tcFailure = Arr.findFirst(assignment, ({ arc, tc }) => localIndex.has(tc) ? this.runSemActs(tc.semActs, {
+				site: "tripleConstraint",
+				node: n,
+				triple: arc.triple
+			}) : success);
+			if (Option.isSome(tcFailure)) return tcFailure;
+			if (shape.expression !== void 0) {
+				const r = this.groupSemActs(shape.expression, counts, localIndex, n, matched);
+				if (Option.isSome(r)) return r;
+			}
+			return this.runSemActs(shape.semActs, {
+				site: "shape",
+				node: n,
+				triples: matched
+			});
+		};
+		const search = (i) => {
+			const choice = choices[i];
+			if (choice === void 0) {
+				const r = tryAssignment();
+				if (Option.isNone(r)) return true;
+				if (r.value !== "duplicate partition" && Option.isNone(firstFailure)) firstFailure = r;
+				return false;
+			}
+			return Arr.some(choice.tcs, (tc) => {
+				assignment[i] = {
+					arc: choice.arc,
+					tc
+				};
+				return search(i + 1);
+			});
+		};
+		if (search(0)) return success;
+		return Option.orElse(firstFailure, () => Option.some(`${n.key} does not match the shape`));
+	}
+	/** Whether the bag of triple constraint counts matches the triple expression. */
+	matchBag(te, counts, localIndex) {
+		const zero = bagKey(counts.map(() => 0));
+		return this.step(te, counts, localIndex, 0).some((b) => bagKey(b) === zero);
+	}
+	resolveTe(te) {
+		return Predicate.isString(te) ? Option.fromUndefinedOr(this.index.tripleExprs.get(te)) : Option.some(te);
+	}
+	/** All bags remaining after `te` (with its cardinality) consumes part of `bag`. */
+	step(te0, bag, localIndex, depth) {
+		const resolved = this.resolveTe(te0);
+		if (Option.isNone(resolved) || depth > 64) return [];
+		const te = resolved.value;
+		const { min, max } = cardinality(te);
+		if (te.type === "TripleConstraint") {
+			const k = localIndex.get(te);
+			if (k === void 0) return min === 0 ? [bag] : [];
+			const avail = bag[k] ?? 0;
+			const hi = Math.min(max, avail);
+			return hi < min ? [] : Arr.map(Arr.range(min, hi), (c) => {
+				const nb = bag.slice();
+				nb[k] = avail - c;
+				return nb;
+			});
+		}
+		const once = (b) => te.type === "OneOf" ? dedupe(te.expressions.flatMap((x) => this.step(x, b, localIndex, depth + 1))) : Arr.reduce(te.expressions, [b], (sets, x) => Arr.isReadonlyArrayEmpty(sets) ? sets : dedupe(sets.flatMap((s) => this.step(x, s, localIndex, depth + 1))));
+		const result = MutableHashMap.empty();
+		if (min === 0) MutableHashMap.set(result, bagKey(bag), bag);
+		iterate({
+			i: 1,
+			frontier: [bag]
+		}, ({ i, frontier }) => {
+			if (i > max || Arr.isReadonlyArrayEmpty(frontier)) return Option.none();
+			const next = dedupe(frontier.flatMap(once));
+			if (i < min) return Option.some({
+				i: i + 1,
+				frontier: next
+			});
+			const fresh = Arr.filter(next, (b) => {
+				const k = bagKey(b);
+				if (MutableHashMap.has(result, k)) return false;
+				MutableHashMap.set(result, k, b);
+				return true;
+			});
+			return Option.some({
+				i: i + 1,
+				frontier: fresh
+			});
+		});
+		return Arr.fromIterable(MutableHashMap.values(result));
+	}
+	/** Runs the semantic actions of the groups (EachOf/OneOf) that took part in a match. */
+	groupSemActs(te0, counts, localIndex, n, triples) {
+		const visit = (node, seen) => {
+			if (Predicate.isString(node)) {
+				if (MutableHashSet.has(seen, node)) return unused;
+				MutableHashSet.add(seen, node);
+			}
+			const resolved = this.resolveTe(node);
+			if (Option.isNone(resolved)) return unused;
+			const te = resolved.value;
+			if (te.type === "TripleConstraint") {
+				const k = localIndex.get(te);
+				return {
+					used: k !== void 0 && (counts[k] ?? 0) > 0,
+					r: success
+				};
+			}
+			let used = false;
+			const failed = Arr.findFirst(te.expressions, (x) => {
+				const v = visit(x, seen);
+				if (Option.isSome(v.r)) return Option.some(v);
+				used ||= v.used;
+				return Option.none();
+			});
+			if (Option.isSome(failed)) return failed.value;
+			if (used || cardinality(te).min > 0) {
+				const r = this.runSemActs(te.semActs, {
+					site: "tripleExpression",
+					node: n,
+					triples
+				});
+				if (Option.isSome(r)) return {
+					used,
+					r
+				};
+			}
+			return {
+				used,
+				r: success
+			};
+		};
+		return visit(te0, MutableHashSet.empty()).r;
+	}
+};
+// src/shex/Validator.ts
+/**
+* ShEx validation: checks node/shape associations of a shape map against an
+* RDF dataset per the ShEx 2.1 semantics (with the ShEx 2.2 `EXTENDS`,
+* `ABSTRACT` and `RESTRICTS` extensions).
+*
+* Recursive references are evaluated coinductively (the maximal typing) and
+* memoised; schemas are checked for the structural requirements, which
+* guarantee a stratification so that negation is well-defined. Imports are
+* loaded through the `SchemaLoader` service and semantic actions are
+* dispatched to the `SemAct.SemActHandler` service.
+*
+* @since 0.1.0
+*/
+var Validator_exports = /* @__PURE__ */ __exportAll({
+	SchemaLoader: () => SchemaLoader,
+	formatResult: () => formatResult,
+	loaderFromRecord: () => loaderFromRecord,
+	loaderLayer: () => loaderLayer,
+	make: () => make,
+	resolveImports: () => resolveImports,
+	schema: () => schema,
+	validate: () => validate,
+	validateNode: () => validateNode
+});
+/**
+* The service used to resolve `IMPORT`s. The default loader fails for every
+* import.
+*
+* @since 0.1.0
+* @category services
+*/
+const SchemaLoader = Context.Reference("@thomasfosterau/effect-rdf/shex/SchemaLoader", { defaultValue: () => ({ load: (iri) => Effect.fail(new ShExImportError({
+	iri,
+	message: "no SchemaLoader is configured"
+})) }) });
+/**
+* A layer providing a `SchemaLoader`.
+*
+* @since 0.1.0
+* @category layers
+*/
+const loaderLayer = (loader) => Layer.succeed(SchemaLoader, loader);
+/**
+* A loader serving schemas from a map of IRIs (useful for tests and bundled
+* schemas).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const loaderFromRecord = (schemas) => ({ load: (iri) => {
+	const s = schemas[iri];
+	return s === void 0 ? Effect.fail(new ShExImportError({
+		iri,
+		message: "unknown schema"
+	})) : Effect.succeed(s);
+} });
+/**
+* Loads the imports of a schema (transitively, each IRI once) and merges
+* their declarations into it. The importing schema's `start` and `startActs`
+* are kept.
+*
+* @since 0.1.0
+* @category imports
+*/
+const resolveImports = Effect.fnUntraced(function* (schema, schemaIri) {
+	if (schema.imports === void 0 || Arr.isReadonlyArrayEmpty(schema.imports)) return schema;
+	const loader = yield* SchemaLoader;
+	const seen = MutableHashSet.fromIterable(schemaIri === void 0 ? [] : [schemaIri]);
+	const shapes = [...schema.shapes ?? []];
+	const labels = MutableHashSet.fromIterable(shapes.map((s) => s.id));
+	const load = (queue) => Arr.match(queue, {
+		onEmpty: () => Effect.void,
+		onNonEmpty: ([iri, ...rest]) => {
+			if (MutableHashSet.has(seen, iri)) return load(rest);
+			MutableHashSet.add(seen, iri);
+			return Effect.flatMap(loader.load(iri), (imported) => {
+				imported.shapes?.forEach((d) => {
+					if (MutableHashSet.has(labels, d.id)) return;
+					MutableHashSet.add(labels, d.id);
+					shapes.push(d);
+				});
+				return load([...rest, ...imported.imports ?? []]);
+			});
+		}
+	});
+	yield* load(schema.imports);
+	const { imports: _, ...rest } = schema;
+	return Arr.isReadonlyArrayNonEmpty(shapes) ? {
+		...rest,
+		shapes
+	} : rest;
+});
+const isFixedMap = (map) => map.every((a) => !Predicate.isTagged(a.node, "TriplePattern"));
+/**
+* Prepares a validator: loads imports through `SchemaLoader`, checks the
+* structural requirements and indexes the schema. Semantic actions are
+* dispatched to the `SemAct.SemActHandler` in scope when the validator is
+* made.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = Effect.fnUntraced(function* (schema, options = {}) {
+	const resolved = yield* resolveImports(schema, options.schemaIri);
+	yield* check(resolved);
+	const index = makeIndex(resolved);
+	const baseHandler = yield* SemActHandler;
+	const handler = options.externalSemActs === void 0 ? baseHandler : withExternalCode(baseHandler, options.externalSemActs);
+	const externs = MutableHashMap.fromIterable(Arr.map(options.externalShapes?.shapes ?? [], (d) => [d.id, d]));
+	const validate = (dataset, shapeMap) => Effect.suspend(() => {
+		const fixed = isFixedMap(shapeMap) ? shapeMap : resolve(shapeMap, dataset);
+		const invalid = Arr.findFirst(fixed, (a) => isStart(a.shape) ? resolved.start === void 0 ? Option.some("the shape map uses START but the schema has no start") : Option.none() : index.shapes.has(a.shape) ? Option.none() : Option.some(`the schema does not declare shape ${a.shape}`));
+		if (Option.isSome(invalid)) return Effect.fail(new ShExValidationError({ message: invalid.value }));
+		const engine = new Engine(index, dataset, handler, externs);
+		const startFailure = engine.runSemActs(resolved.startActs, {
+			site: "start",
+			node: void 0
+		});
+		const results = fixed.map((a) => {
+			const reason = Option.orElse(startFailure, () => isStart(a.shape) ? engine.validateStart(a.node, MutableHashSet.empty()) : engine.validateLabel(a.node, a.shape, MutableHashSet.empty()));
+			return Option.match(reason, {
+				onNone: () => ({
+					node: a.node,
+					shape: a.shape,
+					status: "conformant"
+				}),
+				onSome: (why) => ({
+					node: a.node,
+					shape: a.shape,
+					status: "nonconformant",
+					reason: why
+				})
+			});
+		});
+		const conformant = results.every((r) => r.status === "conformant");
+		return Effect.as(Effect.annotateCurrentSpan({
+			"shex.associations": results.length,
+			"shex.nonconformant": results.filter((r) => r.status === "nonconformant").length,
+			"shex.conformant": conformant
+		}), {
+			results,
+			conformant
+		});
+	}).pipe(Effect.withSpan("ShEx.validate"));
+	return {
+		schema: resolved,
+		index,
+		validate
+	};
+});
+/**
+* Validates a shape map against a dataset with a schema.
+*
+* @since 0.1.0
+* @category validation
+*/
+const validate = (dataset, schema, shapeMap, options = {}) => Effect.flatMap(make(schema, options), (v) => v.validate(dataset, shapeMap));
+/**
+* Validates a single node against a shape label (or `START`).
+*
+* @since 0.1.0
+* @category validation
+*/
+const validateNode = (dataset, schema, node, shape, options = {}) => Effect.map(validate(dataset, schema, [{
+	node,
+	shape
+}], options), (r) => Arr.getUnsafe(r.results, 0));
+/**
+* Formats a shape result on one line: `<node>@<shape>` and, when it does
+* not conform, why.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const formatResult = (result) => {
+	const label = isStart(result.shape) ? "START" : `<${result.shape}>`;
+	const association = `${result.node.key}@${label}`;
+	return result.reason === void 0 ? `${association}: ${result.status}` : `${association}: ${result.reason}`;
+};
+const nonconformance = (failing, data, options) => {
+	const issues = Arr.map(failing, (result) => new SchemaIssue.InvalidValue({
+		message: formatResult(result),
+		result
+	}, result, options));
+	return new SchemaIssue.Composite(DatasetSchema.ast, issues, data);
+};
+/**
+* A `Schema` that accepts a `Dataset` only if every association of the
+* shape map (or the single `{ node, shape }`) conforms, so ShEx validation
+* fits into `Schema.decode` pipelines. It takes a prepared `Validator`
+* (`make`), so imports are resolved before the schema is built and decoding
+* needs no services.
+*
+* Decoding fails with a `SchemaIssue.Composite` holding one `InvalidValue`
+* issue per nonconformant association: its `message` annotation is the
+* formatted result (`formatResult`) and its `result` annotation the
+* `ShapeResult`. A shape map naming an undeclared shape fails with one
+* `InvalidValue`. 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(validator, map)))`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const schema = (validator, shapeMap) => {
+	const map = "node" in shapeMap ? [shapeMap] : shapeMap;
+	return DatasetSchema.pipe(Schema.decodeTo(DatasetSchema, SchemaTransformation.transformEffect({
+		decode: (data, options) => validator.validate(data, map).pipe(Effect.mapError((e) => new SchemaIssue.InvalidValue({ message: e.message }, data, options)), Effect.flatMap((report) => {
+			const failing = Arr.filter(report.results, (r) => r.status === "nonconformant");
+			return Arr.isReadonlyArrayNonEmpty(failing) ? Effect.fail(nonconformance(failing, data, options)) : Effect.succeed(data);
+		})),
+		encode: (data) => Effect.succeed(data)
+	})));
+};
+export { loaderLayer as a, schema as c, loaderFromRecord as i, validate as l, Validator_exports as n, make as o, formatResult as r, resolveImports as s, SchemaLoader as t, validateNode as u };
+
+//# sourceMappingURL=Validator-BzXMKDeJ.mjs.map