schemair 0.1.0 → 0.2.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-DhKsxu9U.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 always asynchronous so caller-owned refs
+* and semantic/constraint providers can use async implementations.
+*
+* 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: async (value) => {
+			const result = await require_payload_index.validatePayloadAsync(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-DDMwVy2I.cjs";
+import { t as AsyncPayloadValidationContext } from "../../index-D3mfwaSO.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 = AsyncPayloadValidationContext;
+/** 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 always asynchronous so caller-owned refs
+ * and semantic/constraint providers can use async implementations.
+ *
+ * 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-4aMF0cTE.js";
+import { t as AsyncPayloadValidationContext } from "../../index-BqfGAU1K.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 = AsyncPayloadValidationContext;
+/** 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 always asynchronous so caller-owned refs
+ * and semantic/constraint providers can use async implementations.
+ *
+ * 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 { validatePayloadAsync } 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 always asynchronous so caller-owned refs
+* and semantic/constraint providers can use async implementations.
+*
+* 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: async (value) => {
+			const result = await validatePayloadAsync(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,4 @@
-const require_definition = require('../definition-DSZZTz4e.cjs');
+const require_definition = require('../definition-BLLBpLKv.cjs');
 
 //#region src/payload/validator.ts
 function hasOwn(value, key) {

package/dist/payload/index.d.cts

@@ -1,56 +1,2 @@
-import { J as SchemaNode } from "../index-rzkFjgrt.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
+import { _ as validatePayloadAsync, a as PayloadProviderDecision, c as PayloadValidationContext, d as SemanticProvider, f as SyncConstraintProvider, g as validatePayload, h as SyncSemanticProvider, i as PayloadProviderContext, l as PayloadValidationDiagnostic, m as SyncPayloadValidationContext, n as ConstraintProvider, o as PayloadResolution, p as SyncPayloadResolution, r as PayloadPath, s as PayloadResolutionContext, t as AsyncPayloadValidationContext, u as PayloadValidationResult } from "../index-D3mfwaSO.cjs";
 export { AsyncPayloadValidationContext, ConstraintProvider, PayloadPath, PayloadProviderContext, PayloadProviderDecision, PayloadResolution, PayloadResolutionContext, PayloadValidationContext, PayloadValidationDiagnostic, PayloadValidationResult, SemanticProvider, SyncConstraintProvider, SyncPayloadResolution, SyncPayloadValidationContext, SyncSemanticProvider, validatePayload, validatePayloadAsync };

package/dist/payload/index.d.ts

@@ -1,56 +1,2 @@
-import { J as SchemaNode } from "../index-CEzHfht2.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
+import { _ as validatePayloadAsync, a as PayloadProviderDecision, c as PayloadValidationContext, d as SemanticProvider, f as SyncConstraintProvider, g as validatePayload, h as SyncSemanticProvider, i as PayloadProviderContext, l as PayloadValidationDiagnostic, m as SyncPayloadValidationContext, n as ConstraintProvider, o as PayloadResolution, p as SyncPayloadResolution, r as PayloadPath, s as PayloadResolutionContext, t as AsyncPayloadValidationContext, u as PayloadValidationResult } from "../index-BqfGAU1K.js";
 export { AsyncPayloadValidationContext, ConstraintProvider, PayloadPath, PayloadProviderContext, PayloadProviderDecision, PayloadResolution, PayloadResolutionContext, PayloadValidationContext, PayloadValidationDiagnostic, PayloadValidationResult, SemanticProvider, SyncConstraintProvider, SyncPayloadResolution, SyncPayloadValidationContext, SyncSemanticProvider, validatePayload, validatePayloadAsync };

package/dist/payload/index.js

@@ -1,4 +1,4 @@
-import { t as validateSchemaNodeDefinition } from "../definition-BXj3T94L.js";
+import { f as validateSchemaNodeDefinition } from "../definition-DmYnDmQO.js";
 
 //#region src/payload/validator.ts
 function hasOwn(value, key) {

package/dist/relations/index.cjs

@@ -1,5 +1,7 @@
-const require_relations = require('../relations-CMz_0nf4.cjs');
+const require_relations = require('../relations-Cymx4iTc.cjs');
 
+exports.checkOperationRelation = require_relations.checkOperationRelation;
+exports.checkOperationRelationAsync = require_relations.checkOperationRelationAsync;
 exports.checkSchemaAssignability = require_relations.checkSchemaAssignability;
 exports.checkSchemaAssignabilityAsync = require_relations.checkSchemaAssignabilityAsync;
 exports.checkSchemaRelation = require_relations.checkSchemaRelation;

package/dist/relations/index.d.cts

@@ -1,2 +1,2 @@
-import { a as RelationProviderContext, c as RelationResolutionContext, d as RelationStatus, f as checkSchemaAssignability, h as checkSchemaRelationAsync, i as RelationPath, l as RelationResult, m as checkSchemaRelation, n as RelationContext, o as RelationProviderDecision, p as checkSchemaAssignabilityAsync, r as RelationDiagnostic, s as RelationResolution, t as AsyncRelationContext, u as RelationSide } from "../index-TACcK_mi.cjs";
-export { AsyncRelationContext, RelationContext, RelationDiagnostic, RelationPath, RelationProviderContext, RelationProviderDecision, RelationResolution, RelationResolutionContext, RelationResult, RelationSide, RelationStatus, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync };
+import { _ as checkSchemaAssignabilityAsync, a as AsyncRelationContext, c as RelationPath, d as RelationResolution, f as RelationResolutionContext, g as checkSchemaAssignability, h as RelationStatus, i as checkOperationRelationAsync, l as RelationProviderContext, m as RelationSide, n as OperationRelationDirection, o as RelationContext, p as RelationResult, r as checkOperationRelation, s as RelationDiagnostic, t as OperationRelationComponent, u as RelationProviderDecision, v as checkSchemaRelation, y as checkSchemaRelationAsync } from "../index-CNjYUKvu.cjs";
+export { AsyncRelationContext, OperationRelationComponent, OperationRelationDirection, RelationContext, RelationDiagnostic, RelationPath, RelationProviderContext, RelationProviderDecision, RelationResolution, RelationResolutionContext, RelationResult, RelationSide, RelationStatus, checkOperationRelation, checkOperationRelationAsync, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync };

package/dist/relations/index.d.ts

@@ -1,2 +1,2 @@
-import { a as RelationProviderContext, c as RelationResolutionContext, d as RelationStatus, f as checkSchemaAssignability, h as checkSchemaRelationAsync, i as RelationPath, l as RelationResult, m as checkSchemaRelation, n as RelationContext, o as RelationProviderDecision, p as checkSchemaAssignabilityAsync, r as RelationDiagnostic, s as RelationResolution, t as AsyncRelationContext, u as RelationSide } from "../index-eK2Xgrwp.js";
-export { AsyncRelationContext, RelationContext, RelationDiagnostic, RelationPath, RelationProviderContext, RelationProviderDecision, RelationResolution, RelationResolutionContext, RelationResult, RelationSide, RelationStatus, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync };
+import { _ as checkSchemaAssignabilityAsync, a as AsyncRelationContext, c as RelationPath, d as RelationResolution, f as RelationResolutionContext, g as checkSchemaAssignability, h as RelationStatus, i as checkOperationRelationAsync, l as RelationProviderContext, m as RelationSide, n as OperationRelationDirection, o as RelationContext, p as RelationResult, r as checkOperationRelation, s as RelationDiagnostic, t as OperationRelationComponent, u as RelationProviderDecision, v as checkSchemaRelation, y as checkSchemaRelationAsync } from "../index-CBbd4hXJ.js";
+export { AsyncRelationContext, OperationRelationComponent, OperationRelationDirection, RelationContext, RelationDiagnostic, RelationPath, RelationProviderContext, RelationProviderDecision, RelationResolution, RelationResolutionContext, RelationResult, RelationSide, RelationStatus, checkOperationRelation, checkOperationRelationAsync, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync };

package/dist/relations/index.js

@@ -1,3 +1,3 @@
-import { i as checkSchemaRelationAsync, n as checkSchemaAssignabilityAsync, r as checkSchemaRelation, t as checkSchemaAssignability } from "../relations-By0bK3UK.js";
+import { a as checkSchemaRelation, i as checkSchemaAssignabilityAsync, n as checkOperationRelationAsync, o as checkSchemaRelationAsync, r as checkSchemaAssignability, t as checkOperationRelation } from "../relations-ysXDmi-Z.js";
 
-export { checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync };
+export { checkOperationRelation, checkOperationRelationAsync, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync };