schemair 0.1.0 → 0.3.0

package/dist/integrations/json-schema/index.js

@@ -0,0 +1,324 @@
+import { i as STANDARD_CONSTRAINT_PATHS, o as STANDARD_SEMANTIC_PATHS } from "../../standard-BGMgbbEQ.js";
+import { pathKey } from "../../standard/index.js";
+
+//#region src/integrations/json-schema/index.ts
+function diagnostic(context, code, message, path, severity = "warning") {
+	context.diagnostics.push({
+		code,
+		message,
+		path,
+		severity
+	});
+}
+function mergeKeyword(target, source) {
+	if (source) Object.assign(target, source);
+}
+function extension(target, value) {
+	const existing = target["x-schemair"];
+	target["x-schemair"] = {
+		...existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {},
+		...value,
+		version: 1
+	};
+}
+function standardSemantic(path, node) {
+	const key = pathKey(path);
+	const stringFormats = {
+		[pathKey(STANDARD_SEMANTIC_PATHS.string.date)]: "date",
+		[pathKey(STANDARD_SEMANTIC_PATHS.string.datetime)]: "date-time",
+		[pathKey(STANDARD_SEMANTIC_PATHS.string.datetimeIso)]: "date-time",
+		[pathKey(STANDARD_SEMANTIC_PATHS.string.email)]: "email",
+		[pathKey(STANDARD_SEMANTIC_PATHS.string.url)]: "uri",
+		[pathKey(STANDARD_SEMANTIC_PATHS.string.ipV4)]: "ipv4",
+		[pathKey(STANDARD_SEMANTIC_PATHS.string.ipV6)]: "ipv6",
+		[pathKey(STANDARD_SEMANTIC_PATHS.string.uuid)]: "uuid",
+		[pathKey(STANDARD_SEMANTIC_PATHS.string.uuidV4)]: "uuid"
+	};
+	if (node.name === "string" && stringFormats[key]) return { format: stringFormats[key] };
+	if (node.name === "number" && key === pathKey(STANDARD_SEMANTIC_PATHS.number.integer)) return { type: "integer" };
+	if (node.name === "number" && key === pathKey(STANDARD_SEMANTIC_PATHS.number.safeInteger)) return {
+		type: "integer",
+		minimum: -9007199254740991,
+		maximum: 9007199254740991
+	};
+}
+function standardConstraint(constraint, target) {
+	const key = pathKey(constraint.constraintPath);
+	const value = constraint.args;
+	switch (key) {
+		case pathKey(STANDARD_CONSTRAINT_PATHS.string.minLength): return typeof value === "number" ? { minLength: value } : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.string.maxLength): return typeof value === "number" ? { maxLength: value } : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.string.pattern): return typeof value === "string" ? { pattern: value } : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.number.minimum): return typeof value === "number" ? { minimum: value } : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.number.maximum): return typeof value === "number" ? { maximum: value } : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.number.exclusiveMinimum): return typeof value === "number" ? target === "draft-2020-12" ? { exclusiveMinimum: value } : {
+			minimum: value,
+			exclusiveMinimum: true
+		} : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.number.exclusiveMaximum): return typeof value === "number" ? target === "draft-2020-12" ? { exclusiveMaximum: value } : {
+			maximum: value,
+			exclusiveMaximum: true
+		} : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.number.multipleOf): return typeof value === "number" ? { multipleOf: value } : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.array.minItems): return typeof value === "number" ? { minItems: value } : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.array.maxItems): return typeof value === "number" ? { maxItems: value } : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.array.uniqueItems): return typeof value === "boolean" ? { uniqueItems: value } : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.record.minProperties): return typeof value === "number" ? { minProperties: value } : void 0;
+		case pathKey(STANDARD_CONSTRAINT_PATHS.record.maxProperties): return typeof value === "number" ? { maxProperties: value } : void 0;
+		default: return;
+	}
+}
+function applyMetadata(target, node, context, path) {
+	if ("semanticPath" in node && node.semanticPath) {
+		const custom = context.options.semanticMapper?.(node.semanticPath, node);
+		const mapped = custom ?? standardSemantic(node.semanticPath, node);
+		if (mapped) {
+			mergeKeyword(target, mapped);
+			extension(target, { semanticPath: node.semanticPath });
+			if (custom === void 0) diagnostic(context, "semantic.lossy", `Semantic path ${node.semanticPath.join("/")} is approximated by JSON Schema keywords`, path);
+		} else {
+			extension(target, { semanticPath: node.semanticPath });
+			diagnostic(context, "semantic.unmapped", `Semantic path ${node.semanticPath.join("/")} has no lossless JSON Schema mapping`, path);
+		}
+	}
+	if ("constraints" in node && node.constraints) for (const constraint of node.constraints) {
+		const mapped = context.options.constraintMapper?.(constraint, node) ?? standardConstraint(constraint, context.target);
+		if (mapped) mergeKeyword(target, mapped);
+		else {
+			const prior = target["x-schemair"];
+			const meta = prior && typeof prior === "object" && !Array.isArray(prior) ? prior : {};
+			extension(target, { constraints: [...Array.isArray(meta.constraints) ? meta.constraints : [], {
+				constraintPath: [...constraint.constraintPath],
+				...constraint.args === void 0 ? {} : { args: constraint.args }
+			}] });
+			diagnostic(context, "constraint.unmapped", `Constraint ${constraint.constraintPath.join("/")} has no lossless JSON Schema mapping`, path);
+		}
+	}
+}
+function project(node, context, path) {
+	if (context.stack.includes(node)) {
+		diagnostic(context, "schema.cycle", "Cyclic schema graph requires an explicit ref strategy", path, "error");
+		const cycle = {};
+		extension(cycle, { selfRef: true });
+		return cycle;
+	}
+	context.stack.push(node);
+	let result;
+	switch (node.kind) {
+		case "primitive":
+			if (context.target === "openapi-3.0" && node.name === "null") {
+				result = {};
+				extension(result, { original: {
+					kind: "primitive",
+					name: "null"
+				} });
+				diagnostic(context, "openapi.null.unsupported", "OpenAPI 3.0 Schema Objects cannot represent a standalone null type", path, "error");
+			} else result = { type: node.name === "null" ? "null" : node.name };
+			applyMetadata(result, node, context, path);
+			break;
+		case "literal":
+			if (context.target === "openapi-3.0") {
+				result = { enum: [node.literal] };
+				extension(result, { literal: node.literal });
+				diagnostic(context, "openapi.literal.lossy", "OpenAPI 3.0 has no const keyword; the literal is projected as a single-value enum", path);
+			} else result = { const: node.literal };
+			break;
+		case "literalUnion":
+			result = { enum: [...node.values] };
+			extension(result, { union: {
+				kind: "literalUnion",
+				values: [...node.values]
+			} });
+			break;
+		case "nullable": {
+			const inner = project(node.value, context, [...path, "value"]);
+			if (context.target === "openapi-3.0") {
+				result = {
+					...inner,
+					nullable: true
+				};
+				extension(result, { union: {
+					kind: "nullable",
+					value: true
+				} });
+				diagnostic(context, "openapi.nullable.lossy", "OpenAPI 3.0 nullable is preserved as an extension because it is not equivalent to JSON Schema null union semantics", path);
+			} else result = { anyOf: [inner, { type: "null" }] };
+			break;
+		}
+		case "array":
+			result = {
+				type: "array",
+				items: project(node.elementSchema, context, [...path, "elementSchema"])
+			};
+			applyMetadata(result, node, context, path);
+			break;
+		case "tuple":
+			if (context.target === "draft-07") result = {
+				type: "array",
+				items: node.elementSchemas.map((item, index) => project(item, context, [
+					...path,
+					"elementSchemas",
+					index
+				])),
+				additionalItems: false,
+				minItems: node.elementSchemas.length,
+				maxItems: node.elementSchemas.length
+			};
+			else if (context.target === "openapi-3.0") {
+				const elements = node.elementSchemas.map((item, index) => project(item, context, [
+					...path,
+					"elementSchemas",
+					index
+				]));
+				result = {
+					type: "array",
+					items: {}
+				};
+				extension(result, { union: {
+					kind: "tuple",
+					length: node.elementSchemas.length,
+					elementSchemas: elements
+				} });
+				diagnostic(context, "openapi.tuple.lossy", "OpenAPI 3.0 has no tuple form; tuple position schemas are retained only in x-schemair", path);
+			} else result = {
+				type: "array",
+				prefixItems: node.elementSchemas.map((item, index) => project(item, context, [
+					...path,
+					"elementSchemas",
+					index
+				])),
+				items: false,
+				minItems: node.elementSchemas.length,
+				maxItems: node.elementSchemas.length
+			};
+			break;
+		case "record": {
+			const properties = {};
+			const required = [];
+			for (const field of node.fields) {
+				properties[field.key] = project(field.schema, context, [
+					...path,
+					"fields",
+					field.key
+				]);
+				if (field.required) required.push(field.key);
+			}
+			result = {
+				type: "object",
+				properties
+			};
+			if (required.length) result.required = required;
+			if (node.additionalFields === void 0) result.additionalProperties = false;
+			else if (node.additionalFields === true) result.additionalProperties = true;
+			else result.additionalProperties = project(node.additionalFields, context, [...path, "additionalFields"]);
+			applyMetadata(result, node, context, path);
+			break;
+		}
+		case "taggedUnion":
+			result = { oneOf: node.variants.map((variant, index) => project(variant.schema, context, [
+				...path,
+				"variants",
+				index
+			])) };
+			extension(result, { union: {
+				kind: "taggedUnion",
+				discriminator: node.discriminator,
+				variants: node.variants.map((variant) => ({
+					key: variant.key,
+					description: variant.description ?? null
+				}))
+			} });
+			diagnostic(context, "union.tagged.lossy", "SchemaIR tagged-union keys are not JSON Schema validation semantics", path);
+			break;
+		case "ref": {
+			const reference = context.options.refStrategy?.(node.refPath);
+			result = reference ? { $ref: reference } : {};
+			if (!reference) {
+				extension(result, { refPath: node.refPath });
+				diagnostic(context, "ref.unresolved", `No JSON Schema ref strategy resolved ${node.refPath.join("/")}`, path, "error");
+			}
+			break;
+		}
+		case "selfRef":
+			result = {};
+			extension(result, { selfRef: true });
+			diagnostic(context, "ref.self", "selfRef needs a caller-owned JSON Schema anchor strategy", path, "error");
+			break;
+	}
+	context.stack.pop();
+	return result;
+}
+function fidelity(diagnostics) {
+	if (diagnostics.some((item) => item.severity === "error")) return "unsupported";
+	if (diagnostics.length) return "lossy";
+	return "exact";
+}
+/** Project a SchemaNode into JSON Schema Draft 2020-12 without hiding loss. */
+function schemaNodeToJsonSchema(node, options = {}) {
+	const target = options.target ?? "draft-2020-12";
+	if (target === "openapi-3.0") return schemaNodeToOpenApiSchema(node, options);
+	const context = {
+		options,
+		target,
+		diagnostics: [],
+		stack: []
+	};
+	return {
+		schema: project(node, context, []),
+		fidelity: fidelity(context.diagnostics),
+		diagnostics: context.diagnostics
+	};
+}
+/** Project a SchemaNode to an OpenAPI 3.0 Schema Object. */
+function schemaNodeToOpenApiSchema(node, options = {}) {
+	const context = {
+		options,
+		target: "openapi-3.0",
+		diagnostics: [],
+		stack: []
+	};
+	return {
+		schema: project(node, context, []),
+		fidelity: fidelity(context.diagnostics),
+		diagnostics: context.diagnostics
+	};
+}
+/** Alias emphasizing that this is a diagnostic-bearing projection operation. */
+const schemaNodeToJsonSchemaWithDiagnostics = schemaNodeToJsonSchema;
+/**
+* Expose a runtime SchemaIR declaration through Standard JSON Schema V1.
+*
+* SchemaIR declarations do not perform input/output transformations, so both
+* converter methods project the same contract. Lossy projections are allowed
+* because their preserved metadata remains in `x-schemair`; unsupported
+* projections throw as required by the Standard JSON Schema protocol.
+*/
+function schemaIRToStandardJsonSchema(node, options = {}) {
+	const convert = (target) => {
+		const { target: _ignoredTarget, ...projectionOptions } = options;
+		const projectionTarget = target === "openapi-3.0" || target === "draft-2020-12" || target === "draft-07" ? target : void 0;
+		const result = projectionTarget === "openapi-3.0" ? schemaNodeToOpenApiSchema(node, projectionOptions) : projectionTarget ? schemaNodeToJsonSchema(node, {
+			...projectionOptions,
+			target: projectionTarget
+		}) : void 0;
+		if (!result) throw new Error(`SchemaIR Standard JSON Schema adapter does not support target ${target}`);
+		if (result.fidelity === "unsupported") {
+			const details = result.diagnostics.map((item) => item.message).join("; ");
+			throw new Error(`SchemaIR cannot be represented as JSON Schema: ${details}`);
+		}
+		return result.schema;
+	};
+	return { "~standard": {
+		version: 1,
+		vendor: "schemair",
+		jsonSchema: {
+			input: ({ target }) => convert(target),
+			output: ({ target }) => convert(target)
+		}
+	} };
+}
+/** Uppercase acronym alias matching the protocol name. */
+const schemaIRToStandardJSONSchema = schemaIRToStandardJsonSchema;
+
+//#endregion
+export { schemaIRToStandardJSONSchema, schemaIRToStandardJsonSchema, schemaNodeToJsonSchema, schemaNodeToJsonSchemaWithDiagnostics, schemaNodeToOpenApiSchema };

