schemair 0.2.0 → 0.3.0

package/dist/{type-interpreter-DnrId8aM.js → type-interpreter-BA8gcLUU.js}

@@ -1,5 +1,6 @@
-import { a as expressionShapeIssue, f as validateSchemaNodeDefinition, i as expressionKinds, r as expressionFields } from "./definition-DmYnDmQO.js";
-import { a as checkSchemaRelation, o as checkSchemaRelationAsync } from "./relations-ysXDmi-Z.js";
+import { a as expressionShapeIssue, f as validateSchemaNodeDefinition, i as expressionKinds, n as validateSchemaTypeTermDefinition, r as expressionFields } from "./definition-BH_LzXGc.js";
+import { n as schemaRefKey, t as indexSchemaRefs } from "./schema-ref-key-DR__tPr-.js";
+import { r as checkSchemaRelation } from "./relations-QtnCRW9x.js";
 
 //#region src/type-interpreter/materializer.ts
 function isRecord(value) {
@@ -861,6 +862,18 @@ function compareTerms(source, target, context) {
 					message: "source does not provide a required field"
 				}]
 			};
+			if (!sourceField && source.additionalFields !== void 0) {
+				if (source.additionalFields === true) return {
+					status: "unknown",
+					issues: [{
+						code: "relation.unknown.additionalField",
+						path: ["fields", field.key],
+						message: "unconstrained source residual values do not prove compatibility with the target field"
+					}]
+				};
+				const residual = compareTerms(source.additionalFields, field.value, context);
+				if (residual.status !== "assignable") return residual;
+			}
 			if (sourceField) {
 				if (field.required === true && sourceField.required !== true) return {
 					status: "incompatible",
@@ -935,125 +948,11 @@ function unknownTermRelation() {
 		}]
 	};
 }
