schemair 0.2.0 → 0.4.0

package/dist/{relations-ysXDmi-Z.js → relations-QtnCRW9x.js}

@@ -1,4 +1,5 @@
-import { f as validateSchemaNodeDefinition, l as validateOperationDefinition } from "./definition-DmYnDmQO.js";
+import { f as validateSchemaNodeDefinition, l as validateOperationDefinition } from "./definition-BH_LzXGc.js";
+import { n as schemaRefKey, t as indexSchemaRefs } from "./schema-ref-key-DR__tPr-.js";
 
 //#region src/relations/validator.ts
 function equalLiteral(left, right) {
@@ -17,11 +18,13 @@ var RelationChecker = class {
 	activePairs = /* @__PURE__ */ new Set();
 	activeRefs = /* @__PURE__ */ new Set();
 	ids = /* @__PURE__ */ new WeakMap();
+	refIndex;
 	nextId = 1;
 	constructor(context, rootSourceSchema, rootTargetSchema) {
 		this.context = context;
 		this.rootSourceSchema = rootSourceSchema;
 		this.rootTargetSchema = rootTargetSchema;
+		this.refIndex = indexSchemaRefs(context.refs);
 	}
 	run() {
 		const result = this.compare(this.rootSourceSchema, this.rootTargetSchema, [], this.rootSourceSchema, this.rootTargetSchema);
@@ -251,8 +254,14 @@ var RelationChecker = class {
 		}
 	}
 	compareRef(ref, other, path, rootSource, rootTarget, side) {
-		if (!this.context.resolveRef) return this.unknown(path, "ref.resolver", "refPath relation requires an explicit resolver");
-		const key = `${side}:${ref.refPath.join("\0")}`;
+		const materialized = this.refIndex.get(schemaRefKey(ref.refPath));
+		if (materialized !== void 0) {
+			const definition$1 = validateSchemaNodeDefinition(materialized);
+			if (!definition$1.ok) return this.rejected(path, "ref.schema", "resolved ref environment contains an invalid schema");
+			return side === "source" ? this.compare(definition$1.node, other, path, rootSource, rootTarget) : this.compare(other, definition$1.node, path, rootSource, rootTarget);
+		}
+		if (!this.context.resolveRef) return this.context.refs === void 0 ? this.unknown(path, "ref.resolver", "refPath relation requires an explicit resolver") : this.unknown(path, "ref.unresolved", "refPath is not present in the resolved environment");
+		const key = `${side}:${schemaRefKey(ref.refPath)}`;
 		if (this.activeRefs.has(key)) return this.unknown(path, "ref.cycle", "refPath relation cycle could not be determined");
 		this.activeRefs.add(key);
 		let resolved;
@@ -364,210 +373,6 @@ function checkSchemaRelation(source, target, context = {}) {
 	return new RelationChecker(context, validSource, validTarget).run();
 }
 const checkSchemaAssignability = checkSchemaRelation;
-async function resolveAsyncSchema(schema, context, active, path, side, rootSourceSchema, rootTargetSchema) {
-	if (schema.kind === "ref" && context.resolveRef) {
-		const key = schema.refPath.join("\0");
-		if (active.has(key)) return schema;
-		active.add(key);
-		let resolved;
-		try {
-			resolved = await context.resolveRef(schema.refPath, {
-				path,
-				side,
-				sourceSchema: side === "source" ? schema : rootSourceSchema,
-				targetSchema: side === "source" ? rootTargetSchema : schema,
-				rootSourceSchema,
-				rootTargetSchema,
-				refPath: schema.refPath
-			});
-		} catch {
-			return schema;
-		} finally {
-			active.delete(key);
-		}
-		if (resolved && !(typeof resolved === "object" && "status" in resolved && resolved.status !== "resolved")) {
-			const definition = validateSchemaNodeDefinition(typeof resolved === "object" && "status" in resolved ? resolved.schema : resolved);
-			if (definition.ok) return resolveAsyncSchema(definition.node, context, new Set(active), path, side, rootSourceSchema, rootTargetSchema);
-		}
-		return schema;
-	}
-	switch (schema.kind) {
-		case "record": return {
-			...schema,
-			fields: await Promise.all(schema.fields.map(async (field) => ({
-				...field,
-				schema: await resolveAsyncSchema(field.schema, context, new Set(active), [
-					...path,
-					"fields",
-					field.key
-				], side, rootSourceSchema, rootTargetSchema)
-			}))),
-			...schema.additionalFields && schema.additionalFields !== true ? { additionalFields: await resolveAsyncSchema(schema.additionalFields, context, new Set(active), [...path, "additionalFields"], side, rootSourceSchema, rootTargetSchema) } : {}
-		};
-		case "array": return {
-			...schema,
-			elementSchema: await resolveAsyncSchema(schema.elementSchema, context, new Set(active), [...path, "elementSchema"], side, rootSourceSchema, rootTargetSchema)
-		};
-		case "tuple": return {
-			...schema,
-			elementSchemas: await Promise.all(schema.elementSchemas.map((item, index) => resolveAsyncSchema(item, context, new Set(active), [
-				...path,
-				"elementSchemas",
-				index
-			], side, rootSourceSchema, rootTargetSchema)))
-		};
-		case "nullable": return {
-			...schema,
-			value: await resolveAsyncSchema(schema.value, context, new Set(active), path, side, rootSourceSchema, rootTargetSchema)
-		};
-		case "taggedUnion": return {
-			...schema,
-			variants: await Promise.all(schema.variants.map(async (variant) => ({
-				...variant,
-				schema: await resolveAsyncSchema(variant.schema, context, new Set(active), [
-					...path,
-					"variants",
-					variant.key
-				], side, rootSourceSchema, rootTargetSchema)
-			})))
-		};
-		default: return schema;
-	}
-}
-function collectRelationPairs(source, target, path = [], result = [], seen = /* @__PURE__ */ new Set()) {
-	const key = `${JSON.stringify(path)}:${JSON.stringify(source)}:${JSON.stringify(target)}`;
-	if (seen.has(key)) return result;
-	seen.add(key);
-	result.push({
-		source,
-		target,
-		path
-	});
-	if (source.kind === "record" && target.kind === "record") {
-		const targetFields = new Map(target.fields.map((field) => [field.key, field]));
-		for (const field of source.fields) {
-			const targetField = targetFields.get(field.key);
-			if (targetField) collectRelationPairs(field.schema, targetField.schema, [
-				...path,
-				"fields",
-				field.key
-			], result, seen);
-		}
-	} else if (source.kind === "array" && target.kind === "array") collectRelationPairs(source.elementSchema, target.elementSchema, [...path, "elementSchema"], result, seen);
-	else if (source.kind === "tuple" && target.kind === "tuple") for (let index = 0; index < Math.min(source.elementSchemas.length, target.elementSchemas.length); index += 1) collectRelationPairs(source.elementSchemas[index], target.elementSchemas[index], [
-		...path,
-		"elementSchemas",
-		index
-	], result, seen);
-	else if (source.kind === "nullable" && target.kind === "nullable") collectRelationPairs(source.value, target.value, path, result, seen);
-	else if (source.kind === "taggedUnion" && target.kind === "taggedUnion" && source.discriminator === target.discriminator) {
-		const targetVariants = new Map(target.variants.map((variant) => [variant.key, variant]));
-		for (const variant of source.variants) {
-			const targetVariant = targetVariants.get(variant.key);
-			if (targetVariant) collectRelationPairs(variant.schema, targetVariant.schema, [
-				...path,
-				"variants",
-				variant.key
-			], result, seen);
-		}
-	}
-	return result;
-}
-async function checkSchemaRelationAsync(source, target, context = {}) {
-	try {
-		const validSource = validateSchema(source, "source");
-		if ("status" in validSource) return validSource;
-		const validTarget = validateSchema(target, "target");
-		if ("status" in validTarget) return validTarget;
-		const resolvedSource = await resolveAsyncSchema(validSource, context, /* @__PURE__ */ new Set(), [], "source", validSource, validTarget);
-		const resolvedTarget = await resolveAsyncSchema(validTarget, context, /* @__PURE__ */ new Set(), [], "target", validSource, validTarget);
-		const pairs = collectRelationPairs(resolvedSource, resolvedTarget);
-		const semanticCache = /* @__PURE__ */ new Map();
-		const constraintCache = /* @__PURE__ */ new Map();
-		if (context.semanticProvider) for (const pair of pairs) {
-			const { source: left, target: right } = pair;
-			const sourceSemantic = left.kind === "primitive" && (left.name === "string" || left.name === "number") ? left.semanticPath : void 0;
-			const targetSemantic = right.kind === "primitive" && (right.name === "string" || right.name === "number") ? right.semanticPath : void 0;
-			if (right.kind !== "primitive" || right.name !== "string" && right.name !== "number" || sourceSemantic === void 0 && targetSemantic === void 0) continue;
-			const providerContext = {
-				path: pair.path,
-				side: "source",
-				sourceSchema: left,
-				targetSchema: right,
-				rootSourceSchema: resolvedSource,
-				rootTargetSchema: resolvedTarget
-			};
-			let decision;
-			try {
-				decision = await context.semanticProvider(sourceSemantic, targetSemantic, providerContext);
-			} catch (error) {
-				decision = {
-					status: "unknown",
-					message: `semantic provider failed: ${error instanceof Error ? error.message : String(error)}`
-				};
-			}
-			semanticCache.set(JSON.stringify([
-				pair.path,
-				sourceSemantic,
-				targetSemantic
-			]), decision);
-		}
-		if (context.constraintProvider) for (const pair of pairs) {
-			const { source: left, target: right } = pair;
-			if (left.kind === "primitive" || left.kind === "array" || left.kind === "record" || left.kind === "literal" || left.kind === "literalUnion") {
-				const literalToPrimitive = (left.kind === "literal" || left.kind === "literalUnion") && right.kind === "primitive";
-				if (right.kind !== left.kind && !literalToPrimitive) continue;
-				const sourceConstraints = "constraints" in left ? left.constraints : void 0;
-				const targetConstraints = "constraints" in right ? right.constraints : void 0;
-				if (sourceConstraints === void 0 && targetConstraints === void 0) continue;
-				const providerContext = {
-					path: pair.path,
-					side: "source",
-					sourceSchema: left,
-					targetSchema: right,
-					rootSourceSchema: resolvedSource,
-					rootTargetSchema: resolvedTarget
-				};
-				let decision;
-				try {
-					decision = await context.constraintProvider(sourceConstraints, targetConstraints, providerContext);
-				} catch (error) {
-					decision = {
-						status: "unknown",
-						message: `constraint provider failed: ${error instanceof Error ? error.message : String(error)}`
-					};
-				}
-				constraintCache.set(JSON.stringify([
-					pair.path,
-					sourceConstraints,
-					targetConstraints
-				]), decision);
-			}
-		}
-		return checkSchemaRelation(resolvedSource, resolvedTarget, {
-			semanticProvider: (sourcePath, targetPath, providerContext) => semanticCache.get(JSON.stringify([
-				providerContext.path,
-				sourcePath,
-				targetPath
-			])) ?? { status: "unknown" },
-			constraintProvider: (sourceConstraints, targetConstraints, providerContext) => constraintCache.get(JSON.stringify([
-				providerContext.path,
-				sourceConstraints,
-				targetConstraints
-			])) ?? { status: "unknown" }
-		});
-	} catch (error) {
-		return {
-			status: "unknown",
-			issues: [{
-				code: "relation.unknown.async",
-				path: [],
-				message: `async relation provider failed: ${error instanceof Error ? error.message : String(error)}`
-			}]
-		};
-	}
-}
-const checkSchemaAssignabilityAsync = checkSchemaRelationAsync;
 
 //#endregion
 //#region src/relations/operation.ts
@@ -701,14 +506,6 @@ function checkOperationRelation(source, target, context = {}) {
 	if (!Array.isArray(work)) return work;
 	return combine(work.map((item) => "result" in item ? item.result : prefix(checkSchemaRelation(item.source, item.target, context), item.path)));
 }
-/** Async companion with the same substitution rules and schema-local providers. */
-async function checkOperationRelationAsync(source, target, context = {}) {
-	const work = prepare(source, target);
-	if (!Array.isArray(work)) return work;
-	const results = [];
-	for (const item of work) results.push("result" in item ? item.result : prefix(await checkSchemaRelationAsync(item.source, item.target, context), item.path));
-	return combine(results);
-}
 
 //#endregion
-export { checkSchemaRelation as a, checkSchemaAssignabilityAsync as i, checkOperationRelationAsync as n, checkSchemaRelationAsync as o, checkSchemaAssignability as r, checkOperationRelation as t };
+export { checkSchemaAssignability as n, checkSchemaRelation as r, checkOperationRelation as t };

package/dist/resolve/index.cjs

@@ -0,0 +1,308 @@
+const require_definition = require('../definition-BLLBpLKv.cjs');
+const require_schema_ref_key = require('../schema-ref-key-BHVFVfj1.cjs');
+
+//#region src/resolve/schema-closure.ts
+var AsyncResolverError = class extends Error {};
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function refNode(value) {
+	if (!isObject(value) || value.kind !== "ref" || !Array.isArray(value.refPath) || value.refPath.some((part) => typeof part !== "string")) return void 0;
+	return value;
+}
+function issue(status, code, path, message) {
+	return {
+		code: `closure.${status}.${code}`,
+		path,
+		message
+	};
+}
+function children(value, basePath) {
+	if (Array.isArray(value)) return value.map((child, index) => ({
+		value: child,
+		path: basePath.length === 0 && index === 0 ? [] : [index]
+	}));
+	if (!isObject(value)) return [];
+	if (value.kind === "record" && Array.isArray(value.fields)) {
+		const fields = value.fields.flatMap((field) => {
+			if (!isObject(field) || typeof field.key !== "string" || !("schema" in field)) return [];
+			return [{
+				value: field.schema,
+				path: ["fields", field.key]
+			}];
+		});
+		if (value.additionalFields !== void 0 && value.additionalFields !== true) fields.push({
+			value: value.additionalFields,
+			path: ["additionalFields"]
+		});
+		return fields;
+	}
+	if (value.kind === "recordOf" && Array.isArray(value.fields)) {
+		const fields = value.fields.flatMap((field) => {
+			if (!isObject(field) || typeof field.key !== "string" || !("value" in field)) return [];
+			return [{
+				value: field.value,
+				path: ["fields", field.key]
+			}];
+		});
+		if (value.additionalFields !== void 0 && value.additionalFields !== true) fields.push({
+			value: value.additionalFields,
+			path: ["additionalFields"]
+		});
+		return fields;
+	}
+	if ((value.kind === "taggedUnion" || value.kind === "taggedUnionOf") && Array.isArray(value.variants)) {
+		const member = value.kind === "taggedUnion" ? "schema" : "value";
+		return value.variants.flatMap((variant) => {
+			if (!isObject(variant) || typeof variant.key !== "string" || !(member in variant)) return [];
+			return [{
+				value: variant[member],
+				path: ["variants", variant.key]
+			}];
+		});
+	}
+	const members = {
+		array: ["elementSchema"],
+		tuple: ["elementSchemas"],
+		nullable: ["value"],
+		arrayOf: ["element"],
+		tupleOf: ["elements"],
+		nullableOf: ["value"],
+		maybeAbsent: ["value"],
+		typeVar: ["extends"],
+		mergeRecords: ["sources"],
+		intersect: ["sources"],
+		elementOf: ["source"],
+		valueOf: ["source"],
+		elementAt: ["source"],
+		fieldOf: ["source"],
+		keyOf: ["source"],
+		fieldsOf: ["source"],
+		pickFields: ["source"],
+		omitFields: ["source"],
+		partialFields: ["source"],
+		requiredFields: ["source"],
+		excludeVariants: ["source"],
+		extractVariants: ["source"],
+		structured: ["schema"]
+	};
+	if (typeof value.kind === "string") {
+		const edges$1 = (Object.hasOwn(members, value.kind) ? members[value.kind] : []).filter((key) => key in value).map((key) => ({
+			value: value[key],
+			path: [key]
+		}));
+		if (value.kind === "refine") {
+			edges$1.push({
+				value: value.source,
+				path: ["source"]
+			});
+			if (Array.isArray(value.fields)) value.fields.forEach((field, index) => {
+				if (isObject(field) && "intersectWith" in field) edges$1.push({
+					value: field.intersectWith,
+					path: [
+						"fields",
+						index,
+						"intersectWith"
+					]
+				});
+			});
+		}
+		return edges$1;
+	}
+	const edges = [];
+	for (const key of [
+		"input",
+		"output",
+		"data"
+	]) if (key in value) edges.push({
+		value: value[key],
+		path: [key]
+	});
+	for (const key of [
+		"errors",
+		"emits",
+		"operations",
+		"containers"
+	]) if (isObject(value[key])) for (const [name, child] of Object.entries(value[key])) edges.push({
+		value: child,
+		path: [key, name]
+	});
+	return edges;
+}
+/** Recursively load all external schema references reachable from an entry,
+* preserving reference paths and recording cycles rather than inlining refs.
+* Yielding host requests lets both execution modes use identical traversal state. */
+function* loadReferences(entry, context) {
+	const refs = /* @__PURE__ */ new Map();
+	for (const ref of context.refs ?? []) refs.set(require_schema_ref_key.schemaRefKey(ref.refPath), {
+		refPath: [...ref.refPath],
+		schema: ref.schema
+	});
+	const active = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const objects = /* @__PURE__ */ new Set();
+	const cycles = /* @__PURE__ */ new Map();
+	const issues = [];
+	let steps = 0;
+	let nodes = 0;
+	let rejected = false;
+	let incomplete = false;
+	function* walk(value, path, depth) {
+		steps += 1;
+		if (steps > (context.maxSteps ?? 1e4) || depth > (context.maxDepth ?? 64)) {
+			incomplete = true;
+			issues.push(issue("incomplete", "budget", path, "schema closure work budget exceeded"));
+			return;
+		}
+		if (isObject(value) && value.kind === "ref" && !require_definition.validateSchemaNodeDefinition(value).ok) {
+			rejected = true;
+			issues.push(issue("rejected", "schema", path, "reference must be a valid SchemaNode"));
+			return;
+		}
+		const ref = refNode(value);
+		if (ref) {
+			const key = require_schema_ref_key.schemaRefKey(ref.refPath);
+			if (active.has(key)) {
+				cycles.set(key, [...ref.refPath]);
+				return;
+			}
+			if (visited.has(key)) return;
+			active.add(key);
+			try {
+				const preloaded = refs.get(key);
+				if (preloaded !== void 0) {
+					if (!require_definition.validateSchemaNodeDefinition(preloaded.schema).ok) {
+						rejected = true;
+						issues.push(issue("rejected", "schema", path, "preloaded ref did not contain a valid SchemaNode"));
+						return;
+					}
+					visited.add(key);
+					yield* walk(preloaded.schema, path, depth + 1);
+					return;
+				}
+				if (nodes >= (context.maxNodes ?? 1e4)) {
+					incomplete = true;
+					issues.push(issue("incomplete", "nodes", path, "schema closure node budget exceeded"));
+					return;
+				}
+				let resolution;
+				if (!context.resolveRef) {
+					incomplete = true;
+					issues.push(issue("incomplete", "unresolved", path, "refPath is not present in the resolved environment"));
+					return;
+				}
+				try {
+					resolution = yield {
+						refPath: ref.refPath,
+						context: {
+							path,
+							refPath: ref.refPath,
+							ref,
+							depth
+						}
+					};
+				} catch (error) {
+					incomplete = true;
+					issues.push(issue("incomplete", error instanceof AsyncResolverError ? "resolver.async" : "resolver", path, `refPath resolver failed: ${error instanceof Error ? error.message : String(error)}`));
+					return;
+				}
+				if (!resolution) {
+					incomplete = true;
+					issues.push(issue("incomplete", "unresolved", path, "refPath resolver returned no schema"));
+					return;
+				}
+				if (typeof resolution === "object" && "status" in resolution && resolution.status !== "resolved") {
+					incomplete = true;
+					issues.push(issue("incomplete", `ref.${resolution.status}`, path, resolution.message ?? "refPath resolver could not determine this path"));
+					return;
+				}
+				const definition = require_definition.validateSchemaNodeDefinition(typeof resolution === "object" && "status" in resolution ? resolution.schema : resolution);
+				if (!definition.ok) {
+					rejected = true;
+					issues.push(issue("rejected", "schema", path, "resolved ref did not contain a valid SchemaNode"));
+					return;
+				}
+				refs.set(key, {
+					refPath: [...ref.refPath],
+					schema: definition.node
+				});
+				nodes += 1;
+				visited.add(key);
+				yield* walk(definition.node, path, depth + 1);
+			} finally {
+				active.delete(key);
+			}
+			return;
+		}
+		if (!isObject(value) && !Array.isArray(value)) return;
+		if (objects.has(value)) {
+			incomplete = true;
+			issues.push(issue("incomplete", "cycle.data", path, "input contains an object cycle"));
+			return;
+		}
+		objects.add(value);
+		try {
+			for (const child of children(value, path)) yield* walk(child.value, [...path, ...child.path], depth + 1);
+		} finally {
+			objects.delete(value);
+		}
+	}
+	yield* walk(entry, [], 0);
+	return {
+		status: rejected ? "rejected" : incomplete ? "incomplete" : "resolved",
+		graph: {
+			refs: [...refs.values()],
+			cycles: [...cycles.values()].sort((left, right) => require_schema_ref_key.schemaRefKey(left).localeCompare(require_schema_ref_key.schemaRefKey(right)))
+		},
+		issues
+	};
+}
+/** Load references using a synchronous host resolver. */
+function resolveSchemaReferences(entry, context = {}) {
+	const traversal = loadReferences(entry, context);
+	let step = traversal.next();
+	while (!step.done) {
+		let resolution;
+		try {
+			resolution = context.resolveRef(step.value.refPath, step.value.context);
+			if (resolution && typeof resolution === "object" && "then" in resolution && typeof resolution.then === "function") {
+				if (resolution instanceof Promise) resolution.catch(() => {});
+				throw new AsyncResolverError("reference loading requires a synchronous resolver; use resolveSchemaReferencesAsync");
+			}
+		} catch (error) {
+			step = traversal.throw(error);
+			continue;
+		}
+		step = traversal.next(resolution);
+	}
+	return step.value;
+}
+/** Load references using a synchronous or asynchronous host resolver. */
+async function resolveSchemaReferencesAsync(entry, context = {}) {
+	const traversal = loadReferences(entry, context);
+	let step = traversal.next();
+	while (!step.done) {
+		let resolution;
+		try {
+			resolution = await context.resolveRef(step.value.refPath, step.value.context);
+		} catch (error) {
+			step = traversal.throw(error);
+			continue;
+		}
+		step = traversal.next(resolution);
+	}
+	return step.value;
+}
+/** Resolve all external schema refs reachable from an operation declaration. */
+function resolveOperationClosure(entry, context = {}) {
+	return resolveSchemaReferences(entry, context);
+}
+async function resolveOperationClosureAsync(entry, context = {}) {
+	return resolveSchemaReferencesAsync(entry, context);
+}
+
+//#endregion
+exports.resolveOperationClosure = resolveOperationClosure;
+exports.resolveOperationClosureAsync = resolveOperationClosureAsync;
+exports.resolveSchemaReferences = resolveSchemaReferences;
+exports.resolveSchemaReferencesAsync = resolveSchemaReferencesAsync;

package/dist/resolve/index.d.cts

@@ -0,0 +1,2 @@
+import { a as SchemaClosureResolutionContext, c as SchemaRefResolution, d as resolveSchemaReferences, f as resolveSchemaReferencesAsync, i as SchemaClosureDiagnostic, l as resolveOperationClosure, n as ResolvedSchemaGraph, o as SchemaClosureResult, r as SchemaClosureContext, s as SchemaClosureStatus, t as AsyncSchemaClosureContext, u as resolveOperationClosureAsync } from "../index-CUGhtuwA.cjs";
+export { AsyncSchemaClosureContext, ResolvedSchemaGraph, SchemaClosureContext, SchemaClosureDiagnostic, SchemaClosureResolutionContext, SchemaClosureResult, SchemaClosureStatus, SchemaRefResolution, resolveOperationClosure, resolveOperationClosureAsync, resolveSchemaReferences, resolveSchemaReferencesAsync };

package/dist/resolve/index.d.ts

@@ -0,0 +1,2 @@
+import { a as SchemaClosureResolutionContext, c as SchemaRefResolution, d as resolveSchemaReferences, f as resolveSchemaReferencesAsync, i as SchemaClosureDiagnostic, l as resolveOperationClosure, n as ResolvedSchemaGraph, o as SchemaClosureResult, r as SchemaClosureContext, s as SchemaClosureStatus, t as AsyncSchemaClosureContext, u as resolveOperationClosureAsync } from "../index-BFSMT_2d.js";
+export { AsyncSchemaClosureContext, ResolvedSchemaGraph, SchemaClosureContext, SchemaClosureDiagnostic, SchemaClosureResolutionContext, SchemaClosureResult, SchemaClosureStatus, SchemaRefResolution, resolveOperationClosure, resolveOperationClosureAsync, resolveSchemaReferences, resolveSchemaReferencesAsync };