schemair 0.2.0 → 0.4.0

package/dist/{type-interpreter-OLt2W2yd.cjs → type-interpreter-D8xETgq1.cjs}

@@ -1,5 +1,6 @@
 const require_definition = require('./definition-BLLBpLKv.cjs');
-const require_relations = require('./relations-Cymx4iTc.cjs');
+const require_schema_ref_key = require('./schema-ref-key-BHVFVfj1.cjs');
+const require_relations = require('./relations-NUVJkAG8.cjs');
 
 //#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 require_relations.checkSchemaRelationAsync(source, target, context.relation);
-	if (source.kind === "record" && target.kind === "record") return require_relations.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 require_relations.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 = require_definition.validateSchemaNodeDefinition(source);
-	const targetSchema = require_definition.validateSchemaNodeDefinition(target);
-	if (sourceSchema.ok && targetSchema.ok) return require_relations.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 = require_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 = require_schema_ref_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" || !require_definition.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: require_schema_ref_key.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 = require_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" || !require_definition.expressionKinds.has(kind)) return { value };
-			const shape = require_definition.expressionFields[kind];
-			if (Object.keys(value).some((key) => !shape.allowed.includes(key)) || shape.required.some((key) => !(key in value))) return { value };
-			if (require_definition.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 (!require_definition.validateSchemaTypeTermDefinition(constraint.source).ok || !require_definition.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
 Object.defineProperty(exports, 'checkTypeTermRelation', {
@@ -1659,45 +1436,21 @@ Object.defineProperty(exports, 'checkTypeTermRelation', {
     return checkTypeTermRelation;
   }
 });
-Object.defineProperty(exports, 'checkTypeTermRelationAsync', {
-  enumerable: true,
-  get: function () {
-    return checkTypeTermRelationAsync;
-  }
-});
 Object.defineProperty(exports, 'evaluateExpression', {
   enumerable: true,
   get: function () {
     return evaluateExpression;
   }
 });
-Object.defineProperty(exports, 'evaluateExpressionAsync', {
-  enumerable: true,
-  get: function () {
-    return evaluateExpressionAsync;
-  }
-});
 Object.defineProperty(exports, 'evaluateSchemaTypeTerm', {
   enumerable: true,
   get: function () {
     return evaluateSchemaTypeTerm;
   }
 });
-Object.defineProperty(exports, 'evaluateSchemaTypeTermAsync', {
-  enumerable: true,
-  get: function () {
-    return evaluateSchemaTypeTermAsync;
-  }
-});
 Object.defineProperty(exports, 'solveTypeVariables', {
   enumerable: true,
   get: function () {
     return solveTypeVariables;
   }
-});
-Object.defineProperty(exports, 'solveTypeVariablesAsync', {
-  enumerable: true,
-  get: function () {
-    return solveTypeVariablesAsync;
-  }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schemair",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "TypeScript wire bindings and authoring tools for SchemaIR",
   "license": "Apache-2.0",
   "homepage": "https://github.com/schemair/schemair#readme",
@@ -70,6 +70,16 @@
         "default": "./dist/relations/index.cjs"
       }
     },
+    "./compatibility": {
+      "import": {
+        "types": "./dist/compatibility/index.d.ts",
+        "default": "./dist/compatibility/index.js"
+      },
+      "require": {
+        "types": "./dist/compatibility/index.d.cts",
+        "default": "./dist/compatibility/index.cjs"
+      }
+    },
     "./type-interpreter": {
       "import": {
         "types": "./dist/type-interpreter/index.d.ts",
@@ -80,6 +90,16 @@
         "default": "./dist/type-interpreter/index.cjs"
       }
     },
+    "./resolve": {
+      "import": {
+        "types": "./dist/resolve/index.d.ts",
+        "default": "./dist/resolve/index.js"
+      },
+      "require": {
+        "types": "./dist/resolve/index.d.cts",
+        "default": "./dist/resolve/index.cjs"
+      }
+    },
     "./authoring": {
       "import": {
         "types": "./dist/authoring/index.d.ts",
@@ -129,8 +149,8 @@
     "prepack": "pnpm build"
   },
   "devDependencies": {
-    "@types/node": "^22.10.0",
-    "tsdown": "^0.18.2",
+    "@types/node": "^26.6.4",
+    "tsdown": "^0.23.0",
     "tsx": "^4.20.0",
     "typescript": "^5.7.2"
   },

package/dist/index-BqfGAU1K.d.ts

@@ -1,56 +0,0 @@
-import { ct as SchemaNode } from "./index-4aMF0cTE.js";
-
-//#region src/payload/validator.d.ts
-type PayloadPath = readonly (string | number)[];
-interface PayloadValidationDiagnostic {
-  readonly code: string;
-  readonly path: PayloadPath;
-  readonly message: string;
-}
-type PayloadValidationResult = {
-  readonly status: 'accepted';
-  readonly issues: readonly [];
-} | {
-  readonly status: 'rejected' | 'unknown';
-  readonly issues: readonly PayloadValidationDiagnostic[];
-};
-type PayloadProviderDecision = boolean | {
-  readonly status: 'accepted' | 'rejected' | 'unknown' | 'unsupported';
-  readonly message?: string;
-};
-interface PayloadProviderContext {
-  readonly path: PayloadPath;
-  readonly schema: SchemaNode;
-  readonly rootSchema: SchemaNode;
-}
-interface PayloadResolutionContext extends PayloadProviderContext {
-  readonly refPath: readonly string[];
-}
-type PayloadResolution = SchemaNode | {
-  readonly status: 'resolved';
-  readonly schema: SchemaNode;
-} | {
-  readonly status: 'unknown' | 'unsupported';
-  readonly message?: string;
-} | undefined;
-type SemanticProvider = (semanticPath: readonly string[], value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | Promise<PayloadProviderDecision | undefined> | undefined;
-type ConstraintProvider = (constraintPath: readonly string[], args: unknown, value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | Promise<PayloadProviderDecision | undefined> | undefined;
-type SyncSemanticProvider = (semanticPath: readonly string[], value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | undefined;
-type SyncConstraintProvider = (constraintPath: readonly string[], args: unknown, value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | undefined;
-type SyncPayloadResolution = PayloadResolution;
-interface SyncPayloadValidationContext {
-  readonly resolveRef?: (refPath: readonly string[], context: PayloadResolutionContext) => SyncPayloadResolution;
-  readonly semanticProvider?: SyncSemanticProvider;
-  readonly constraintProvider?: SyncConstraintProvider;
-}
-interface PayloadValidationContext {
-  readonly resolveRef?: (refPath: readonly string[], context: PayloadResolutionContext) => PayloadResolution | Promise<PayloadResolution>;
-  readonly semanticProvider?: SemanticProvider;
-  readonly constraintProvider?: ConstraintProvider;
-}
-/** Context accepted by the asynchronous payload validation entry point. */
-type AsyncPayloadValidationContext = PayloadValidationContext;
-declare function validatePayload(value: unknown, schema: SchemaNode, context?: SyncPayloadValidationContext): PayloadValidationResult;
-declare function validatePayloadAsync(value: unknown, schema: SchemaNode, context?: AsyncPayloadValidationContext): Promise<PayloadValidationResult>;
-//#endregion
-export { validatePayloadAsync as _, PayloadProviderDecision as a, PayloadValidationContext as c, SemanticProvider as d, SyncConstraintProvider as f, validatePayload as g, SyncSemanticProvider as h, PayloadProviderContext as i, PayloadValidationDiagnostic as l, SyncPayloadValidationContext as m, ConstraintProvider as n, PayloadResolution as o, SyncPayloadResolution as p, PayloadPath as r, PayloadResolutionContext as s, AsyncPayloadValidationContext as t, PayloadValidationResult as u };

package/dist/index-D3mfwaSO.d.cts

@@ -1,56 +0,0 @@
-import { ct as SchemaNode } from "./index-DDMwVy2I.cjs";
-
-//#region src/payload/validator.d.ts
-type PayloadPath = readonly (string | number)[];
-interface PayloadValidationDiagnostic {
-  readonly code: string;
-  readonly path: PayloadPath;
-  readonly message: string;
-}
-type PayloadValidationResult = {
-  readonly status: 'accepted';
-  readonly issues: readonly [];
-} | {
-  readonly status: 'rejected' | 'unknown';
-  readonly issues: readonly PayloadValidationDiagnostic[];
-};
-type PayloadProviderDecision = boolean | {
-  readonly status: 'accepted' | 'rejected' | 'unknown' | 'unsupported';
-  readonly message?: string;
-};
-interface PayloadProviderContext {
-  readonly path: PayloadPath;
-  readonly schema: SchemaNode;
-  readonly rootSchema: SchemaNode;
-}
-interface PayloadResolutionContext extends PayloadProviderContext {
-  readonly refPath: readonly string[];
-}
-type PayloadResolution = SchemaNode | {
-  readonly status: 'resolved';
-  readonly schema: SchemaNode;
-} | {
-  readonly status: 'unknown' | 'unsupported';
-  readonly message?: string;
-} | undefined;
-type SemanticProvider = (semanticPath: readonly string[], value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | Promise<PayloadProviderDecision | undefined> | undefined;
-type ConstraintProvider = (constraintPath: readonly string[], args: unknown, value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | Promise<PayloadProviderDecision | undefined> | undefined;
-type SyncSemanticProvider = (semanticPath: readonly string[], value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | undefined;
-type SyncConstraintProvider = (constraintPath: readonly string[], args: unknown, value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | undefined;
-type SyncPayloadResolution = PayloadResolution;
-interface SyncPayloadValidationContext {
-  readonly resolveRef?: (refPath: readonly string[], context: PayloadResolutionContext) => SyncPayloadResolution;
-  readonly semanticProvider?: SyncSemanticProvider;
-  readonly constraintProvider?: SyncConstraintProvider;
-}
-interface PayloadValidationContext {
-  readonly resolveRef?: (refPath: readonly string[], context: PayloadResolutionContext) => PayloadResolution | Promise<PayloadResolution>;
-  readonly semanticProvider?: SemanticProvider;
-  readonly constraintProvider?: ConstraintProvider;
-}
-/** Context accepted by the asynchronous payload validation entry point. */
-type AsyncPayloadValidationContext = PayloadValidationContext;
-declare function validatePayload(value: unknown, schema: SchemaNode, context?: SyncPayloadValidationContext): PayloadValidationResult;
-declare function validatePayloadAsync(value: unknown, schema: SchemaNode, context?: AsyncPayloadValidationContext): Promise<PayloadValidationResult>;
-//#endregion
-export { validatePayloadAsync as _, PayloadProviderDecision as a, PayloadValidationContext as c, SemanticProvider as d, SyncConstraintProvider as f, validatePayload as g, SyncSemanticProvider as h, PayloadProviderContext as i, PayloadValidationDiagnostic as l, SyncPayloadValidationContext as m, ConstraintProvider as n, PayloadResolution as o, SyncPayloadResolution as p, PayloadPath as r, PayloadResolutionContext as s, AsyncPayloadValidationContext as t, PayloadValidationResult as u };