-async function compareTermsAsync(source, target, context) {
-	if (source.kind === "never") return {
-		status: "assignable",
-		issues: []
-	};
-	if (source.kind === "absent") return target.kind === "absent" || target.kind === "maybeAbsent" ? {
-		status: "assignable",
-		issues: []
-	} : incompatiblePresence("absent");
-	if (target.kind === "never" || target.kind === "absent") return incompatiblePresence(target.kind);
-	if (source.kind === "maybeAbsent" && target.kind !== "maybeAbsent") return incompatiblePresence("maybeAbsent");
-	if (target.kind === "unknown") return {
-		status: "assignable",
-		issues: []
-	};
-	if (source.kind === "unknown") return unknownTermRelation();
-	if (source.kind === "opaqueHostType" && target.kind === "opaqueHostType") {
-		if (samePath(source.hostPath, target.hostPath)) return {
-			status: "assignable",
-			issues: []
-		};
-		if (!context.hostTypeRelation) return {
-			status: "incompatible",
-			issues: [{
-				code: "relation.incompatible.opaqueHostType",
-				path: [],
-				message: "different opaque host types require an explicit relation provider"
-			}]
-		};
-		return hostDecision(await context.hostTypeRelation(source.hostPath, target.hostPath), "opaque host type relation provider rejected the relation");
-	}
-	if (source.kind === "arrayOf" && target.kind === "arrayOf") {
-		if (!sameData(source.constraints, target.constraints)) return unknownMetadata();
-		return compareTermsAsync(source.element, target.element, context);
-	}
-	if (source.kind === "maybeAbsent" || target.kind === "maybeAbsent") {
-		if (source.kind !== "maybeAbsent") {
-			if (target.kind === "maybeAbsent") return compareTermsAsync(source, target.value, context);
-			return unreachableRelation();
-		}
-		if (target.kind !== "maybeAbsent") return incompatiblePresence("maybeAbsent");
-		return compareTermsAsync(source.value, target.value, context);
-	}
-	if (source.kind === "array" && target.kind === "array") return checkSchemaRelationAsync(source, target, context.relation);
-	if (source.kind === "record" && target.kind === "record") return checkSchemaRelationAsync(source, target, context.relation);
-	if (source.kind === "tupleOf" && target.kind === "tupleOf") {
-		if (source.elements.length !== target.elements.length) return {
-			status: "incompatible",
-			issues: [{
-				code: "relation.incompatible.tuple.length",
-				path: [],
-				message: "tuple lengths are different"
-			}]
-		};
-		for (let index = 0; index < source.elements.length; index += 1) {
-			const result$1 = await compareTermsAsync(source.elements[index], target.elements[index], context);
-			if (result$1.status !== "assignable") return result$1;
-		}
-		return {
-			status: "assignable",
-			issues: []
-		};
-	}
-	if (source.kind === "tuple" && target.kind === "tuple") return checkSchemaRelationAsync(source, target, context.relation);
-	if (source.kind === "recordOf" && target.kind === "recordOf") {
-		if (!sameData(source.constraints, target.constraints) || !sameData(source.additionalFields, target.additionalFields)) return unknownMetadata();
-		const sourceFields = new Map(source.fields.map((field) => [field.key, field]));
-		for (const field of target.fields) {
-			const sourceField = sourceFields.get(field.key);
-			if (!sourceField && field.required === true) return {
-				status: "incompatible",
-				issues: [{
-					code: "relation.incompatible.required",
-					path: ["fields", field.key],
-					message: "source does not provide a required field"
-				}]
-			};
-			if (sourceField) {
-				if (field.required === true && sourceField.required !== true) return {
-					status: "incompatible",
-					issues: [{
-						code: "relation.incompatible.required",
-						path: ["fields", field.key],
-						message: "source field may be absent"
-					}]
-				};
-				const result$1 = await compareTermsAsync(sourceField.value, field.value, context);
-				if (result$1.status !== "assignable") return result$1;
-			}
-		}
-		for (const field of source.fields) if (!target.fields.some((candidate) => candidate.key === field.key)) {
-			if (target.additionalFields === void 0) return {
-				status: "incompatible",
-				issues: [{
-					code: "relation.incompatible.additionalField",
-					path: ["fields", field.key],
-					message: "target record does not allow this source field"
-				}]
-			};
-			if (target.additionalFields !== true) {
-				const relation = await compareTermsAsync(field.value, target.additionalFields, context);
-				if (relation.status !== "assignable") return relation;
-			}
-		}
-		return {
-			status: "assignable",
-			issues: []
-		};
-	}
-	const sourceSchema = validateSchemaNodeDefinition(source);
-	const targetSchema = validateSchemaNodeDefinition(target);
-	if (sourceSchema.ok && targetSchema.ok) return checkSchemaRelationAsync(sourceSchema.node, targetSchema.node, context.relation);
+function relationWithInterpreterRefs(relation, interpreter) {
+	if (interpreter?.refs === void 0) return relation ?? {};
 	return {
-		status: "unknown",
-		issues: [{
-			code: "relation.unknown.term",
-			path: [],
-			message: "async relation requires normalized term comparison"
-		}]
+		...relation ?? {},
+		refs: [...relation?.refs ?? [], ...interpreter.refs]
 	};
 }
 function diagnostics(result$1, status) {
@@ -1077,12 +976,8 @@ function compareEvaluated(source, target, relation = {}, hostTypeRelation) {
 	} : { relation });
 }
 function checkTypeTermRelation(source, target, context = {}) {
-	return compareEvaluated(evaluateExpression(source, context.interpreter), evaluateExpression(target, context.interpreter), context.relation, context.hostTypeRelation);
-}
-async function checkTypeTermRelationAsync(source, target, context = {}) {
-	const [sourceResult, targetResult] = await Promise.all([evaluateExpressionAsync(source, context.interpreter), evaluateExpressionAsync(target, context.interpreter)]);
-	if (sourceResult.status !== "evaluated" || targetResult.status !== "evaluated") return compareEvaluated(sourceResult, targetResult);
-	return compareTermsAsync(sourceResult.term, targetResult.term, context);
+	const relation = relationWithInterpreterRefs(context.relation, context.interpreter);
+	return compareEvaluated(evaluateExpression(source, context.interpreter), evaluateExpression(target, context.interpreter), relation, context.hostTypeRelation);
 }
 
 //#endregion
@@ -1152,9 +1047,13 @@ function replaceChild(expression, path, value) {
 		expression[key] = value;
 		return;
 	}
-	const items = expression[key];
+	const items = [...expression[key]];
+	expression[key] = items;
 	const index = Number(indexText);
