schemair 0.1.0 → 0.3.0

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 };

package/dist/resolve/index.js

@@ -0,0 +1,305 @@
+import { f as validateSchemaNodeDefinition } from "../definition-BH_LzXGc.js";
+import { n as schemaRefKey } from "../schema-ref-key-DR__tPr-.js";
+
+//#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(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" && !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 = 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 (!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 = 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) => schemaRefKey(left).localeCompare(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
+export { resolveOperationClosure, resolveOperationClosureAsync, resolveSchemaReferences, resolveSchemaReferencesAsync };

package/dist/schema-ref-key-BHVFVfj1.cjs

@@ -0,0 +1,26 @@
+
+//#region src/internal/schema-ref-key.ts
+/** Encode ref path segments without allowing a segment separator collision. */
+function schemaRefKey(path) {
+	return JSON.stringify(path);
+}
+/** Build the private lookup index used by synchronous host boundaries. */
+function indexSchemaRefs(entries) {
+	const index = /* @__PURE__ */ new Map();
+	for (const entry of entries ?? []) index.set(schemaRefKey(entry.refPath), entry.schema);
+	return index;
+}
+
+//#endregion
+Object.defineProperty(exports, 'indexSchemaRefs', {
+  enumerable: true,
+  get: function () {
+    return indexSchemaRefs;
+  }
+});
+Object.defineProperty(exports, 'schemaRefKey', {
+  enumerable: true,
+  get: function () {
+    return schemaRefKey;
+  }
+});

package/dist/schema-ref-key-DR__tPr-.js

@@ -0,0 +1,14 @@
+//#region src/internal/schema-ref-key.ts
+/** Encode ref path segments without allowing a segment separator collision. */
+function schemaRefKey(path) {
+	return JSON.stringify(path);
+}
+/** Build the private lookup index used by synchronous host boundaries. */
+function indexSchemaRefs(entries) {
+	const index = /* @__PURE__ */ new Map();
+	for (const entry of entries ?? []) index.set(schemaRefKey(entry.refPath), entry.schema);
+	return index;
+}
+
+//#endregion
+export { schemaRefKey as n, indexSchemaRefs as t };

package/dist/spec/index.cjs

@@ -0,0 +1,9 @@
+const require_standard = require('../standard-etPFZDJI.cjs');
+
+exports.STANDARD_CONSTRAINT_DEFINITIONS = require_standard.STANDARD_CONSTRAINT_DEFINITIONS;
+exports.STANDARD_CONSTRAINT_PATHS = require_standard.STANDARD_CONSTRAINT_PATHS;
+exports.STANDARD_CONSTRAINT_PATH_LIST = require_standard.STANDARD_CONSTRAINT_PATH_LIST;
+exports.STANDARD_SEMANTIC_DEFINITIONS = require_standard.STANDARD_SEMANTIC_DEFINITIONS;
+exports.STANDARD_SEMANTIC_PATHS = require_standard.STANDARD_SEMANTIC_PATHS;
+exports.STANDARD_SEMANTIC_PATH_LIST = require_standard.STANDARD_SEMANTIC_PATH_LIST;
+exports.STANDARD_SEMANTIC_RELATIONS = require_standard.STANDARD_SEMANTIC_RELATIONS;