schemair 0.1.0 → 0.2.0

package/dist/definition-BLLBpLKv.cjs

@@ -0,0 +1,1187 @@
+
+//#region src/definition/validator.ts
+const NODE_KINDS = new Set([
+	"primitive",
+	"literal",
+	"record",
+	"array",
+	"tuple",
+	"literalUnion",
+	"nullable",
+	"taggedUnion",
+	"ref",
+	"selfRef"
+]);
+const PRIMITIVE_NAMES = new Set([
+	"string",
+	"number",
+	"boolean",
+	"null"
+]);
+function isRecord$1(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function hasOwn(value, key) {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+function ownKeys(value) {
+	return Reflect.ownKeys(value);
+}
+function hasAccessor(value) {
+	return ownKeys(value).some((key) => {
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		return descriptor !== void 0 && ("get" in descriptor || "set" in descriptor);
+	});
+}
+function isDenseArray(value) {
+	if (!Array.isArray(value)) return false;
+	for (const key of Reflect.ownKeys(value)) {
+		if (typeof key === "symbol") return false;
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (descriptor !== void 0 && ("get" in descriptor || "set" in descriptor)) return false;
+		if (key !== "length" && !/^(0|[1-9]\d*)$/.test(key)) return false;
+	}
+	for (let index = 0; index < value.length; index += 1) if (!hasOwn(value, String(index))) return false;
+	return true;
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isLiteral(value) {
+	return typeof value === "string" || typeof value === "boolean" || isFiniteNumber(value);
+}
+function scalarDomain(value) {
+	if (typeof value === "string") return "string";
+	if (typeof value === "boolean") return "boolean";
+	return "number";
+}
+function equalLiteral(left, right) {
+	return typeof left === typeof right && Object.is(left, right) || left === right;
+}
+function describe(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+var DefinitionValidator = class {
+	issues = [];
+	active = /* @__PURE__ */ new WeakSet();
+	validateRoot(value) {
+		if (this.validateNode(value, [], true)) return {
+			ok: true,
+			node: value,
+			issues: []
+		};
+		return {
+			ok: false,
+			issues: this.issues
+		};
+	}
+	issue(code, path, message) {
+		this.issues.push({
+			code,
+			path,
+			message
+		});
+	}
+	checkObject(value, path, label) {
+		if (!isRecord$1(value)) {
+			this.issue("schema.object.invalid", path, `${label} must be a plain object`);
+			return false;
+		}
+		if (hasAccessor(value)) {
+			this.issue("schema.object.accessor", path, `${label} must not contain accessor properties`);
+			return false;
+		}
+		if (ownKeys(value).some((key) => typeof key === "symbol")) {
+			this.issue("schema.object.symbol-key", path, `${label} must not contain symbol keys`);
+			return false;
+		}
+		return true;
+	}
+	checkFields(value, allowed, required, path) {
+		let valid = true;
+		for (const key of Object.getOwnPropertyNames(value)) if (!allowed.includes(key)) {
+			this.issue("schema.field.unknown", [...path, key], `unknown field '${key}'`);
+			valid = false;
+		}
+		for (const key of required) if (!hasOwn(value, key)) {
+			this.issue("schema.field.missing", [...path, key], `missing required field '${key}'`);
+			valid = false;
+		}
+		return valid;
+	}
+	enter(value, path) {
+		if (this.active.has(value)) {
+			this.issue("schema.cycle", path, "actual object cycles are not valid schema data");
+			return false;
+		}
+		this.active.add(value);
+		return true;
+	}
+	leave(value) {
+		this.active.delete(value);
+	}
+	validateNode(value, path, root) {
+		if (!this.checkObject(value, path, "schema node")) return false;
+		if (!this.enter(value, path)) return false;
+		let valid = true;
+		const kind = value.kind;
+		if (typeof kind !== "string" || !NODE_KINDS.has(kind)) {
+			this.issue("schema.kind.invalid", [...path, "kind"], `unsupported schema kind '${String(kind)}'`);
+			valid = false;
+		} else switch (kind) {
+			case "primitive":
+				valid = this.validatePrimitive(value, path);
+				break;
+			case "literal":
+				valid = this.validateLiteral(value, path);
+				break;
+			case "record":
+				valid = this.validateRecord(value, path);
+				break;
+			case "array":
+				valid = this.validateArray(value, path);
+				break;
+			case "tuple":
+				valid = this.validateTuple(value, path);
+				break;
+			case "literalUnion":
+				valid = this.validateLiteralUnion(value, path);
+				break;
+			case "nullable":
+				valid = this.validateNullable(value, path);
+				break;
+			case "taggedUnion":
+				valid = this.validateTaggedUnion(value, path);
+				break;
+			case "ref":
+				valid = this.validateRef(value, path);
+				break;
+			case "selfRef":
+				valid = this.checkFields(value, ["kind"], [], path);
+				if (root) {
+					this.issue("schema.selfRef.root", path, "a root schema cannot consist only of selfRef");
+					valid = false;
+				}
+				break;
+			default: valid = false;
+		}
+		this.leave(value);
+		return valid;
+	}
+	validatePrimitive(value, path) {
+		let valid = this.checkFields(value, [
+			"kind",
+			"name",
+			"semanticPath",
+			"constraints"
+		], ["name"], path);
+		const name = value.name;
+		if (typeof name !== "string" || !PRIMITIVE_NAMES.has(name)) {
+			this.issue("schema.primitive.name", [...path, "name"], `primitive name must be one of string, number, boolean, or null`);
+			return false;
+		}
+		if (!(name === "string" || name === "number") && (hasOwn(value, "semanticPath") || hasOwn(value, "constraints"))) {
+			this.issue("schema.primitive.metadata", path, "semanticPath and constraints are only supported on string and number primitives");
+			valid = false;
+		}
+		if (hasOwn(value, "semanticPath")) valid = this.validatePath(value.semanticPath, [...path, "semanticPath"], "semanticPath") && valid;
+		if (hasOwn(value, "constraints")) valid = this.validateConstraints(value.constraints, [...path, "constraints"], "constraints") && valid;
+		return valid;
+	}
+	validateLiteral(value, path) {
+		let valid = this.checkFields(value, ["kind", "literal"], ["literal"], path);
+		if (!isLiteral(value.literal)) {
+			this.issue("schema.literal.value", [...path, "literal"], "literal must be a finite string, number, or boolean");
+			valid = false;
+		}
+		return valid;
+	}
+	validateRecord(value, path) {
+		let valid = this.checkFields(value, [
+			"kind",
+			"fields",
+			"additionalFields",
+			"constraints"
+		], ["fields"], path);
+		if (!isDenseArray(value.fields)) {
+			this.issue("schema.record.fields", [...path, "fields"], "fields must be a dense array");
+			return false;
+		}
+		const keys$1 = /* @__PURE__ */ new Set();
+		value.fields.forEach((field, index) => {
+			const fieldPath = [
+				...path,
+				"fields",
+				index
+			];
+			if (!this.checkObject(field, fieldPath, "record field")) {
+				valid = false;
+				return;
+			}
+			valid = this.checkFields(field, [
+				"key",
+				"schema",
+				"required",
+				"description"
+			], ["key", "schema"], fieldPath) && valid;
+			if (typeof field.key !== "string") {
+				this.issue("schema.record.field-key", [...fieldPath, "key"], "record field key must be a string");
+				valid = false;
+			} else if (keys$1.has(field.key)) {
+				this.issue("schema.record.field-key.duplicate", [...fieldPath, "key"], `duplicate record field key '${field.key}'`);
+				valid = false;
+			} else keys$1.add(field.key);
+			if (hasOwn(field, "required") && typeof field.required !== "boolean") {
+				this.issue("schema.record.required", [...fieldPath, "required"], "required must be a boolean");
+				valid = false;
+			}
+			if (hasOwn(field, "description") && typeof field.description !== "string") {
+				this.issue("schema.record.description", [...fieldPath, "description"], "description must be a string");
+				valid = false;
+			}
+			valid = this.validateNode(field.schema, [...fieldPath, "schema"], false) && valid;
+		});
+		if (hasOwn(value, "additionalFields")) {
+			if (value.additionalFields !== true) valid = this.validateNode(value.additionalFields, [...path, "additionalFields"], false) && valid;
+		}
+		if (hasOwn(value, "constraints")) valid = this.validateConstraints(value.constraints, [...path, "constraints"], "constraints") && valid;
+		return valid;
+	}
+	validateArray(value, path) {
+		let valid = this.checkFields(value, [
+			"kind",
+			"elementSchema",
+			"constraints"
+		], ["elementSchema"], path);
+		valid = this.validateNode(value.elementSchema, [...path, "elementSchema"], false) && valid;
+		if (hasOwn(value, "constraints")) valid = this.validateConstraints(value.constraints, [...path, "constraints"], "constraints") && valid;
+		return valid;
+	}
+	validateTuple(value, path) {
+		let valid = this.checkFields(value, ["kind", "elementSchemas"], ["elementSchemas"], path);
+		if (!isDenseArray(value.elementSchemas)) {
+			this.issue("schema.tuple.elements", [...path, "elementSchemas"], "elementSchemas must be a dense array");
+			return false;
+		}
+		value.elementSchemas.forEach((child, index) => {
+			valid = this.validateNode(child, [
+				...path,
+				"elementSchemas",
+				index
+			], false) && valid;
+		});
+		return valid;
+	}
+	validateLiteralUnion(value, path) {
+		let valid = this.checkFields(value, ["kind", "values"], ["values"], path);
+		if (!isDenseArray(value.values)) {
+			this.issue("schema.literalUnion.values", [...path, "values"], "values must be a dense array");
+			return false;
+		}
+		if (value.values.length < 2) {
+			this.issue("schema.literalUnion.cardinality", [...path, "values"], "literalUnion requires at least two values");
+			valid = false;
+		}
+		let domain;
+		const literals = [];
+		value.values.forEach((candidate, index) => {
+			const candidatePath = [
+				...path,
+				"values",
+				index
+			];
+			if (!isLiteral(candidate)) {
+				this.issue("schema.literalUnion.value", candidatePath, "literalUnion values must be finite strings, numbers, or booleans");
+				valid = false;
+				return;
+			}
+			const candidateDomain = scalarDomain(candidate);
+			if (domain === void 0) domain = candidateDomain;
+			else if (domain !== candidateDomain) {
+				this.issue("schema.literalUnion.domain", candidatePath, "literalUnion values must share one scalar domain");
+				valid = false;
+			}
+			if (literals.some((existing) => equalLiteral(existing, candidate))) {
+				this.issue("schema.literalUnion.duplicate", candidatePath, "literalUnion values must be unique");
+				valid = false;
+			}
+			literals.push(candidate);
+		});
+		return valid;
+	}
+	validateNullable(value, path) {
+		let valid = this.checkFields(value, ["kind", "value"], ["value"], path);
+		valid = this.validateNode(value.value, [...path, "value"], false) && valid;
+		if (isRecord$1(value.value) && (value.value.kind === "nullable" || value.value.kind === "primitive" && value.value.name === "null")) {
+			this.issue("schema.nullable.redundant", [...path, "value"], "nullable cannot wrap null or another nullable node");
+			valid = false;
+		}
+		return valid;
+	}
+	validateTaggedUnion(value, path) {
+		let valid = this.checkFields(value, [
+			"kind",
+			"discriminator",
+			"variants"
+		], ["discriminator", "variants"], path);
+		if (typeof value.discriminator !== "string") {
+			this.issue("schema.taggedUnion.discriminator", [...path, "discriminator"], "discriminator must be a string");
+			valid = false;
+		}
+		if (!isDenseArray(value.variants)) {
+			this.issue("schema.taggedUnion.variants", [...path, "variants"], "variants must be a dense array");
+			return false;
+		}
+		if (value.variants.length < 2) {
+			this.issue("schema.taggedUnion.cardinality", [...path, "variants"], "taggedUnion requires at least two variants");
+			valid = false;
+		}
+		const variantKeys = /* @__PURE__ */ new Set();
+		const tags = /* @__PURE__ */ new Set();
+		value.variants.forEach((variant, index) => {
+			const variantPath = [
+				...path,
+				"variants",
+				index
+			];
+			if (!this.checkObject(variant, variantPath, "tagged-union variant")) {
+				valid = false;
+				return;
+			}
+			valid = this.checkFields(variant, [
+				"key",
+				"schema",
+				"description"
+			], ["key", "schema"], variantPath) && valid;
+			if (typeof variant.key !== "string" || variant.key.trim() === "") {
+				this.issue("schema.taggedUnion.variant-key", [...variantPath, "key"], "variant key must be a non-blank string");
+				valid = false;
+			} else if (variantKeys.has(variant.key)) {
+				this.issue("schema.taggedUnion.variant-key.duplicate", [...variantPath, "key"], `duplicate variant key '${variant.key}'`);
+				valid = false;
+			} else variantKeys.add(variant.key);
+			if (hasOwn(variant, "description") && typeof variant.description !== "string") {
+				this.issue("schema.taggedUnion.description", [...variantPath, "description"], "description must be a string");
+				valid = false;
+			}
+			valid = this.validateNode(variant.schema, [...variantPath, "schema"], false) && valid;
+			if (!isRecord$1(variant.schema) || variant.schema.kind !== "record") {
+				this.issue("schema.taggedUnion.variant-schema", [...variantPath, "schema"], "tagged-union variants must be direct record schemas");
+				valid = false;
+				return;
+			}
+			const field = (isDenseArray(variant.schema.fields) ? variant.schema.fields : []).find((candidate) => isRecord$1(candidate) && candidate.key === value.discriminator);
+			if (!field || field.required !== true || !isRecord$1(field.schema) || field.schema.kind !== "literal" || typeof field.schema.literal !== "string") {
+				this.issue("schema.taggedUnion.discriminator-field", [
+					...variantPath,
+					"schema",
+					"fields"
+				], "each variant must have a required string-literal discriminator field");
+				valid = false;
+			} else if (tags.has(field.schema.literal)) {
+				this.issue("schema.taggedUnion.discriminator-duplicate", [
+					...variantPath,
+					"schema",
+					"fields"
+				], "discriminator literal tags must be unique");
+				valid = false;
+			} else tags.add(field.schema.literal);
+		});
+		return valid;
+	}
+	validateRef(value, path) {
+		let valid = this.checkFields(value, ["kind", "refPath"], ["refPath"], path);
+		valid = this.validatePath(value.refPath, [...path, "refPath"], "refPath") && valid;
+		return valid;
+	}
+	validatePath(value, path, label) {
+		if (!isDenseArray(value) || value.length === 0 || value.some((segment) => typeof segment !== "string" || segment.trim() === "")) {
+			this.issue("schema.path.invalid", path, `${label} must be a non-empty dense array of non-blank strings`);
+			return false;
+		}
+		return true;
+	}
+	validateConstraints(value, path, label) {
+		if (!isDenseArray(value)) {
+			this.issue("schema.constraints.invalid", path, `${label} must be a dense array`);
+			return false;
+		}
+		let valid = true;
+		value.forEach((constraint, index) => {
+			const constraintPath = [...path, index];
+			if (!this.checkObject(constraint, constraintPath, "constraint")) {
+				valid = false;
+				return;
+			}
+			valid = this.checkFields(constraint, ["constraintPath", "args"], ["constraintPath"], constraintPath) && valid;
+			valid = this.validatePath(constraint.constraintPath, [...constraintPath, "constraintPath"], "constraintPath") && valid;
+			if (hasOwn(constraint, "args")) valid = this.validateJsonValue(constraint.args, [...constraintPath, "args"], /* @__PURE__ */ new WeakSet()) && valid;
+		});
+		return valid;
+	}
+	validateJsonValue(value, path, active) {
+		if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+		if (typeof value === "number") {
+			if (Number.isFinite(value)) return true;
+			this.issue("schema.json-value.number", path, "JSON numbers must be finite");
+			return false;
+		}
+		if (typeof value !== "object") {
+			this.issue("schema.json-value.type", path, `value of type ${describe(value)} is not JSON-compatible`);
+			return false;
+		}
+		if (active.has(value)) {
+			this.issue("schema.json-value.cycle", path, "actual object cycles are not JSON-compatible");
+			return false;
+		}
+		if (Array.isArray(value)) {
+			if (!isDenseArray(value)) {
+				this.issue("schema.json-value.array", path, "JSON arrays must be dense and have no symbol keys");
+				return false;
+			}
+			active.add(value);
+			let valid$1 = true;
+			value.forEach((child, index) => {
+				valid$1 = this.validateJsonValue(child, [...path, index], active) && valid$1;
+			});
+			active.delete(value);
+			return valid$1;
+		}
+		if (!this.checkObject(value, path, "JSON object")) return false;
+		active.add(value);
+		let valid = true;
+		for (const key of Object.keys(value)) valid = this.validateJsonValue(value[key], [...path, key], active) && valid;
+		active.delete(value);
+		return valid;
+	}
+};
+/** Validate only the serializable structural definition of one SchemaNode. */
+function validateSchemaNodeDefinition(value) {
+	return new DefinitionValidator().validateRoot(value);
+}
+
+//#endregion
+//#region src/definition/operation-validator.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const own$1 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const keys = (value) => Object.getOwnPropertyNames(value);
+const MAX_OPERATION_DEFINITION_STEPS = 1e4;
+const MAX_OPERATION_DEFINITION_DEPTH = 64;
+var Validator$1 = class {
+	issues = [];
+	active = /* @__PURE__ */ new WeakSet();
+	steps = 0;
+	budgetExceeded = false;
+	issue(code, path, message) {
+		this.issues.push({
+			code,
+			path,
+			message
+		});
+	}
+	object(value, path, label) {
+		if (++this.steps > MAX_OPERATION_DEFINITION_STEPS) {
+			if (!this.budgetExceeded) {
+				this.issue("operation.budget", path, "operation definition validation budget exceeded");
+				this.budgetExceeded = true;
+			}
+			return false;
+		}
+		if (!isRecord(value)) {
+			this.issue("operation.object.invalid", path, `${label} must be a plain object`);
+			return false;
+		}
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== null && prototype !== Object.prototype || Reflect.ownKeys(value).some((key) => typeof key === "symbol" || !("value" in Object.getOwnPropertyDescriptor(value, key)) || !Object.getOwnPropertyDescriptor(value, key).enumerable)) {
+			this.issue("operation.object.invalid", path, `${label} must contain only enumerable own data properties on a plain object`);
+			return false;
+		}
+		return true;
+	}
+	fields(value, allowed, path) {
+		let valid = true;
+		for (const key of keys(value)) if (!allowed.includes(key)) {
+			this.issue("operation.field.unknown", [...path, key], `unknown field '${key}'`);
+			valid = false;
+		}
+		return valid;
+	}
+	enter(value, path) {
+		if (this.active.has(value)) {
+			this.issue("operation.cycle", path, "operation declarations must be acyclic");
+			return false;
+		}
+		this.active.add(value);
+		return true;
+	}
+	leave(value) {
+		this.active.delete(value);
+	}
+	description(value, path) {
+		if (!own$1(value, "description")) return true;
+		if (typeof value.description !== "string" || value.description.length === 0) {
+			this.issue("operation.description.invalid", [...path, "description"], "description must be a non-empty string");
+			return false;
+		}
+		return true;
+	}
+	nameMap(value, path, label, child) {
+		if (!this.object(value, path, label)) return false;
+		let valid = true;
+		for (const [name, item] of keys(value).map((name$1) => [name$1, value[name$1]])) {
+			if (name.length === 0) {
+				this.issue("operation.name.invalid", [...path, name], `${label} names must be non-empty`);
+				valid = false;
+			}
+			valid = child(item, [...path, name]) && valid;
+		}
+		return valid;
+	}
+	schema(value, path) {
+		const result = validateSchemaNodeDefinition(value);
+		if (result.ok) return true;
+		for (const issue of result.issues) this.issues.push({
+			...issue,
+			path: [...path, ...issue.path]
+		});
+		return false;
+	}
+	payload(value, path, structured) {
+		if (!this.object(value, path, "payload")) return false;
+		let valid = this.fields(value, value.kind === "structured" ? ["kind", "schema"] : ["kind", "meta"], path);
+		if (value.kind === "structured") {
+			if (!own$1(value, "schema")) {
+				this.issue("operation.payload.schema.missing", [...path, "schema"], "structured payload requires schema");
+				return false;
+			}
+			valid = this.schema(value.schema, [...path, "schema"]) && valid;
+		} else if (value.kind === "binary" && !structured) {
+			if (own$1(value, "meta")) if (!this.object(value.meta, [...path, "meta"], "binary metadata")) valid = false;
+			else {
+				valid = this.fields(value.meta, ["kind", "value"], [...path, "meta"]) && valid;
+				if (value.meta.kind !== "mime" || typeof value.meta.value !== "string" || value.meta.value.length === 0) {
+					this.issue("operation.payload.meta.invalid", [...path, "meta"], "binary metadata must be a non-empty mime descriptor");
+					valid = false;
+				}
+			}
+		} else {
+			this.issue("operation.payload.kind.invalid", [...path, "kind"], structured ? "structured payload kind must be structured" : "payload kind must be structured or binary");
+			valid = false;
+		}
+		return valid;
+	}
+	error(value, path) {
+		if (!this.object(value, path, "error")) return false;
+		let valid = this.fields(value, ["description", "data"], path) && this.description(value, path);
+		if (own$1(value, "data")) valid = this.schema(value.data, [...path, "data"]) && valid;
+		return valid;
+	}
+	errors(value, path) {
+		return this.nameMap(value, path, "error", (item, childPath) => this.error(item, childPath));
+	}
+	channel(value, path, structured) {
+		if (!this.object(value, path, "channel")) return false;
+		let valid = this.fields(value, [
+			"description",
+			"data",
+			"errors"
+		], path) && this.description(value, path);
+		if (own$1(value, "data")) valid = this.payload(value.data, [...path, "data"], structured) && valid;
+		if (own$1(value, "errors")) valid = this.errors(value.errors, [...path, "errors"]) && valid;
+		return valid;
+	}
+	operation(value, path, structured = false) {
+		if (!this.object(value, path, "operation") || !this.enter(value, path)) return false;
+		let valid = this.fields(value, [
+			"description",
+			"input",
+			"output",
+			"errors",
+			"emits"
+		], path) && this.description(value, path);
+		if (own$1(value, "input")) valid = this.payload(value.input, [...path, "input"], structured) && valid;
+		if (own$1(value, "output")) valid = this.payload(value.output, [...path, "output"], structured) && valid;
+		if (own$1(value, "errors")) valid = this.errors(value.errors, [...path, "errors"]) && valid;
+		if (own$1(value, "emits")) valid = this.nameMap(value.emits, [...path, "emits"], "channel", (item, childPath) => this.channel(item, childPath, structured)) && valid;
+		this.leave(value);
+		return valid;
+	}
+	container(value, path, structured = false) {
+		if (path.length > MAX_OPERATION_DEFINITION_DEPTH) {
+			this.issue("operation.depth", path, "operation declaration nesting depth exceeded");
+			return false;
+		}
+		if (!this.object(value, path, "container") || !this.enter(value, path)) return false;
+		let valid = this.fields(value, [
+			"description",
+			"operations",
+			"containers"
+		], path) && this.description(value, path);
+		const operationNames = isRecord(value.operations) ? new Set(Object.getOwnPropertyNames(value.operations)) : /* @__PURE__ */ new Set();
+		const containerNames = isRecord(value.containers) ? new Set(Object.getOwnPropertyNames(value.containers)) : /* @__PURE__ */ new Set();
+		for (const name of operationNames) if (containerNames.has(name)) {
+			this.issue("operation.container.name-collision", [...path, name], "operation and container names must be disjoint");
+			valid = false;
+		}
+		if (own$1(value, "operations")) valid = this.nameMap(value.operations, [...path, "operations"], "operation", (item, childPath) => this.operation(item, childPath, structured)) && valid;
+		if (own$1(value, "containers")) valid = this.nameMap(value.containers, [...path, "containers"], "container", (item, childPath) => this.container(item, childPath, structured)) && valid;
+		this.leave(value);
+		return valid;
+	}
+};
+function validateOperationDefinition(value) {
+	const validator = new Validator$1();
+	return validator.operation(value, []) ? {
+		ok: true,
+		operation: value,
+		issues: []
+	} : {
+		ok: false,
+		issues: validator.issues
+	};
+}
+function validateOperationContainerDefinition(value) {
+	const validator = new Validator$1();
+	return validator.container(value, []) ? {
+		ok: true,
+		container: value,
+		issues: []
+	} : {
+		ok: false,
+		issues: validator.issues
+	};
+}
+function validateStructuredOperationDefinition(value) {
+	const validator = new Validator$1();
+	return validator.operation(value, [], true) ? {
+		ok: true,
+		operation: value,
+		issues: []
+	} : {
+		ok: false,
+		issues: validator.issues
+	};
+}
+function validateStructuredOperationContainerDefinition(value) {
+	const validator = new Validator$1();
+	return validator.container(value, [], true) ? {
+		ok: true,
+		container: value,
+		issues: []
+	} : {
+		ok: false,
+		issues: validator.issues
+	};
+}
+function isStructuredOperationDefinition(value) {
+	return validateStructuredOperationDefinition(value).ok;
+}
+function isStructuredOperationContainerDefinition(value) {
+	return validateStructuredOperationContainerDefinition(value).ok;
+}
+
+//#endregion
+//#region src/definition/expression-shape.ts
+const expressionKinds = new Set([
+	"typeVar",
+	"opaqueHostType",
+	"absent",
+	"never",
+	"unknown",
+	"maybeAbsent",
+	"arrayOf",
+	"tupleOf",
+	"recordOf",
+	"elementOf",
+	"valueOf",
+	"elementAt",
+	"fieldOf",
+	"keyOf",
+	"fieldsOf",
+	"pickFields",
+	"omitFields",
+	"partialFields",
+	"requiredFields",
+	"mergeRecords",
+	"nullableOf",
+	"taggedUnionOf",
+	"intersect",
+	"refine",
+	"excludeVariants",
+	"extractVariants"
+]);
+const expressionFields = {
+	typeVar: {
+		required: ["name"],
+		allowed: [
+			"kind",
+			"name",
+			"extends"
+		]
+	},
+	opaqueHostType: {
+		required: ["hostPath"],
+		allowed: ["kind", "hostPath"]
+	},
+	absent: {
+		required: [],
+		allowed: ["kind"]
+	},
+	never: {
+		required: [],
+		allowed: ["kind"]
+	},
+	unknown: {
+		required: [],
+		allowed: ["kind"]
+	},
+	maybeAbsent: {
+		required: ["value"],
+		allowed: ["kind", "value"]
+	},
+	arrayOf: {
+		required: ["element"],
+		allowed: [
+			"kind",
+			"element",
+			"constraints"
+		]
+	},
+	tupleOf: {
+		required: ["elements"],
+		allowed: ["kind", "elements"]
+	},
+	recordOf: {
+		required: ["fields"],
+		allowed: [
+			"kind",
+			"fields",
+			"additionalFields",
+			"constraints"
+		]
+	},
+	nullableOf: {
+		required: ["value"],
+		allowed: ["kind", "value"]
+	},
+	taggedUnionOf: {
+		required: ["discriminator", "variants"],
+		allowed: [
+			"kind",
+			"discriminator",
+			"variants"
+		]
+	},
+	elementOf: {
+		required: ["source"],
+		allowed: ["kind", "source"]
+	},
+	valueOf: {
+		required: ["source"],
+		allowed: ["kind", "source"]
+	},
+	elementAt: {
+		required: ["source", "index"],
+		allowed: [
+			"kind",
+			"source",
+			"index"
+		]
+	},
+	fieldOf: {
+		required: ["source", "key"],
+		allowed: [
+			"kind",
+			"source",
+			"key"
+		]
+	},
+	keyOf: {
+		required: ["source"],
+		allowed: ["kind", "source"]
+	},
+	fieldsOf: {
+		required: ["source", "fields"],
+		allowed: [
+			"kind",
+			"source",
+			"fields"
+		]
+	},
+	pickFields: {
+		required: ["source", "fields"],
+		allowed: [
+			"kind",
+			"source",
+			"fields"
+		]
+	},
+	omitFields: {
+		required: ["source", "fields"],
+		allowed: [
+			"kind",
+			"source",
+			"fields"
+		]
+	},
+	partialFields: {
+		required: ["source", "fields"],
+		allowed: [
+			"kind",
+			"source",
+			"fields"
+		]
+	},
+	requiredFields: {
+		required: ["source", "fields"],
+		allowed: [
+			"kind",
+			"source",
+			"fields"
+		]
+	},
+	mergeRecords: {
+		required: ["sources", "conflict"],
+		allowed: [
+			"kind",
+			"sources",
+			"conflict"
+		]
+	},
+	intersect: {
+		required: ["sources"],
+		allowed: ["kind", "sources"]
+	},
+	refine: {
+		required: ["source", "fields"],
+		allowed: [
+			"kind",
+			"source",
+			"fields"
+		]
+	},
+	excludeVariants: {
+		required: ["source", "variants"],
+		allowed: [
+			"kind",
+			"source",
+			"variants"
+		]
+	},
+	extractVariants: {
+		required: ["source", "variants"],
+		allowed: [
+			"kind",
+			"source",
+			"variants"
+		]
+	}
+};
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, keys$1) {
+	return Object.keys(value).every((key) => keys$1.includes(key));
+}
+function isSelector(value) {
+	if (!isObject(value)) return false;
+	if (value.kind === "all") return hasOnlyKeys(value, ["kind"]);
+	return value.kind === "keys" && hasOnlyKeys(value, [
+		"kind",
+		"keys",
+		"onMissing"
+	]) && Array.isArray(value.keys) && value.keys.every((key) => typeof key === "string") && new Set(value.keys).size === value.keys.length && (value.onMissing === "error" || value.onMissing === "ignore");
+}
+function expressionShapeIssue(expression) {
+	const kind = expression.kind;
+	if (kind === "typeVar" && (typeof expression.name !== "string" || !expression.name.trim())) return "typeVar name must be non-blank";
+	if (kind === "opaqueHostType" && (!Array.isArray(expression.hostPath) || expression.hostPath.length === 0 || expression.hostPath.some((part) => typeof part !== "string" || !part.trim()))) return "hostPath must be a non-empty path";
+	if (kind === "tupleOf" && (!Array.isArray(expression.elements) || !isDense(expression.elements))) return "elements must be a dense array";
+	if (kind === "recordOf") {
+		if (!Array.isArray(expression.fields) || !isDense(expression.fields)) return "fields must be a dense array";
+		const keys$1 = /* @__PURE__ */ new Set();
+		for (const field of expression.fields) {
+			if (!isObject(field) || !hasOnlyKeys(field, [
+				"key",
+				"value",
+				"required",
+				"description"
+			]) || typeof field.key !== "string" || keys$1.has(field.key)) return "record fields must have unique keys and a valid shape";
+			if (field.required !== void 0 && typeof field.required !== "boolean") return "record field required must be a boolean";
+			if (field.description !== void 0 && typeof field.description !== "string") return "record field description must be a string";
+			keys$1.add(field.key);
+		}
+		if (expression.additionalFields !== void 0 && expression.additionalFields !== true && !isObject(expression.additionalFields)) return "additionalFields must be a type term or true";
+		if (expression.constraints !== void 0 && (!Array.isArray(expression.constraints) || !isDense(expression.constraints))) return "constraints must be a dense array";
+	}
+	if (kind === "arrayOf" && expression.constraints !== void 0 && (!Array.isArray(expression.constraints) || !isDense(expression.constraints))) return "constraints must be a dense array";
+	if (kind === "taggedUnionOf") {
+		if (typeof expression.discriminator !== "string" || !expression.discriminator.trim() || !Array.isArray(expression.variants) || !isDense(expression.variants) || expression.variants.length < 2) return "taggedUnionOf requires a discriminator and at least two dense variants";
+		const keys$1 = /* @__PURE__ */ new Set();
+		for (const variant of expression.variants) {
+			if (!isObject(variant) || !hasOnlyKeys(variant, [
+				"key",
+				"value",
+				"description"
+			]) || typeof variant.key !== "string" || !variant.key.trim() || keys$1.has(variant.key)) return "taggedUnionOf variants must have unique non-blank keys and a valid shape";
+			if (variant.description !== void 0 && typeof variant.description !== "string") return "variant description must be a string";
+			keys$1.add(variant.key);
+		}
+	}
+	if ([
+		"fieldsOf",
+		"pickFields",
+		"omitFields",
+		"partialFields",
+		"requiredFields"
+	].includes(String(kind)) && !isSelector(expression.fields)) return "fields must be a valid field selector";
+	if ((kind === "excludeVariants" || kind === "extractVariants") && !isSelector(expression.variants)) return "variants must be a valid variant selector";
+	if (kind === "elementAt" && (!Number.isSafeInteger(expression.index) || expression.index < 0)) return "index must be a non-negative safe integer";
+	if (kind === "fieldOf" && typeof expression.key !== "string") return "key must be a string";
+	if (kind === "mergeRecords" && (!Array.isArray(expression.sources) || !isDense(expression.sources) || expression.sources.length < 2 || ![
+		"leftWins",
+		"rightWins",
+		"error"
+	].includes(String(expression.conflict)))) return "mergeRecords requires at least two dense sources and a valid conflict policy";
+	if (kind === "intersect" && (!Array.isArray(expression.sources) || !isDense(expression.sources) || expression.sources.length < 2)) return "intersect requires at least two dense sources";
+	if (kind === "refine") {
+		if (!Array.isArray(expression.fields) || !isDense(expression.fields) || expression.fields.length === 0) return "refine requires non-empty dense field actions";
+		const keys$1 = /* @__PURE__ */ new Set();
+		for (const action of expression.fields) {
+			if (!isObject(action) || !hasOnlyKeys(action, [
+				"key",
+				"require",
+				"intersectWith",
+				"addConstraints"
+			]) || typeof action.key !== "string" || keys$1.has(action.key)) return "refine actions must have unique keys and a valid shape";
+			if (action.require !== void 0 && action.require !== true) return "refine require must be true when specified";
+			if (action.addConstraints !== void 0 && (!Array.isArray(action.addConstraints) || !isDense(action.addConstraints))) return "addConstraints must be a dense array";
+			keys$1.add(action.key);
+		}
+	}
+}
+function isDense(value) {
+	for (let index = 0; index < value.length; index += 1) if (!Object.prototype.hasOwnProperty.call(value, index)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/definition/expression-validator.ts
+const own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var Validator = class {
+	issues = [];
+	steps = 0;
+	active = /* @__PURE__ */ new WeakSet();
+	issue(code, path, message) {
+		this.issues.push({
+			code: `expression.${code}`,
+			path,
+			message
+		});
+		return false;
+	}
+	portable(value, path = [], depth = 0) {
+		if (++this.steps > 1e4 || depth > 64) return this.issue("budget", path, "definition validation budget exceeded");
+		if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+		if (typeof value === "number" && Number.isFinite(value)) return true;
+		if (typeof value !== "object" || value === null) return this.issue("json.invalid", path, "value must be JSON-compatible");
+		if (this.active.has(value)) return this.issue("cycle", path, "declarations must be acyclic");
+		const array = Array.isArray(value);
+		const prototype = Object.getPrototypeOf(value);
+		if (!array && prototype !== null && prototype !== Object.prototype) return this.issue("object.invalid", path, "declarations require plain objects");
+		this.active.add(value);
+		let valid = true;
+		for (const key of Reflect.ownKeys(value)) {
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (typeof key === "symbol" || !("value" in descriptor) || !descriptor.enumerable && !(array && key === "length")) {
+				valid = this.issue("property.invalid", path, "only enumerable own data properties are supported") && valid;
+				continue;
+			}
+			if (array && key === "length") continue;
+			if (array && (!/^(0|[1-9]\d*)$/.test(key) || Number(key) >= value.length)) {
+				valid = this.issue("array.invalid", path, "arrays must have only indexed elements") && valid;
+				continue;
+			}
+			valid = this.portable(descriptor.value, [...path, array ? Number(key) : key], depth + 1) && valid;
+		}
+		if (array) {
+			for (let i = 0; i < value.length; i++) if (!own(value, String(i))) {
+				valid = this.issue("array.sparse", [...path, i], "arrays must be dense") && valid;
+				break;
+			}
+		}
+		this.active.delete(value);
+		return valid;
+	}
+	term(value, path = [], expressionOnly = false) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return this.issue("term.invalid", path, "type term must be an object");
+		const record = value;
+		const kind = record.kind;
+		if (typeof kind !== "string" || !expressionKinds.has(kind)) {
+			if (expressionOnly) return this.issue("kind.invalid", [...path, "kind"], "expected a SchemaTypeExpr kind");
+			const schema = validateSchemaNodeDefinition(value);
+			if (schema.ok) return true;
+			this.issues.push(...schema.issues.map((issue$1) => ({
+				...issue$1,
+				path: [...path, ...issue$1.path]
+			})));
+			return false;
+		}
+		const shape = expressionFields[kind];
+		for (const key of Object.keys(record)) if (!shape.allowed.includes(key)) return this.issue("shape.invalid", [...path, key], `unknown field '${key}'`);
+		for (const key of shape.required) if (!own(record, key)) return this.issue("shape.invalid", [...path, key], `missing field '${key}'`);
+		const issue = expressionShapeIssue(record);
+		if (issue) return this.issue("shape.invalid", path, issue);
+		let valid = true;
+		const child = (value$1, childPath) => {
+			valid = this.term(value$1, childPath) && valid;
+		};
+		for (const key of [
+			"value",
+			"element",
+			"source",
+			"extends"
+		]) if (own(record, key)) child(record[key], [...path, key]);
+		if (own(record, "additionalFields") && record.additionalFields !== true) child(record.additionalFields, [...path, "additionalFields"]);
+		for (const key of ["elements", "sources"]) if (Array.isArray(record[key])) record[key].forEach((item, index) => child(item, [
+			...path,
+			key,
+			index
+		]));
+		for (const key of ["fields", "variants"]) if (Array.isArray(record[key])) record[key].forEach((item, index) => {
+			if (kind === "recordOf" && key === "fields" || kind === "taggedUnionOf" && key === "variants") child(item.value, [
+				...path,
+				key,
+				index,
+				"value"
+			]);
+			if (kind === "refine" && own(item, "intersectWith")) child(item.intersectWith, [
+				...path,
+				key,
+				index,
+				"intersectWith"
+			]);
+			if (kind === "refine" && own(item, "addConstraints")) valid = this.constraints(item.addConstraints, [
+				...path,
+				key,
+				index,
+				"addConstraints"
+			]) && valid;
+		});
+		if (own(record, "constraints")) valid = this.constraints(record.constraints, [...path, "constraints"]) && valid;
+		return valid;
+	}
+	constraints(value, path) {
+		const result = validateSchemaNodeDefinition({
+			kind: "record",
+			fields: [],
+			constraints: value
+		});
+		if (result.ok) return true;
+		this.issues.push(...result.issues.map((issue) => ({
+			...issue,
+			path: [...path, ...issue.path.slice(1)]
+		})));
+		return false;
+	}
+};
+function validateSchemaTypeExprDefinition(value) {
+	const validator = new Validator();
+	return validator.portable(value) && validator.term(value, [], true) ? {
+		ok: true,
+		expression: value,
+		issues: []
+	} : {
+		ok: false,
+		issues: validator.issues
+	};
+}
+function validateSchemaTypeTermDefinition(value) {
+	const validator = new Validator();
+	return validator.portable(value) && validator.term(value) ? {
+		ok: true,
+		term: value,
+		issues: []
+	} : {
+		ok: false,
+		issues: validator.issues
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'expressionFields', {
+  enumerable: true,
+  get: function () {
+    return expressionFields;
+  }
+});
+Object.defineProperty(exports, 'expressionKinds', {
+  enumerable: true,
+  get: function () {
+    return expressionKinds;
+  }
+});
+Object.defineProperty(exports, 'expressionShapeIssue', {
+  enumerable: true,
+  get: function () {
+    return expressionShapeIssue;
+  }
+});
+Object.defineProperty(exports, 'isStructuredOperationContainerDefinition', {
+  enumerable: true,
+  get: function () {
+    return isStructuredOperationContainerDefinition;
+  }
+});
+Object.defineProperty(exports, 'isStructuredOperationDefinition', {
+  enumerable: true,
+  get: function () {
+    return isStructuredOperationDefinition;
+  }
+});
+Object.defineProperty(exports, 'validateOperationContainerDefinition', {
+  enumerable: true,
+  get: function () {
+    return validateOperationContainerDefinition;
+  }
+});
+Object.defineProperty(exports, 'validateOperationDefinition', {
+  enumerable: true,
+  get: function () {
+    return validateOperationDefinition;
+  }
+});
+Object.defineProperty(exports, 'validateSchemaNodeDefinition', {
+  enumerable: true,
+  get: function () {
+    return validateSchemaNodeDefinition;
+  }
+});
+Object.defineProperty(exports, 'validateSchemaTypeExprDefinition', {
+  enumerable: true,
+  get: function () {
+    return validateSchemaTypeExprDefinition;
+  }
+});
+Object.defineProperty(exports, 'validateSchemaTypeTermDefinition', {
+  enumerable: true,
+  get: function () {
+    return validateSchemaTypeTermDefinition;
+  }
+});
+Object.defineProperty(exports, 'validateStructuredOperationContainerDefinition', {
+  enumerable: true,
+  get: function () {
+    return validateStructuredOperationContainerDefinition;
+  }
+});
+Object.defineProperty(exports, 'validateStructuredOperationDefinition', {
+  enumerable: true,
+  get: function () {
+    return validateStructuredOperationDefinition;
+  }
+});