-	if (subkey) items[index][subkey] = value;
+	if (subkey) items[index] = {
+		...items[index],
+		[subkey]: value
+	};
 	else items[index] = value;
 }
 function projectNormalized(expression) {
@@ -1263,33 +1162,32 @@ function operandKindIssue(expression) {
 function normalize(term, state, depth = 0) {
 	state.steps += 1;
 	if (state.steps > (state.context.maxSteps ?? 2e3) || depth > (state.context.maxDepth ?? 64)) return failure("incomplete", "budget", "type interpretation work budget exceeded");
+	const definition = validateSchemaTypeTermDefinition(term);
+	if (!definition.ok) {
+		const status = definition.issues.every((issue$1) => issue$1.code === "expression.cycle" || issue$1.code === "expression.budget") ? "incomplete" : "rejected";
+		return {
+			status,
+			issues: definition.issues.map((issue$1) => ({
+				...issue$1,
+				code: `interpreter.${status}.${issue$1.code}`
+			}))
+		};
+	}
 	if (!isObject(term)) return failure("rejected", "term.object", "type term must be an object");
 	if (schemaTerm(term)) {
 		if (term.kind !== "ref") return result(term);
-		if (!state.context.resolveRef) return failure("incomplete", "ref.resolver", "refPath requires an explicit resolver");
-		const key = term.refPath.join("\0");
-		if (state.refs.has(key)) return failure("incomplete", "cycle.ref", "refPath resolution cycle could not be determined");
-		state.refs.add(key);
-		let resolved;
-		try {
-			resolved = state.context.resolveRef(term.refPath);
-		} catch (error) {
-			state.refs.delete(key);
-			return failure("incomplete", "ref.error", `refPath resolver failed: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		if (!resolved) {
-			state.refs.delete(key);
-			return failure("incomplete", "ref.unresolved", "refPath resolver returned no schema");
-		}
-		if (typeof resolved === "object" && "status" in resolved && resolved.status !== "resolved") {
-			state.refs.delete(key);
-			return failure("incomplete", `ref.${resolved.status}`, resolved.message ?? "refPath resolver could not determine this path");
-		}
-		try {
-			return normalize(typeof resolved === "object" && "status" in resolved ? resolved.schema : resolved, state, depth + 1);
-		} finally {
-			state.refs.delete(key);
+		const key = schemaRefKey(term.refPath);
+		const materialized = state.refIndex.get(key);
+		if (materialized !== void 0) {
+			if (state.refs.has(key)) return failure("incomplete", "cycle.ref", "refPath resolution encountered a recursive reference");
+			state.refs.add(key);
+			try {
+				return normalize(materialized, state, depth + 1);
+			} finally {
+				state.refs.delete(key);
+			}
 		}
+		return failure("incomplete", state.context.refs === void 0 ? "ref.environment" : "ref.unresolved", state.context.refs === void 0 ? "refPath requires a preloaded refs environment" : "refPath is not present in the preloaded refs environment");
 	}
 	const kind = term.kind;
 	if (typeof kind !== "string" || !expressionKinds.has(kind)) return failure("rejected", "expression.kind", "term is neither a valid SchemaNode nor a supported expression");
@@ -1326,7 +1224,7 @@ function normalize(term, state, depth = 0) {
 		if (evaluated.status === "evaluated" && upper !== void 0) {
 			const upperResult = result(upper);
 			if (evaluated.unresolvedTypeVars?.length || upperResult.status === "evaluated" && upperResult.unresolvedTypeVars?.length) return failure("incomplete", "typeVar.bound", "type variable upper bound could not be established");
-			const relation = checkTypeTermRelation(evaluated.term, upper);
+			const relation = checkTypeTermRelation(evaluated.term, upper, { interpreter: state.context });
 			if (relation.status !== "assignable") return failure(relation.status === "incompatible" || relation.status === "rejected" ? "rejected" : "incomplete", "typeVar.bound", `binding for '${term.name}' does not satisfy its upper bound: ${relation.issues[0]?.message ?? relation.status}`);
 		}
 		return evaluated;
@@ -1392,97 +1290,14 @@ function normalize(term, state, depth = 0) {
 function evaluateExpression(term, context = {}) {
 	return normalize(term, {
 		context,
+		refIndex: indexSchemaRefs(context.refs),
 		active: /* @__PURE__ */ new Set(),
 		variables: /* @__PURE__ */ new Set(),
 		refs: /* @__PURE__ */ new Set(),
 		steps: 0
 	});
 }
-async function evaluateExpressionAsync(term, context = {}) {
-	const activeRefs = /* @__PURE__ */ new Set();
-	const activeVars = /* @__PURE__ */ new Set();
-	const activeObjects = /* @__PURE__ */ new Set();
-	let steps = 0;
-	const resolveTree = async (value, depth = 0) => {
-		steps += 1;
-		if (steps > (context.maxSteps ?? 2e3) || depth > (context.maxDepth ?? 64)) return { failure: failure("incomplete", "budget", "type interpretation work budget exceeded") };
-		if (!isObject(value)) return { value };
-		if (activeObjects.has(value)) return { failure: failure("incomplete", "cycle.expression", "expression cycle could not be determined") };
-		activeObjects.add(value);
-		try {
-			const definition = validateSchemaNodeDefinition(value);
-			if (definition.ok && definition.node.kind === "ref") {
-				if (!context.resolveRef) return { failure: failure("incomplete", "ref.resolver", "refPath requires an explicit resolver") };
-				const key = definition.node.refPath.join("\0");
-				if (activeRefs.has(key)) return { failure: failure("incomplete", "cycle.ref", "refPath resolution cycle could not be determined") };
-				activeRefs.add(key);
-				try {
-					let resolution;
-					try {
-						resolution = await context.resolveRef(definition.node.refPath);
-					} catch (error) {
-						return { failure: failure("incomplete", "ref.error", `refPath resolver failed: ${error instanceof Error ? error.message : String(error)}`) };
-					}
-					if (!resolution) return { failure: failure("incomplete", "ref.unresolved", "refPath resolver returned no schema") };
-					if (typeof resolution === "object" && "status" in resolution && resolution.status !== "resolved") return { failure: failure("incomplete", `ref.${resolution.status}`, resolution.message ?? "refPath resolver could not determine this path") };
-					return await resolveTree(typeof resolution === "object" && "status" in resolution ? resolution.schema : resolution, depth + 1);
-				} finally {
-					activeRefs.delete(key);
-				}
-			}
-			if (value.kind === "typeVar") {
-				if (typeof value.name !== "string" || !value.name.trim()) return { value };
-				const bound = context.typeVars?.[value.name];
-				if (bound === void 0) {
-					if (value.extends === void 0) return { value };
-					const upper = await resolveTree(value.extends, depth + 1);
-					return upper.failure ? upper : { value: {
-						...value,
-						extends: upper.value
-					} };
-				}
-				if (activeVars.has(value.name)) return { failure: failure("incomplete", "cycle.typeVar", "typeVar resolution cycle could not be determined") };
-				activeVars.add(value.name);
-				try {
-					const resolved$1 = await resolveTree(bound, depth + 1);
-					if (resolved$1.failure || value.extends === void 0) return resolved$1;
-					const upper = await resolveTree(value.extends, depth + 1);
-					if (upper.failure) return upper;
-					const source = evaluateExpression(resolved$1.value);
-					const target = evaluateExpression(upper.value);
-					if (source.status !== "evaluated" || target.status !== "evaluated" || source.unresolvedTypeVars?.length || target.unresolvedTypeVars?.length) return { failure: failure("incomplete", "typeVar.bound", "type variable upper bound could not be established") };
-					const relation = checkTypeTermRelation(source.term, target.term);
-					if (relation.status !== "assignable") return { failure: failure(relation.status === "incompatible" || relation.status === "rejected" ? "rejected" : "incomplete", "typeVar.bound", `binding for '${value.name}' does not satisfy its upper bound: ${relation.issues[0]?.message ?? relation.status}`) };
-					return resolved$1;
-				} finally {
-					activeVars.delete(value.name);
-				}
-			}
-			const kind = value.kind;
-			if (typeof kind !== "string" || !expressionKinds.has(kind)) return { value };
-			const shape = expressionFields[kind];
-			if (Object.keys(value).some((key) => !shape.allowed.includes(key)) || shape.required.some((key) => !(key in value))) return { value };
-			if (expressionShapeIssue(value)) return { value };
-			const copy = { ...value };
-			for (const [path, child] of childTerms(value)) {
-				const resolved$1 = await resolveTree(child, depth + 1);
-				if (resolved$1.failure) return resolved$1;
-				replaceChild(copy, path, resolved$1.value);
-			}
-			return { value: copy };
-		} finally {
-			activeObjects.delete(value);
-		}
-	};
-	const resolved = await resolveTree(term);
-	if (resolved.failure) return resolved.failure;
-	return evaluateExpression(resolved.value, {
-		maxDepth: Number.MAX_SAFE_INTEGER,
-		maxSteps: Number.MAX_SAFE_INTEGER
-	});
-}
 const evaluateSchemaTypeTerm = evaluateExpression;
-const evaluateSchemaTypeTermAsync = evaluateExpressionAsync;
 
 //#endregion
 //#region src/type-interpreter/type-variable-solver.ts
@@ -1541,6 +1356,11 @@ function initial(input, context) {
 		code: "solver.rejected.variable.prebound",
 		message: "a variable declared for solving is already bound in the interpreter context"
 	}]);
+	for (const [index, constraint] of input.constraints.entries()) if (!validateSchemaTypeTermDefinition(constraint.source).ok || !validateSchemaTypeTermDefinition(constraint.target).ok) return makeResult("rejected", {}, names, [{
+		code: "solver.rejected.input",
+		constraint: index,
+		message: "constraint terms must be well formed"
+	}]);
 }
 function interpreterContext(context, bindings) {
 	return {
@@ -1608,49 +1428,6 @@ function solveTypeVariables(input, context = {}) {
 	}
 	return makeResult("solved", bindings, input.variables, []);
 }
-async function solveTypeVariablesAsync(input, context = {}) {
-	const invalid = initial(input, context);
-	if (invalid) return invalid;
-	const bindings = Object.create(null);
-	const names = new Set(input.variables);
-	for (let pass = 0; pass <= input.variables.length; pass += 1) {
-		let changed = false;
-		for (const [index, constraint] of input.constraints.entries()) {
-			const actual = await evaluateExpressionAsync(constraint.source, interpreterContext(context.interpreter, bindings));
-			if (actual.status === "evaluated" && actual.unresolvedTypeVars?.length) continue;
-			if (actual.status !== "evaluated") return makeResult(actual.status === "incomplete" ? "unknown" : actual.status, bindings, input.variables, [issue(actual.status, index, actual.issues[0]?.message ?? "source could not be evaluated")]);
-			const found = [];
-			if (candidates(actual.term, constraint.target, found)) return makeResult("incompatible", bindings, input.variables, [issue("incompatible.shape", index, "source and target container shapes differ")]);
-			for (const candidate of found) {
-				if (context.interpreter?.typeVars?.[candidate.name] !== void 0 && !names.has(candidate.name)) continue;
-				if (!names.has(candidate.name)) return makeResult("rejected", bindings, input.variables, [issue("rejected.variable.undeclared", index, "target uses an undeclared type variable", candidate.name)]);
-				const previous = bindings[candidate.name];
-				if (!previous) {
-					bindings[candidate.name] = candidate.term;
-					changed = true;
-					continue;
-				}
-				if ((await checkTypeTermRelationAsync(candidate.term, previous, relationContext(context, bindings))).status === "assignable") continue;
-				if ((await checkTypeTermRelationAsync(previous, candidate.term, relationContext(context, bindings))).status === "assignable") {
-					bindings[candidate.name] = candidate.term;
-					changed = true;
-					continue;
-				}
-				return makeResult("unknown", bindings, input.variables, [issue("unknown.variable.join", index, "no supported unique common supertype for variable candidates", candidate.name)]);
-			}
-		}
-		if (!changed) break;
-	}
-	if (input.variables.some((name) => !Object.hasOwn(bindings, name))) return makeResult("unknown", bindings, input.variables, [{
-		code: "solver.unknown.variable.unresolved",
-		message: "one or more declared type variables could not be inferred"
-	}]);
-	for (const [index, constraint] of input.constraints.entries()) {
-		const relation = await checkTypeTermRelationAsync(constraint.source, constraint.target, relationContext(context, bindings));
-		if (relation.status !== "assignable") return makeResult(relation.status, bindings, input.variables, [issue(relation.status, index, relation.issues[0]?.message ?? "type relation could not be established")]);
-	}
-	return makeResult("solved", bindings, input.variables, []);
-}
 
 //#endregion
-export { evaluateSchemaTypeTerm as a, checkTypeTermRelationAsync as c, evaluateExpressionAsync as i, solveTypeVariablesAsync as n, evaluateSchemaTypeTermAsync as o, evaluateExpression as r, checkTypeTermRelation as s, solveTypeVariables as t };
+export { checkTypeTermRelation as i, evaluateExpression as n, evaluateSchemaTypeTerm as r, solveTypeVariables as t };