package/dist/integrations/standard-schema/index.cjs

@@ -0,0 +1,32 @@
+const require_payload_index = require('../../payload/index.cjs');
+
+//#region src/integrations/standard-schema/index.ts
+function toStandardIssue(issue) {
+	const path = issue.path.length > 0 ? [...issue.path] : void 0;
+	return path === void 0 ? { message: issue.message } : {
+		message: issue.message,
+		path
+	};
+}
+/**
+* Expose a serializable SchemaIR declaration through the Standard Schema
+* runtime protocol. Validation is synchronous; load external refs and policy
+* data before constructing the adapter.
+*
+* The adapter never transforms a payload and intentionally does not expose
+* `~standard.types` because the declaration is runtime data.
+*/
+function schemaIRToStandardSchema(schema, options = {}) {
+	return { "~standard": {
+		version: 1,
+		vendor: "schemair",
+		validate: (value) => {
+			const result = require_payload_index.validatePayload(value, schema, options);
+			if (result.status === "accepted") return { value };
+			return { issues: result.issues.map(toStandardIssue) };
+		}
+	} };
+}
+
+//#endregion
+exports.schemaIRToStandardSchema = schemaIRToStandardSchema;

package/dist/integrations/standard-schema/index.d.cts

@@ -0,0 +1,22 @@
+import { ct as SchemaNode } from "../../index-i7Au-FQ6.cjs";
+import { s as PayloadValidationContext } from "../../index-CzNxjqVg.cjs";
+import { StandardSchemaV1, StandardSchemaV1 as StandardSchemaV1$1 } from "@standard-schema/spec";
+
+//#region src/integrations/standard-schema/index.d.ts
+/** Options captured by a Standard Schema adapter at construction time. */
+type StandardSchemaAdapterOptions = PayloadValidationContext;
+/** Runtime-only Standard Schema surface for a dynamic SchemaIR declaration. */
+type SchemaIRStandardSchema = {
+  readonly '~standard': Omit<StandardSchemaV1$1.Props, 'types'>;
+};
+/**
+ * Expose a serializable SchemaIR declaration through the Standard Schema
+ * runtime protocol. Validation is synchronous; load external refs and policy
+ * data before constructing the adapter.
+ *
+ * The adapter never transforms a payload and intentionally does not expose
+ * `~standard.types` because the declaration is runtime data.
+ */
+declare function schemaIRToStandardSchema(schema: SchemaNode, options?: StandardSchemaAdapterOptions): SchemaIRStandardSchema;
+//#endregion
+export { SchemaIRStandardSchema, StandardSchemaAdapterOptions, type StandardSchemaV1, schemaIRToStandardSchema };

