schemair 0.1.0 → 0.2.0

package/dist/standard/index.js

@@ -0,0 +1,777 @@
+import { a as STANDARD_CONSTRAINT_PATH_LIST, i as STANDARD_CONSTRAINT_PATHS, n as STANDARD_SEMANTIC_DEFINITIONS, o as STANDARD_SEMANTIC_PATHS, r as STANDARD_SEMANTIC_RELATIONS, s as STANDARD_SEMANTIC_PATH_LIST, t as STANDARD_CONSTRAINT_DEFINITIONS } from "../standard-DhKsxu9U.js";
+import { f as validateSchemaNodeDefinition } from "../definition-DmYnDmQO.js";
+
+//#region src/standard/runtime.ts
+function pathKey(path) {
+	return path.map((segment) => {
+		let key = "";
+		for (const character of segment) {
+			const code = character.charCodeAt(0);
+			key += character.length === 1 && code >= 55296 && code <= 57343 ? `%u${code.toString(16).toUpperCase()}` : encodeURIComponent(character);
+		}
+		return key;
+	}).join("/");
+}
+function definitionMap(definitions) {
+	const result = Object.create(null);
+	for (const definition of definitions) result[pathKey(definition.path)] = definition;
+	return result;
+}
+const STANDARD_SEMANTIC_DEFINITION_MAP = definitionMap(STANDARD_SEMANTIC_DEFINITIONS);
+const STANDARD_CONSTRAINT_DEFINITION_MAP = definitionMap(STANDARD_CONSTRAINT_DEFINITIONS);
+const standardVocabularyRegistry = Object.freeze({
+	semanticDefinitions: STANDARD_SEMANTIC_DEFINITION_MAP,
+	constraintDefinitions: STANDARD_CONSTRAINT_DEFINITION_MAP
+});
+function isStandardSemanticNamespace(path) {
+	return Boolean(path && path.length > 0 && path[0] === "std");
+}
+function isExtensionSemanticPath(path) {
+	return Boolean(path && path.length > 0 && path[0] === "ext");
+}
+function classifySemanticPath(path) {
+	if (!path || path.length === 0) return void 0;
+	const key = pathKey(path);
+	const definition = STANDARD_SEMANTIC_DEFINITION_MAP[key];
+	if (definition) return {
+		path: [...path],
+		key,
+		resolution: "standard",
+		definition
+	};
+	return {
+		path: [...path],
+		key,
+		resolution: isExtensionSemanticPath(path) ? "extension" : "unresolved"
+	};
+}
+
+//#endregion
+//#region src/standard/exact-rational.ts
+const DEFAULT_EXACT_RATIONAL_MAX_BITS = 4096;
+function absolute(value) {
+	return value < 0n ? -value : value;
+}
+function greatestCommonDivisorInteger(left, right) {
+	let a = absolute(left);
+	let b = absolute(right);
+	while (b !== 0n) {
+		const remainder = a % b;
+		a = b;
+		b = remainder;
+	}
+	return a;
+}
+function leastCommonMultipleInteger(left, right) {
+	if (left === 0n || right === 0n) return 0n;
+	return absolute(left / greatestCommonDivisorInteger(left, right) * right);
+}
+function bitLength(value) {
+	const magnitude = absolute(value);
+	return magnitude === 0n ? 0 : magnitude.toString(2).length;
+}
+function normalizeRational(numerator, denominator, maxBits) {
+	if (denominator === 0n) return {
+		ok: false,
+		reason: "division_by_zero"
+	};
+	if (numerator === 0n) return {
+		ok: true,
+		value: {
+			numerator: 0n,
+			denominator: 1n
+		}
+	};
+	const sign = denominator < 0n ? -1n : 1n;
+	const divisor = greatestCommonDivisorInteger(numerator, denominator);
+	const reducedNumerator = numerator / divisor * sign;
+	const reducedDenominator = absolute(denominator / divisor);
+	if (bitLength(reducedNumerator) > maxBits || bitLength(reducedDenominator) > maxBits) return {
+		ok: false,
+		reason: "max_bits_exceeded"
+	};
+	return {
+		ok: true,
+		value: {
+			numerator: reducedNumerator,
+			denominator: reducedDenominator
+		}
+	};
+}
+function exactRationalFromFiniteNumber(value, maxBits = DEFAULT_EXACT_RATIONAL_MAX_BITS) {
+	if (!Number.isFinite(value)) return {
+		ok: false,
+		reason: "invalid_number"
+	};
+	if (Object.is(value, -0) || value === 0) return {
+		ok: true,
+		value: {
+			numerator: 0n,
+			denominator: 1n
+		}
+	};
+	const source = String(value);
+	const match = /^(-?)(\d+)(?:\.(\d+))?(?:e([+-]?\d+))?$/i.exec(source);
+	if (!match) return {
+		ok: false,
+		reason: "invalid_number"
+	};
+	const sign = match[1] === "-" ? -1n : 1n;
+	const integerDigits = match[2] ?? "";
+	const fractionDigits = match[3] ?? "";
+	const exponent = Number(match[4] ?? 0);
+	const digits = BigInt(`${integerDigits}${fractionDigits}`);
+	const decimalScale = fractionDigits.length - exponent;
+	if (decimalScale <= 0) return normalizeRational(sign * digits * 10n ** BigInt(-decimalScale), 1n, maxBits);
+	return normalizeRational(sign * digits, 10n ** BigInt(decimalScale), maxBits);
+}
+function exactRationalIsIntegerMultiple(value, divisor, maxBits = DEFAULT_EXACT_RATIONAL_MAX_BITS) {
+	if (divisor.numerator === 0n) return {
+		ok: false,
+		reason: "division_by_zero"
+	};
+	const quotient = normalizeRational(value.numerator * divisor.denominator, value.denominator * divisor.numerator, maxBits);
+	if (!quotient.ok) return quotient;
+	return {
+		ok: true,
+		value: quotient.value.numerator % quotient.value.denominator === 0n
+	};
+}
+function greatestCommonDivisorRationals(values, maxBits = DEFAULT_EXACT_RATIONAL_MAX_BITS) {
+	if (values.length === 0 || values.some((value) => value.numerator === 0n)) return {
+		ok: false,
+		reason: "division_by_zero"
+	};
+	let commonDenominator = 1n;
+	for (const value of values) {
+		commonDenominator = leastCommonMultipleInteger(commonDenominator, value.denominator);
+		if (bitLength(commonDenominator) > maxBits) return {
+			ok: false,
+			reason: "max_bits_exceeded"
+		};
+	}
+	let commonNumerator;
+	for (const value of values) {
+		const scaled = absolute(value.numerator) * (commonDenominator / value.denominator);
+		commonNumerator = commonNumerator === void 0 ? scaled : greatestCommonDivisorInteger(commonNumerator, scaled);
+	}
+	return normalizeRational(commonNumerator ?? 0n, commonDenominator, maxBits);
+}
+function leastCommonMultipleRationals(values, maxBits = DEFAULT_EXACT_RATIONAL_MAX_BITS) {
+	if (values.length === 0 || values.some((value) => value.numerator === 0n)) return {
+		ok: false,
+		reason: "division_by_zero"
+	};
+	let result = {
+		numerator: absolute(values[0].numerator),
+		denominator: values[0].denominator
+	};
+	for (let index = 1; index < values.length; index += 1) {
+		const value = values[index];
+		const divisor = greatestCommonDivisorRationals([result, value], maxBits);
+		if (!divisor.ok) return divisor;
+		const multiplied = normalizeRational(result.numerator * absolute(value.numerator), result.denominator * value.denominator, maxBits);
+		if (!multiplied.ok) return multiplied;
+		const joined = normalizeRational(multiplied.value.numerator * divisor.value.denominator, multiplied.value.denominator * absolute(divisor.value.numerator), maxBits);
+		if (!joined.ok) return joined;
+		result = joined.value;
+	}
+	return {
+		ok: true,
+		value: result
+	};
+}
+function formatExactRational(value) {
+	return value.denominator === 1n ? String(value.numerator) : `${value.numerator}/${value.denominator}`;
+}
+
+//#endregion
+//#region src/standard/constraint-profile.ts
+const sameSegmentPath$1 = (a, b) => a.length === b.length && a.every((segment, index) => segment === b[index]);
+function isStandardConstraintOwner(node) {
+	return node.kind === "primitive" && (node.name === "string" || node.name === "number") || node.kind === "array" || node.kind === "record";
+}
+function strongerLower(current, candidate) {
+	if (!current || candidate.value > current.value) return candidate;
+	if (candidate.value < current.value) return current;
+	return current.inclusive && !candidate.inclusive ? candidate : current;
+}
+function strongerUpper(current, candidate) {
+	if (!current || candidate.value < current.value) return candidate;
+	if (candidate.value > current.value) return current;
+	return current.inclusive && !candidate.inclusive ? candidate : current;
+}
+function nextUp(value) {
+	if (value === 0) return Number.MIN_VALUE;
+	const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+	view.setFloat64(0, value);
+	const bits = view.getBigUint64(0);
+	view.setBigUint64(0, value > 0 ? bits + 1n : bits - 1n);
+	return view.getFloat64(0);
+}
+function intervalIsEmpty(interval) {
+	const { lower, upper } = interval;
+	if (interval.domain === "continuous") {
+		const first = !lower ? -Number.MAX_VALUE : lower.inclusive ? lower.value : nextUp(lower.value);
+		const last = !upper ? Number.MAX_VALUE : upper.inclusive ? upper.value : -nextUp(-upper.value);
+		return !Number.isFinite(first) || !Number.isFinite(last) || first > last;
+	}
+	if (!lower || !upper) return false;
+	if (lower.value > upper.value) return true;
+	if (lower.value === upper.value) return !lower.inclusive || !upper.inclusive;
+	return (lower.inclusive ? Math.ceil(lower.value) : Math.floor(lower.value) + 1) > (upper.inclusive ? Math.floor(upper.value) : Math.ceil(upper.value) - 1);
+}
+function intervalContainsZero(interval) {
+	const lowerAccepts = !interval.lower || interval.lower.value < 0 || interval.lower.value === 0 && interval.lower.inclusive;
+	const upperAccepts = !interval.upper || interval.upper.value > 0 || interval.upper.value === 0 && interval.upper.inclusive;
+	return lowerAccepts && upperAccepts;
+}
+function isConstraint(constraint, path) {
+	return sameSegmentPath$1(constraint.constraintPath, path);
+}
+function buildStandardConstraintProfile(node, options = {}) {
+	const constraints = node.constraints ?? [];
+	const multipleOf = [];
+	const patterns = [];
+	const unhandled = [];
+	const invalid = [];
+	let budgetExceeded = false;
+	let uniqueItems;
+	let domain;
+	let lower;
+	let upper;
+	if (node.kind === "primitive" && node.name === "number") domain = "continuous";
+	else {
+		domain = "integer";
+		lower = {
+			value: 0,
+			inclusive: true
+		};
+		if (node.kind === "record") {
+			lower = {
+				value: node.fields.filter((field) => field.required === true).length,
+				inclusive: true
+			};
+			if (node.additionalFields === void 0) upper = {
+				value: node.fields.length,
+				inclusive: true
+			};
+		}
+	}
+	for (const constraint of constraints) {
+		if (node.kind === "primitive" && node.name === "number" && isConstraint(constraint, STANDARD_CONSTRAINT_PATHS.number.multipleOf)) {
+			if (typeof constraint.args !== "number" || !Number.isFinite(constraint.args) || constraint.args <= 0) {
+				invalid.push(constraint);
+				continue;
+			}
+			const rational = exactRationalFromFiniteNumber(constraint.args, options.maxRationalBits ?? DEFAULT_EXACT_RATIONAL_MAX_BITS);
+			if (!rational.ok) if (rational.reason === "max_bits_exceeded") budgetExceeded = true;
+			else invalid.push(constraint);
+			else multipleOf.push(rational.value);
+			continue;
+		}
+		if (node.kind === "primitive" && node.name === "string" && isConstraint(constraint, STANDARD_CONSTRAINT_PATHS.string.pattern)) {
+			if (typeof constraint.args !== "string") invalid.push(constraint);
+			else try {
+				new RegExp(constraint.args);
+				patterns.push(constraint.args);
+			} catch {
+				invalid.push(constraint);
+			}
+			continue;
+		}
+		if (node.kind === "array" && isConstraint(constraint, STANDARD_CONSTRAINT_PATHS.array.uniqueItems)) {
+			if (typeof constraint.args !== "boolean") invalid.push(constraint);
+			else if (constraint.args) uniqueItems = true;
+			continue;
+		}
+		const definition = STANDARD_CONSTRAINT_DEFINITION_MAP[pathKey(constraint.constraintPath)];
+		const target = node.kind === "primitive" ? node.name : node.kind;
+		if (definition && (definition.target !== target || typeof constraint.args !== definition.argsType || definition.argsDomain === "nonNegativeInteger" && (typeof constraint.args !== "number" || !Number.isSafeInteger(constraint.args) || constraint.args < 0))) {
+			invalid.push(constraint);
+			continue;
+		}
+		if (typeof constraint.args !== "number" || !Number.isFinite(constraint.args)) {
+			unhandled.push(constraint);
+			continue;
+		}
+		let nextLower;
+		let nextUpper;
+		if (node.kind === "primitive" && node.name === "number") {
+			if (isConstraint(constraint, STANDARD_CONSTRAINT_PATHS.number.minimum)) nextLower = {
+				value: constraint.args,
+				inclusive: true
+			};
+			else if (isConstraint(constraint, STANDARD_CONSTRAINT_PATHS.number.exclusiveMinimum)) nextLower = {
+				value: constraint.args,
+				inclusive: false
+			};
+			else if (isConstraint(constraint, STANDARD_CONSTRAINT_PATHS.number.maximum)) nextUpper = {
+				value: constraint.args,
+				inclusive: true
+			};
+			else if (isConstraint(constraint, STANDARD_CONSTRAINT_PATHS.number.exclusiveMaximum)) nextUpper = {
+				value: constraint.args,
+				inclusive: false
+			};
+		} else {
+			const lowerPath = node.kind === "array" ? STANDARD_CONSTRAINT_PATHS.array.minItems : node.kind === "record" ? STANDARD_CONSTRAINT_PATHS.record.minProperties : STANDARD_CONSTRAINT_PATHS.string.minLength;
+			const upperPath = node.kind === "array" ? STANDARD_CONSTRAINT_PATHS.array.maxItems : node.kind === "record" ? STANDARD_CONSTRAINT_PATHS.record.maxProperties : STANDARD_CONSTRAINT_PATHS.string.maxLength;
+			if (isConstraint(constraint, lowerPath)) nextLower = {
+				value: constraint.args,
+				inclusive: true
+			};
+			else if (isConstraint(constraint, upperPath)) nextUpper = {
+				value: constraint.args,
+				inclusive: true
+			};
+		}
+		if (nextLower || nextUpper) {
+			if (domain === "integer" && (!Number.isSafeInteger(constraint.args) || constraint.args < 0)) {
+				invalid.push(constraint);
+				continue;
+			}
+			if (nextLower) lower = strongerLower(lower, nextLower);
+			if (nextUpper) upper = strongerUpper(upper, nextUpper);
+		} else unhandled.push(constraint);
+	}
+	const interval = {
+		domain,
+		...lower === void 0 ? {} : { lower },
+		...upper === void 0 ? {} : { upper }
+	};
+	let satisfiability;
+	if (intervalIsEmpty(interval)) satisfiability = "empty";
+	else if (invalid.length > 0 || budgetExceeded || unhandled.length > 0 || patterns.length > 0) satisfiability = "unknown";
+	else if (multipleOf.length > 0 && !intervalContainsZero(interval)) satisfiability = "unknown";
+	else satisfiability = "satisfiable";
+	return {
+		interval,
+		multipleOf,
+		...uniqueItems === void 0 ? {} : { uniqueItems },
+		patterns,
+		unhandled,
+		invalid,
+		budgetExceeded,
+		satisfiability
+	};
+}
+
+//#endregion
+//#region src/standard/payload.ts
+function isIPv4(value) {
+	if (typeof value !== "string") return false;
+	const parts = value.split(".");
+	return parts.length === 4 && parts.every((part) => {
+		if (!/^\d{1,3}$/.test(part)) return false;
+		if (part.length > 1 && part[0] === "0") return false;
+		return Number(part) <= 255;
+	});
+}
+function isIPv6(value) {
+	if (typeof value !== "string" || value.length === 0) return false;
+	const halves = value.split("::");
+	if (halves.length > 2) return false;
+	const parsePart = (part) => {
+		if (part.length === 0) return 0;
+		const pieces = part.split(":");
+		let count = 0;
+		for (const [index, piece] of pieces.entries()) if (piece.includes(".")) {
+			if (index !== pieces.length - 1 || !isIPv4(piece)) return -1;
+			count += 2;
+		} else {
+			if (!/^[0-9a-f]{1,4}$/i.test(piece)) return -1;
+			count += 1;
+		}
+		return count;
+	};
+	const left = parsePart(halves[0]);
+	const right = halves.length === 2 ? parsePart(halves[1]) : 0;
+	if (left < 0 || right < 0) return false;
+	return halves.length === 2 ? left + right < 8 : left === 8;
+}
+/** These predicates are a TypeScript host policy, not universal protocol predicates. */
+const predicates = {
+	"std/string/date": (value) => {
+		if (typeof value !== "string") return false;
+		const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+		if (!m) return false;
+		const year = Number(m[1]), month = Number(m[2]), day = Number(m[3]);
+		const days = month === 2 ? year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28 : [
+			4,
+			6,
+			9,
+			11
+		].includes(month) ? 30 : 31;
+		return month >= 1 && month <= 12 && day >= 1 && day <= days;
+	},
+	"std/string/datetime": (value) => typeof value === "string" && Number.isFinite(Date.parse(value)),
+	"std/string/datetime/iso": (value) => typeof value === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})?$/.test(value) && predicates["std/string/date"](value.slice(0, 10)) && Number(value.slice(11, 13)) < 24 && Number(value.slice(14, 16)) < 60 && Number.isFinite(Date.parse(value)),
+	"std/string/email": (value) => typeof value === "string" && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
+	"std/string/url": (value) => typeof value === "string" && /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/i.test(value),
+	"std/string/ip/v4": isIPv4,
+	"std/string/ip/v6": isIPv6,
+	"std/string/uuid": (value) => typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value),
+	"std/string/uuid/v4": (value) => typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value),
+	"std/string/json": (value) => {
+		if (typeof value !== "string") return false;
+		try {
+			JSON.parse(value);
+			return true;
+		} catch {
+			return false;
+		}
+	},
+	"std/string/base64": (value) => typeof value === "string" && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value),
+	"std/string/base64url": (value) => typeof value === "string" && /^[A-Za-z0-9_-]+$/.test(value),
+	"std/string/hex": (value) => typeof value === "string" && /^[0-9a-f]+$/i.test(value),
+	"std/string/decimal": (value) => typeof value === "string" && /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/.test(value),
+	"std/string/bigint": (value) => typeof value === "string" && /^(?:0|-[1-9][0-9]*|[1-9][0-9]*)$/.test(value),
+	"std/number/integer": (value) => typeof value === "number" && Number.isFinite(value) && Number.isInteger(value),
+	"std/number/safeInteger": (value) => typeof value === "number" && Number.isSafeInteger(value),
+	"std/number/epochMillis": (value) => typeof value === "number" && Number.isFinite(value) && Number.isInteger(value),
+	"std/number/epochSeconds": (value) => typeof value === "number" && Number.isFinite(value) && Number.isInteger(value)
+};
+const unknown = (message) => ({
+	status: "unknown",
+	message
+});
+const standardSemanticProvider = (path, value, context) => {
+	const key = pathKey(path), definition = STANDARD_SEMANTIC_DEFINITION_MAP[key];
+	if (!definition) return unknown("Unknown semantic path; supply a host provider");
+	if (context.schema.kind !== "primitive" || context.schema.name !== definition.primitive || typeof value !== definition.primitive) return false;
+	if (definition.role === "annotation") return true;
+	return predicates[key]?.(value) ?? unknown("No standard semantic predicate");
+};
+/** Canonical JSON equality ignores object property order and treats -0 as 0. */
+function valueKey(value, active = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+	if (typeof value === "number") return Number.isFinite(value) ? String(value) : void 0;
+	if (typeof value !== "object" || active.has(value)) return void 0;
+	if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return void 0;
+	active.add(value);
+	const keys = Array.isArray(value) ? Array.from({ length: value.length }, (_, i) => String(i)) : Object.keys(value).sort();
+	const parts = [];
+	for (const key of keys) {
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (!descriptor || !("value" in descriptor)) {
+			active.delete(value);
+			return;
+		}
+		const part = valueKey(descriptor.value, active);
+		if (part === void 0) {
+			active.delete(value);
+			return;
+		}
+		parts.push(Array.isArray(value) ? part : `${JSON.stringify(key)}:${part}`);
+	}
+	active.delete(value);
+	return Array.isArray(value) ? `[${parts.join(",")}]` : `{${parts.join(",")}}`;
+}
+function standardConstraintTarget(node) {
+	return node.kind === "primitive" ? node.name : node.kind;
+}
+const standardConstraintProvider = (path, args, value, context) => {
+	const definition = STANDARD_CONSTRAINT_DEFINITION_MAP[pathKey(path)];
+	if (!definition) return unknown("Unknown constraint path; supply a host provider");
+	if (standardConstraintTarget(context.schema) !== definition.target || typeof args !== definition.argsType) return false;
+	if (typeof args === "number" && (!Number.isFinite(args) || definition.argsDomain === "nonNegativeInteger" && (!Number.isSafeInteger(args) || args < 0) || definition.argsDomain === "positiveNumber" && args <= 0)) return false;
+	const name = definition.path[1];
+	if (name === "pattern") {
+		if (typeof value !== "string" || typeof args !== "string") return false;
+		try {
+			return new RegExp(args).test(value);
+		} catch {
+			return unknown("Pattern is unsupported by the ECMAScript regex engine");
+		}
+	}
+	if (name === "uniqueItems") {
+		if (!Array.isArray(value)) return false;
+		if (args === false) return true;
+		const keys = value.map((item) => valueKey(item));
+		if (keys.some((key) => key === void 0)) return unknown("uniqueItems requires finite JSON values");
+		return new Set(keys).size === keys.length;
+	}
+	if (typeof args !== "number") return false;
+	if (definition.target === "number") {
+		if (typeof value !== "number" || !Number.isFinite(value)) return false;
+		switch (name) {
+			case "minimum": return value >= args;
+			case "maximum": return value <= args;
+			case "exclusiveMinimum": return value > args;
+			case "exclusiveMaximum": return value < args;
+			case "multipleOf": {
+				const v = exactRationalFromFiniteNumber(value), d = exactRationalFromFiniteNumber(args);
+				if (!v.ok || !d.ok) return unknown("Exact rational budget exceeded");
+				const result = exactRationalIsIntegerMultiple(v.value, d.value);
+				return result.ok ? result.value : unknown("Exact rational budget exceeded");
+			}
+		}
+	}
+	const size = definition.target === "string" && typeof value === "string" ? [...value].length : definition.target === "array" && Array.isArray(value) ? value.length : definition.target === "record" && value !== null && typeof value === "object" && !Array.isArray(value) ? Object.keys(value).length : void 0;
+	if (size === void 0) return false;
+	return name?.startsWith("min") ? size >= args : size <= args;
+};
+function providerMap(definitions, provider) {
+	const result = Object.create(null);
+	for (const definition of definitions) result[pathKey(definition.path)] = provider;
+	return Object.freeze(result);
+}
+const standardSemanticRegistry = providerMap(STANDARD_SEMANTIC_DEFINITIONS, standardSemanticProvider);
+const standardConstraintRegistry = providerMap(STANDARD_CONSTRAINT_DEFINITIONS, standardConstraintProvider);
+/** Opt in explicitly; core validation never silently installs vocabulary policy. */
+const standardPayloadContext = Object.freeze({
+	semanticProvider: standardSemanticProvider,
+	constraintProvider: standardConstraintProvider
+});
+
+//#endregion
+//#region src/standard/operations.ts
+function standardSchemaSatisfiability(node) {
+	if (!validateSchemaNodeDefinition(node).ok || !isStandardConstraintOwner(node)) return "unknown";
+	const profile = buildStandardConstraintProfile(node);
+	if (profile.invalid.length || profile.budgetExceeded || profile.unhandled.length) return "unknown";
+	if (profile.satisfiability === "empty") return "emptySet";
+	if (node.kind === "primitive" && node.semanticPath) return "unknown";
+	if (node.kind === "record" || node.kind === "array") return "unknown";
+	return profile.satisfiability === "satisfiable" ? "inhabited" : "unknown";
+}
+function refineStandardSchema(node, addConstraints) {
+	if (!validateSchemaNodeDefinition(node).ok || !isStandardConstraintOwner(node)) return {
+		status: "unsupported",
+		message: "Expected a valid constraint-bearing schema"
+	};
+	const schema = {
+		...node,
+		constraints: [...node.constraints ?? [], ...addConstraints]
+	};
+	if (!validateSchemaNodeDefinition(schema).ok) return {
+		status: "unsupported",
+		message: "Invalid constraint data"
+	};
+	const profile = buildStandardConstraintProfile(schema);
+	if (profile.invalid.length || profile.budgetExceeded || profile.unhandled.length) return {
+		status: "unknown",
+		message: "Unsupported or invalid constraint profile"
+	};
+	if (profile.satisfiability === "empty") return { status: "emptySet" };
+	return {
+		status: "resolved",
+		schema
+	};
+}
+function intersectStandardSchemas(left, right) {
+	if (!validateSchemaNodeDefinition(left).ok || !validateSchemaNodeDefinition(right).ok || left.kind !== "primitive" || right.kind !== "primitive" || left.name !== right.name || !isStandardConstraintOwner(left) || !isStandardConstraintOwner(right)) return {
+		status: "unsupported",
+		message: "Standard intersection supports string/number primitives"
+	};
+	if (left.semanticPath && right.semanticPath && JSON.stringify(left.semanticPath) !== JSON.stringify(right.semanticPath)) return {
+		status: "unknown",
+		message: "Semantic intersection cannot be proved"
+	};
+	return refineStandardSchema({
+		...left,
+		...right.semanticPath ? { semanticPath: [...right.semanticPath] } : {}
+	}, right.constraints ?? []);
+}
+
+//#endregion
+//#region src/standard/relations.ts
+const sameSegmentPath = (a, b) => a.length === b.length && a.every((segment, index) => segment === b[index]);
+const issue = (code, message, path, details) => ({
+	status: code === "incompatible_schema" ? "incompatible" : "unknown",
+	issues: [{
+		code,
+		message,
+		path,
+		...details === void 0 ? {} : { details }
+	}]
+});
+const ok = () => ({ status: "assignable" });
+const refKey = (path) => JSON.stringify(path);
+const pathEquals = (left, right) => refKey(left) === refKey(right);
+function primitiveType(value) {
+	return typeof value;
+}
+function semanticRelation(source, target, path, context) {
+	if (source.kind !== "primitive" && source.kind !== "literal" || target.kind !== "primitive") return ok();
+	const sourceNameKind = source.kind === "literal" ? primitiveType(source.literal) : source.name;
+	if (sourceNameKind !== "string" && sourceNameKind !== "number" || sourceNameKind !== target.name) return ok();
+	const sourcePath = "semanticPath" in source && source.semanticPath?.length ? source.semanticPath : void 0;
+	const targetPath = target.semanticPath?.length ? target.semanticPath : void 0;
+	if (!targetPath) {
+		if (source.kind === "literal") return ok();
+		return (context.semanticIdentityPolicy ?? "ignore") === "ignore" ? ok() : issue("incompatible_schema", "Semantic identity is missing from the target schema", path);
+	}
+	if ((context.semanticIdentityPolicy ?? "ignore") !== "ignore") {
+		if (!sourcePath) return issue("incompatible_schema", "Semantic identity is missing from the source schema", path);
+		if (!(context.semanticIdentityPolicy === "exact" ? pathEquals(sourcePath, targetPath) : sourcePath.length >= targetPath.length && targetPath.every((segment, index) => sourcePath[index] === segment))) return issue("incompatible_schema", "Semantic identity is not assignable to the target identity", path);
+	}
+	if (!classifySemanticPath(targetPath)?.definition || sourcePath && !classifySemanticPath(sourcePath)?.definition) return issue("semantic_relation_unknown", "Unknown semantic path requires a host provider", path);
+	if (sourcePath && pathEquals(sourcePath, targetPath)) return ok();
+	const targetDefinition = classifySemanticPath(targetPath);
+	if (targetDefinition?.definition?.role === "annotation") return ok();
+	if (source.kind === "literal" && targetDefinition?.definition?.role === "validation") {
+		const validated = standardSemanticProvider(targetPath, source.literal, {
+			schema: target,
+			rootSchema: target,
+			path
+		});
+		return validated === true ? ok() : validated === false ? issue("incompatible_schema", "Literal does not satisfy target validation semantic", path) : issue("semantic_relation_unknown", "Semantic predicate is unknown", path);
+	}
+	const sourceDefinition = sourcePath ? classifySemanticPath(sourcePath) : void 0;
+	const sourceName = sourcePath?.join("/");
+	const targetName = targetPath.join("/");
+	if (STANDARD_SEMANTIC_RELATIONS.some((relation) => relation.kind === "acceptedSetSubset" && relation.source.join("/") === sourceName && relation.target.join("/") === targetName)) {
+		if ((context.semanticIdentityPolicy ?? "ignore") === "exact" && JSON.stringify(sourcePath) !== JSON.stringify(targetPath)) return issue("incompatible_schema", "Semantic identity is not exact", path);
+		return ok();
+	}
+	if (targetDefinition?.resolution === "extension") return issue("semantic_relation_unknown", "Extension vocabulary requires a provider", path);
+	if (sourceDefinition?.definition?.role === "validation" && targetDefinition?.definition?.role === "validation") return issue("semantic_relation_unknown", "Semantic validation relation is not proven", path, {
+		relation: "accepted_set",
+		sourceSemanticPath: sourcePath ?? null,
+		targetSemanticPath: targetPath
+	});
+	return issue("semantic_relation_unknown", "Accepted-set semantic implication is not proven", path);
+}
+function constraintsOf(node) {
+	return "constraints" in node ? node.constraints ?? [] : [];
+}
+function lowerImplies(source, target) {
+	if (!target) return true;
+	if (!source) return false;
+	return source.value > target.value || source.value === target.value && (target.inclusive || !source.inclusive);
+}
+function upperImplies(source, target) {
+	if (!target) return true;
+	if (!source) return false;
+	return source.value < target.value || source.value === target.value && (target.inclusive || !source.inclusive);
+}
+function exactConstraintIncluded(source, target) {
+	return source.some((candidate) => sameSegmentPath(candidate.constraintPath, target.constraintPath) && JSON.stringify(candidate.args) === JSON.stringify(target.args));
+}
+function constraintOwner(node) {
+	return node.kind === "primitive" && (node.name === "string" || node.name === "number") || node.kind === "array" || node.kind === "record" ? node : void 0;
+}
+function literalProfile(source, target) {
+	if (source.kind !== "literal") return void 0;
+	if (target.kind === "primitive" && target.name === "number" && typeof source.literal === "number") return {
+		interval: {
+			domain: "continuous",
+			lower: {
+				value: source.literal,
+				inclusive: true
+			},
+			upper: {
+				value: source.literal,
+				inclusive: true
+			}
+		},
+		multipleOf: [],
+		patterns: [],
+		unhandled: [],
+		invalid: [],
+		budgetExceeded: false,
+		satisfiability: "satisfiable"
+	};
+	if (target.kind === "primitive" && target.name === "string" && typeof source.literal === "string") {
+		const length = [...source.literal].length;
+		return {
+			interval: {
+				domain: "integer",
+				lower: {
+					value: length,
+					inclusive: true
+				},
+				upper: {
+					value: length,
+					inclusive: true
+				}
+			},
+			multipleOf: [],
+			patterns: [],
+			unhandled: [],
+			invalid: [],
+			budgetExceeded: false,
+			satisfiability: "satisfiable"
+		};
+	}
+}
+function multipleOfImplies(source, target) {
+	if (target.length === 0) return true;
+	if (source.length === 0) return false;
+	const joined = leastCommonMultipleRationals(source);
+	return joined.ok && target.every((value) => {
+		const relation = exactRationalIsIntegerMultiple(joined.value, value);
+		return relation.ok && relation.value;
+	});
+}
+function constraintRelation(source, target, path, context) {
+	const targetOwner = constraintOwner(target);
+	if (constraintsOf(target).length === 0) return ok();
+	if (!targetOwner) return issue("constraint_relation_unknown", "Target cannot carry these constraints", path);
+	if (constraintsOf(target).find((constraint) => constraint.constraintPath[0] === "ext")) return issue("constraint_relation_unknown", "Extension vocabulary requires a provider", path);
+	const sourceOwner = constraintOwner(source);
+	const sourceProfile = literalProfile(source, targetOwner) ?? (sourceOwner ? buildStandardConstraintProfile(sourceOwner) : void 0);
+	const targetProfile = buildStandardConstraintProfile(targetOwner);
+	if (!sourceProfile || sourceProfile.invalid.length > 0 || sourceProfile.budgetExceeded || targetProfile.invalid.length > 0 || targetProfile.budgetExceeded) return issue("constraint_relation_unknown", "Constraint relation cannot be proven for an invalid or unsupported profile", path);
+	if (sourceProfile.unhandled.length || targetProfile.unhandled.length) return issue("constraint_relation_unknown", "Unknown constraint path requires a host provider", path);
+	if (sourceProfile.satisfiability === "empty") return ok();
+	if (targetProfile.satisfiability === "empty") return issue("constraint_relation_unknown", "Source satisfiability is not established", path);
+	if (targetProfile.multipleOf.length > 0) {
+		const literal = source.kind === "literal" && typeof source.literal === "number" ? exactRationalFromFiniteNumber(source.literal) : void 0;
+		if (!(literal?.ok === true && targetProfile.multipleOf.every((value) => {
+			const relation = exactRationalIsIntegerMultiple(literal.value, value);
+			return relation.ok && relation.value;
+		})) && !multipleOfImplies(sourceProfile.multipleOf, targetProfile.multipleOf)) return issue("constraint_relation_unknown", "multipleOf relation cannot be proven", path);
+	}
+	if (targetProfile.uniqueItems === true && sourceProfile.uniqueItems !== true) return issue("constraint_relation_unknown", "uniqueItems relation cannot be proven", path);
+	if (targetProfile.patterns.length > 0) {
+		if (source.kind === "literal" && typeof source.literal === "string") for (const pattern of targetProfile.patterns) try {
+			if (!new RegExp(pattern).test(source.literal)) return issue("incompatible_schema", "String literal does not satisfy target pattern", path);
+		} catch {
+			return issue("constraint_relation_unknown", "Pattern relation cannot be proven", path);
+		}
+		else if (!targetProfile.patterns.every((pattern) => constraintsOf(source).some((constraint) => pathEquals(constraint.constraintPath, STANDARD_CONSTRAINT_PATHS.string.pattern) && constraint.args === pattern))) return issue("constraint_relation_unknown", "Pattern relation cannot be proven for a non-literal source", path);
+	}
+	for (const targetConstraint of targetProfile.unhandled) {
+		if (target.kind === "primitive" && target.name === "string" && pathEquals(targetConstraint.constraintPath, STANDARD_CONSTRAINT_PATHS.string.pattern) && source.kind === "literal" && typeof source.literal === "string") {
+			try {
+				if (!new RegExp(String(targetConstraint.args)).test(source.literal)) return issue("incompatible_schema", "String literal does not satisfy target pattern", path);
+			} catch {
+				return issue("constraint_relation_unknown", "Pattern relation cannot be proven", path);
+			}
+			continue;
+		}
+		if (!exactConstraintIncluded(constraintsOf(source), targetConstraint)) return issue("constraint_relation_unknown", "No implication handler is available for target constraint", path, { constraintPath: [...targetConstraint.constraintPath] });
+	}
+	if (!targetProfile.interval || !sourceProfile.interval || sourceProfile.interval.domain !== targetProfile.interval.domain) return issue("constraint_relation_unknown", "Constraint interval domains cannot be compared", path);
+	if (lowerImplies(sourceProfile.interval.lower, targetProfile.interval.lower) && upperImplies(sourceProfile.interval.upper, targetProfile.interval.upper)) return ok();
+	if (sourceProfile.unhandled.length > 0) return issue("constraint_relation_unknown", "Unsupported source constraints may further narrow the accepted-value set", path);
+	return issue("constraint_relation_unknown", "Interval implication is not proven", path);
+}
+function decision(result) {
+	const message = result.issues?.[0]?.message;
+	return {
+		status: result.status,
+		...message ? { message } : {}
+	};
+}
+/** Accepted-set policy; unknown implication is never treated as compatibility. */
+function createStandardRelationContext(options = {}) {
+	return {
+		semanticProvider: (_sourcePath, _targetPath, context) => decision(semanticRelation(context.sourceSchema, context.targetSchema, [], options)),
+		constraintProvider: (_sourceConstraints, _targetConstraints, context) => decision(constraintRelation(context.sourceSchema, context.targetSchema, [], options))
+	};
+}
+const standardRelationContext = Object.freeze(createStandardRelationContext());
+const standardVocabularyProvider = Object.freeze({
+	payload: standardPayloadContext,
+	relation: standardRelationContext,
+	refine: refineStandardSchema,
+	intersect: intersectStandardSchemas,
+	satisfiability: standardSchemaSatisfiability
+});
+
+//#endregion
+export { DEFAULT_EXACT_RATIONAL_MAX_BITS, STANDARD_CONSTRAINT_DEFINITIONS, STANDARD_CONSTRAINT_DEFINITION_MAP, STANDARD_CONSTRAINT_PATHS, STANDARD_CONSTRAINT_PATH_LIST, STANDARD_SEMANTIC_DEFINITIONS, STANDARD_SEMANTIC_DEFINITION_MAP, STANDARD_SEMANTIC_PATHS, STANDARD_SEMANTIC_PATH_LIST, STANDARD_SEMANTIC_RELATIONS, buildStandardConstraintProfile, classifySemanticPath, createStandardRelationContext, exactRationalFromFiniteNumber, exactRationalIsIntegerMultiple, formatExactRational, greatestCommonDivisorRationals, intersectStandardSchemas, isExtensionSemanticPath, isStandardConstraintOwner, isStandardSemanticNamespace, leastCommonMultipleRationals, pathKey, refineStandardSchema, standardConstraintProvider, standardConstraintRegistry, standardConstraintTarget, standardPayloadContext, standardRelationContext, standardSchemaSatisfiability, standardSemanticProvider, standardSemanticRegistry, standardVocabularyProvider, standardVocabularyRegistry };