package/dist/integrations/standard-schema/index.d.ts

@@ -0,0 +1,22 @@
+import { ct as SchemaNode } from "../../index-1sDuqu05.js";
+import { s as PayloadValidationContext } from "../../index-hrcM9oJe.js";
+import { StandardSchemaV1, StandardSchemaV1 as StandardSchemaV1$1 } from "@standard-schema/spec";
+
+//#region src/integrations/standard-schema/index.d.ts
+/** Options captured by a Standard Schema adapter at construction time. */
+type StandardSchemaAdapterOptions = PayloadValidationContext;
+/** Runtime-only Standard Schema surface for a dynamic SchemaIR declaration. */
+type SchemaIRStandardSchema = {
+  readonly '~standard': Omit<StandardSchemaV1$1.Props, 'types'>;
+};
+/**
+ * Expose a serializable SchemaIR declaration through the Standard Schema
+ * runtime protocol. Validation is synchronous; load external refs and policy
+ * data before constructing the adapter.
+ *
+ * The adapter never transforms a payload and intentionally does not expose
+ * `~standard.types` because the declaration is runtime data.
+ */
+declare function schemaIRToStandardSchema(schema: SchemaNode, options?: StandardSchemaAdapterOptions): SchemaIRStandardSchema;
+//#endregion
+export { SchemaIRStandardSchema, StandardSchemaAdapterOptions, type StandardSchemaV1, schemaIRToStandardSchema };

package/dist/integrations/standard-schema/index.js

@@ -0,0 +1,32 @@
+import { validatePayload } from "../../payload/index.js";
+
+//#region src/integrations/standard-schema/index.ts
+function toStandardIssue(issue) {
+	const path = issue.path.length > 0 ? [...issue.path] : void 0;
+	return path === void 0 ? { message: issue.message } : {
+		message: issue.message,
+		path
+	};
+}
+/**
+* Expose a serializable SchemaIR declaration through the Standard Schema
+* runtime protocol. Validation is synchronous; load external refs and policy
+* data before constructing the adapter.
+*
+* The adapter never transforms a payload and intentionally does not expose
+* `~standard.types` because the declaration is runtime data.
+*/
+function schemaIRToStandardSchema(schema, options = {}) {
+	return { "~standard": {
+		version: 1,
+		vendor: "schemair",
+		validate: (value) => {
+			const result = validatePayload(value, schema, options);
+			if (result.status === "accepted") return { value };
+			return { issues: result.issues.map(toStandardIssue) };
+		}
+	} };
+}
+
+//#endregion
+export { schemaIRToStandardSchema };

package/dist/payload/index.cjs

@@ -1,4 +1,5 @@
-const require_definition = require('../definition-DSZZTz4e.cjs');
+const require_definition = require('../definition-BLLBpLKv.cjs');
+const require_schema_ref_key = require('../schema-ref-key-BHVFVfj1.cjs');
 
 //#region src/payload/validator.ts
 function hasOwn(value, key) {
@@ -38,22 +39,19 @@ function hasAccessorOrSymbol(value) {
 function isPromiseLike(value) {
 	return (typeof value === "object" && value !== null || typeof value === "function") && typeof value.then === "function";
 }
-function chain(previous, next) {
-	return isPromiseLike(previous) ? Promise.resolve(previous).then(() => next()) : next();
-}
 var PayloadValidator = class {
 	issues = [];
 	activePayload = /* @__PURE__ */ new WeakSet();
 	activeRefs = /* @__PURE__ */ new Set();
+	refIndex;
 	rootSchema;
-	constructor(context, rootSchema, allowAsync) {
+	constructor(context, rootSchema) {
 		this.context = context;
-		this.allowAsync = allowAsync;
 		this.rootSchema = rootSchema;
+		this.refIndex = require_schema_ref_key.indexSchemaRefs(context.refs);
 	}
 	run(value) {
-		const validation = this.validateNode(value, this.rootSchema, [], this.rootSchema);
-		if (isPromiseLike(validation)) return Promise.resolve(validation).then(() => this.result());
+		this.validateNode(value, this.rootSchema, [], this.rootSchema);
 		return this.result();
 	}
 	result() {
@@ -93,35 +91,29 @@ var PayloadValidator = class {
 	}
 	validateNode(value, schema, path, root) {
 		switch (schema.kind) {
-			case "primitive": {
+			case "primitive":
 				if (!this.matchesPrimitive(value, schema.name)) {
 					this.reject(path, "type", `expected ${schema.name}`);
 					return;
 				}
-				let pending = void 0;
-				if ((schema.name === "string" || schema.name === "number") && schema.semanticPath) pending = chain(pending, () => this.runSemantic(schema.semanticPath, value, schema, path, root));
-				if ((schema.name === "string" || schema.name === "number") && schema.constraints) pending = chain(pending, () => this.runConstraints(schema.constraints, value, schema, path, root));
-				return pending;
-			}
+				if ((schema.name === "string" || schema.name === "number") && schema.semanticPath) this.runSemantic(schema.semanticPath, value, schema, path, root);
+				if ((schema.name === "string" || schema.name === "number") && schema.constraints) this.runConstraints(schema.constraints, value, schema, path, root);
+				return;
 			case "literal":
 				if (!isLiteral(value) || !equalLiteral(value, schema.literal)) this.reject(path, "literal", "value does not match literal");
 				return;
 			case "record": return this.validateRecord(value, schema, path, root);
-			case "array": {
+			case "array":
 				if (!isDenseArray(value)) {
 					this.reject(path, "array", "expected a dense array");
 					return;
 				}
 				if (!this.enterPayload(value, path)) return;
-				let pending = void 0;
-				for (let index = 0; index < value.length; index += 1) pending = chain(pending, () => this.validateNode(value[index], schema.elementSchema, [...path, index], root));
-				pending = chain(pending, () => {
-					this.leavePayload(value);
-					return schema.constraints ? this.runConstraints(schema.constraints, value, schema, path, root) : void 0;
-				});
-				return pending;
-			}
-			case "tuple": {
+				for (let index = 0; index < value.length; index += 1) this.validateNode(value[index], schema.elementSchema, [...path, index], root);
+				this.leavePayload(value);
+				if (schema.constraints) this.runConstraints(schema.constraints, value, schema, path, root);
+				return;
+			case "tuple":
 				if (!isDenseArray(value)) {
 					this.reject(path, "tuple", "expected a dense array");
 					return;
@@ -131,15 +123,12 @@ var PayloadValidator = class {
 					return;
 				}
 				if (!this.enterPayload(value, path)) return;
-				let pending = void 0;
 				for (let index = 0; index < schema.elementSchemas.length; index += 1) {
 					const elementSchema = schema.elementSchemas[index];
-					if (elementSchema) pending = chain(pending, () => this.validateNode(value[index], elementSchema, [...path, index], root));
+					if (elementSchema) this.validateNode(value[index], elementSchema, [...path, index], root);
 				}
-				return chain(pending, () => {
-					this.leavePayload(value);
-				});
-			}
+				this.leavePayload(value);
+				return;
 			case "literalUnion":
 				if (!isLiteral(value) || !schema.values.some((candidate) => equalLiteral(candidate, value))) this.reject(path, "literal-union", "value is not one of the allowed literals");
 				return;
@@ -165,26 +154,23 @@ var PayloadValidator = class {
 		}
 		if (!this.enterPayload(value, path)) return;
 		const fields = new Map(schema.fields.map((field) => [field.key, field]));
-		let pending = void 0;
 		for (const field of schema.fields) {
 			if (!hasOwn(value, field.key)) {
 				if (field.required === true) this.reject([...path, field.key], "required", "required field is missing");
 				continue;
 			}
-			pending = chain(pending, () => this.validateNode(value[field.key], field.schema, [...path, field.key], root));
+			this.validateNode(value[field.key], field.schema, [...path, field.key], root);
 		}
 		for (const key of Object.keys(value)) {
 			if (fields.has(key)) continue;
 			if (!hasOwn(schema, "additionalFields")) this.reject([...path, key], "additional-field", "unknown field is not allowed");
 			else if (schema.additionalFields !== true) {
 				const additionalSchema = schema.additionalFields;
-				if (additionalSchema) pending = chain(pending, () => this.validateNode(value[key], additionalSchema, [...path, key], root));
+				if (additionalSchema) this.validateNode(value[key], additionalSchema, [...path, key], root);
 			} else if (!this.isJsonValue(value[key], /* @__PURE__ */ new WeakSet())) this.reject([...path, key], "additional-value", "additional field must be JSON-compatible");
 		}
-		return chain(pending, () => {
-			this.leavePayload(value);
-			return schema.constraints ? this.runConstraints(schema.constraints, value, schema, path, root) : void 0;
-		});
+		this.leavePayload(value);
+		if (schema.constraints) this.runConstraints(schema.constraints, value, schema, path, root);
 	}
 	validateTaggedUnion(value, schema, path, root) {
 		if (!isPlainRecord(value) || hasAccessorOrSymbol(value)) {
@@ -207,15 +193,18 @@ var PayloadValidator = class {
 		return this.validateNode(value, variant.schema, path, root);
 	}
 	validateRef(value, schema, path, root) {
-		if (!this.context.resolveRef) {
-			this.unsupported(path, "ref.resolver", "refPath requires an explicit resolver");
-			return;
-		}
-		const refKey = schema.refPath.join("\0");
+		const refKey = require_schema_ref_key.schemaRefKey(schema.refPath);
 		if (this.activeRefs.has(refKey)) {
 			this.unknown(path, "ref.cycle", "refPath resolution cycle could not be determined");
 			return;
 		}
+		const materialized = this.refIndex.get(refKey);
+		if (materialized !== void 0) return this.handleResolution(materialized, value, path, root);
+		if (!this.context.resolveRef) {
+			if (this.context.refs !== void 0) this.unknown(path, "ref.unresolved", "refPath is not present in the resolved environment");
+			else this.unsupported(path, "ref.resolver", "refPath requires an explicit resolver");
+			return;
+		}
 		this.activeRefs.add(refKey);
 		let resolved;
 		try {
@@ -231,19 +220,15 @@ var PayloadValidator = class {
 			return;
 		}
 		if (isPromiseLike(resolved)) {
-			if (!this.allowAsync) {
-				this.unsupported(path, "ref.async", "synchronous validation requires a synchronous ref resolver");
-				this.activeRefs.delete(refKey);
-				return;
-			}
-			return Promise.resolve(resolved).then((result) => this.handleResolution(result, value, path, root)).catch((error) => {
-				this.unknown(path, "ref.error", `refPath resolver failed: ${error instanceof Error ? error.message : String(error)}`);
-			}).finally(() => this.activeRefs.delete(refKey));
+			this.unsupported(path, "ref.async", "synchronous validation requires a synchronous ref resolver");
+			this.activeRefs.delete(refKey);
+			return;
+		}
+		try {
+			this.handleResolution(resolved, value, path, root);
+		} finally {
+			this.activeRefs.delete(refKey);
 		}
-		const handled = this.handleResolution(resolved, value, path, root);
-		if (isPromiseLike(handled)) return Promise.resolve(handled).finally(() => this.activeRefs.delete(refKey));
-		this.activeRefs.delete(refKey);
-		return handled;
 	}
 	handleResolution(resolved, value, path, root) {
 		if (resolved === void 0) {
@@ -279,19 +264,17 @@ var PayloadValidator = class {
 		}), path, "semantic");
 	}
 	runConstraints(constraints, value, schema, path, root) {
-		let pending = void 0;
 		for (const constraint of constraints) {
 			if (!this.context.constraintProvider) {
 				this.unsupported(path, "constraint.provider", `constraint path ${constraint.constraintPath.join("/")} has no provider`);
 				continue;
 			}
-			pending = chain(pending, () => this.applyProvider(() => this.context.constraintProvider(constraint.constraintPath, constraint.args, value, {
+			this.applyProvider(() => this.context.constraintProvider(constraint.constraintPath, constraint.args, value, {
 				path,
 				schema,
 				rootSchema: root
-			}), path, "constraint"));
+			}), path, "constraint");
 		}
-		return pending;
 	}
 	applyProvider(call, path, kind) {
 		let result;
@@ -302,13 +285,8 @@ var PayloadValidator = class {
 			return;
 		}
 		if (isPromiseLike(result)) {
-			if (!this.allowAsync) {
-				this.unsupported(path, `${kind}.async`, `synchronous validation requires a synchronous ${kind} provider`);
-				return;
-			}
-			return Promise.resolve(result).then((decision) => this.applyDecision(decision, path, kind)).catch((error) => {
-				this.unknown(path, `${kind}.error`, `${kind} provider failed: ${error instanceof Error ? error.message : String(error)}`);
-			});
+			this.unsupported(path, `${kind}.async`, `synchronous validation requires a synchronous ${kind} provider`);
+			return;
 		}
 		return this.applyDecision(result, path, kind);
 	}
@@ -368,23 +346,8 @@ function validateDefinition(schema) {
 function validatePayload(value, schema, context = {}) {
 	const validated = validateDefinition(schema);
 	if ("status" in validated) return validated;
-	const result = new PayloadValidator(context, validated, false).run(value);
-	if (isPromiseLike(result)) return {
-		status: "unknown",
-		issues: [{
-			code: "payload.unknown.async",
-			path: [],
-			message: "synchronous payload validation produced an asynchronous result"
-		}]
-	};
-	return result;
-}
-async function validatePayloadAsync(value, schema, context = {}) {
-	const validated = validateDefinition(schema);
-	if ("status" in validated) return validated;
-	return Promise.resolve(new PayloadValidator(context, validated, true).run(value));
+	return new PayloadValidator(context, validated).run(value);
 }
 
 //#endregion
-exports.validatePayload = validatePayload;
-exports.validatePayloadAsync = validatePayloadAsync;
+exports.validatePayload = validatePayload;