@atscript/typescript 0.1.33 → 0.1.35

package/dist/utils.cjs

@@ -1,915 +1,6 @@
 "use strict";
+const require_json_schema = require('./json-schema-S5-XAOrR.cjs');
 
-//#region packages/typescript/src/validator.ts
-function _define_property(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-else obj[key] = value;
-	return obj;
-}
-const regexCache = new Map();
-var Validator = class {
-	isLimitExceeded() {
-		if (this.stackErrors.length > 0) {
-			const top = this.stackErrors[this.stackErrors.length - 1];
-			return top !== null && top.length >= this.opts.errorLimit;
-		}
-		return this.errors.length >= this.opts.errorLimit;
-	}
-	push(name) {
-		this.stackPath.push(name);
-		this.stackErrors.push(null);
-		this.cachedPath = this.stackPath.length <= 1 ? "" : this.stackPath[1] + (this.stackPath.length > 2 ? "." + this.stackPath.slice(2).join(".") : "");
-	}
-	pop(saveErrors) {
-		this.stackPath.pop();
-		const popped = this.stackErrors.pop();
-		if (saveErrors && popped !== null && popped !== undefined && popped.length > 0) for (const err of popped) this.error(err.message, err.path, err.details);
-		this.cachedPath = this.stackPath.length <= 1 ? "" : this.stackPath[1] + (this.stackPath.length > 2 ? "." + this.stackPath.slice(2).join(".") : "");
-		return popped;
-	}
-	clear() {
-		this.stackErrors[this.stackErrors.length - 1] = null;
-	}
-	error(message, path, details) {
-		let errors = this.stackErrors[this.stackErrors.length - 1];
-		if (!errors) if (this.stackErrors.length > 0) {
-			errors = [];
-			this.stackErrors[this.stackErrors.length - 1] = errors;
-		} else errors = this.errors;
-		const error = {
-			path: path || this.cachedPath,
-			message
-		};
-		if (details?.length) error.details = details;
-		errors.push(error);
-	}
-	throw() {
-		throw new ValidatorError(this.errors);
-	}
-	/**
-	* Validates a value against the type definition.
-	*
-	* Acts as a TypeScript type guard — when it returns `true`, the value
-	* is narrowed to `DataType`.
-	*
-	* @param value - The value to validate.
-	* @param safe - If `true`, returns `false` on failure instead of throwing.
-	* @returns `true` if the value matches the type definition.
-	* @throws {ValidatorError} When validation fails and `safe` is not `true`.
-	*/ validate(value, safe, context) {
-		this.errors = [];
-		this.stackErrors = [];
-		this.stackPath = [""];
-		this.cachedPath = "";
-		this.context = context;
-		const passed = this.validateSafe(this.def, value);
-		this.pop(!passed);
-		this.context = undefined;
-		if (!passed) {
-			if (safe) return false;
-			this.throw();
-		}
-		return true;
-	}
-	validateSafe(def, value) {
-		if (this.isLimitExceeded()) return false;
-		if (!isAnnotatedType(def)) throw new Error("Can not validate not-annotated type");
-		if (typeof this.opts.replace === "function") def = this.opts.replace(def, this.cachedPath);
-		if (def.optional && value === undefined) return true;
-		for (const plugin of this.opts.plugins) {
-			const result = plugin(this, def, value);
-			if (result === false || result === true) return result;
-		}
-		return this.validateAnnotatedType(def, value);
-	}
-	get path() {
-		return this.cachedPath;
-	}
-	validateAnnotatedType(def, value) {
-		switch (def.type.kind) {
-			case "": {
-				if (def.type.designType === "phantom") return true;
-				return this.validatePrimitive(def, value);
-			}
-			case "object": return this.validateObject(def, value);
-			case "array": return this.validateArray(def, value);
-			case "union": return this.validateUnion(def, value);
-			case "intersection": return this.validateIntersection(def, value);
-			case "tuple": return this.validateTuple(def, value);
-			default: throw new Error(`Unknown type kind "${def.type.kind}"`);
-		}
-	}
-	validateUnion(def, value) {
-		let i = 0;
-		const popped = [];
-		for (const item of def.type.items) {
-			this.push(`[${item.type.kind || item.type.designType}(${i})]`);
-			if (this.validateSafe(item, value)) {
-				this.pop(false);
-				return true;
-			}
-			const errors = this.pop(false);
-			if (errors) popped.push(...errors);
-			i++;
-		}
-		this.clear();
-		const expected = def.type.items.map((item, i$1) => `[${item.type.kind || item.type.designType}(${i$1})]`).join(", ");
-		this.error(`Value does not match any of the allowed types: ${expected}`, undefined, popped);
-		return false;
-	}
-	validateIntersection(def, value) {
-		for (const item of def.type.items) if (!this.validateSafe(item, value)) return false;
-		return true;
-	}
-	validateTuple(def, value) {
-		if (!Array.isArray(value) || value.length !== def.type.items.length) {
-			this.error(`Expected array of length ${def.type.items.length}`);
-			return false;
-		}
-		let i = 0;
-		for (const item of def.type.items) {
-			this.push(String(i));
-			if (!this.validateSafe(item, value[i])) {
-				this.pop(true);
-				return false;
-			}
-			this.pop(false);
-			i++;
-		}
-		return true;
-	}
-	validateArray(def, value) {
-		if (!Array.isArray(value)) {
-			this.error("Expected array");
-			return false;
-		}
-		const minLength = def.metadata.get("expect.minLength");
-		if (minLength) {
-			const length = typeof minLength === "number" ? minLength : minLength.length;
-			if (value.length < length) {
-				const message = typeof minLength === "object" && minLength.message ? minLength.message : `Expected minimum length of ${length} items, got ${value.length} items`;
-				this.error(message);
-				return false;
-			}
-		}
-		const maxLength = def.metadata.get("expect.maxLength");
-		if (maxLength) {
-			const length = typeof maxLength === "number" ? maxLength : maxLength.length;
-			if (value.length > length) {
-				const message = typeof maxLength === "object" && maxLength.message ? maxLength.message : `Expected maximum length of ${length} items, got ${value.length} items`;
-				this.error(message);
-				return false;
-			}
-		}
-		const uniqueItems = def.metadata.get("expect.array.uniqueItems");
-		if (uniqueItems) {
-			const separator = "▼↩";
-			const seen = new Set();
-			const keyProps = new Set();
-			if (def.type.of.type.kind === "object") {
-				for (const [key, val] of def.type.of.type.props.entries()) if (val.metadata.get("expect.array.key")) keyProps.add(key);
-			}
-			for (let idx = 0; idx < value.length; idx++) {
-				const item = value[idx];
-				let key;
-				if (keyProps.size > 0) {
-					key = "";
-					for (const prop of keyProps) key += JSON.stringify(item[prop]) + separator;
-				} else key = JSON.stringify(item);
-				if (seen.has(key)) {
-					this.push(String(idx));
-					this.error(uniqueItems.message || "Duplicate items are not allowed");
-					this.pop(true);
-					return false;
-				}
-				seen.add(key);
-			}
-		}
-		let i = 0;
-		let passed = true;
-		for (const item of value) {
-			this.push(String(i));
-			if (!this.validateSafe(def.type.of, item)) {
-				passed = false;
-				this.pop(true);
-				if (this.isLimitExceeded()) return false;
-			} else this.pop(false);
-			i++;
-		}
-		return passed;
-	}
-	validateObject(def, value) {
-		if (typeof value !== "object" || value === null || Array.isArray(value)) {
-			this.error("Expected object");
-			return false;
-		}
-		let passed = true;
-		const valueKeys = new Set(Object.keys(value));
-		const typeKeys = new Set();
-		let skipList;
-		if (this.opts.skipList) {
-			const path = this.stackPath.length > 1 ? `${this.cachedPath}.` : "";
-			for (const item of this.opts.skipList) if (item.startsWith(path)) {
-				const key = item.slice(path.length);
-				if (!skipList) skipList = new Set();
-				skipList.add(key);
-				valueKeys.delete(key);
-			}
-		}
-		let partialFunctionMatched = false;
-		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.cachedPath);
-		for (const [key, item] of def.type.props.entries()) {
-			if (skipList && skipList.has(key) || isPhantomType(item)) continue;
-			typeKeys.add(key);
-			if (value[key] === undefined) {
-				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
-			}
-			this.push(key);
-			if (this.validateSafe(item, value[key])) this.pop(false);
-else {
-				passed = false;
-				this.pop(true);
-				if (this.isLimitExceeded()) return false;
-			}
-		}
-		for (const key of valueKeys)
- /** matched patterns for unknown keys */ if (!typeKeys.has(key)) {
-			const matched = [];
-			for (const { pattern, def: propDef } of def.type.propsPatterns) if (pattern.test(key)) matched.push({
-				pattern,
-				def: propDef
-			});
-			if (matched.length > 0) {
-				this.push(key);
-				let keyPassed = false;
-				for (const { def: propDef } of matched) {
-					if (this.validateSafe(propDef, value[key])) {
-						keyPassed = true;
-						break;
-					}
-					this.clear();
-				}
-				if (!keyPassed) {
-					this.validateSafe(matched[0].def, value[key]);
-					this.pop(true);
-					passed = false;
-					if (this.isLimitExceeded()) return false;
-				} else this.pop(false);
-			} else if (this.opts.unknownProps !== "ignore") {
-				if (this.opts.unknownProps === "error") {
-					this.push(key);
-					this.error(`Unexpected property`);
-					this.pop(true);
-					if (this.isLimitExceeded()) return false;
-					passed = false;
-				} else if (this.opts.unknownProps === "strip") delete value[key];
-			}
-		}
-		return passed;
-	}
-	validatePrimitive(def, value) {
-		if (def.type.value !== undefined) {
-			if (value !== def.type.value) {
-				this.error(`Expected ${def.type.value}, got ${value}`);
-				return false;
-			}
-			return true;
-		}
-		const typeOfValue = Array.isArray(value) ? "array" : typeof value;
-		switch (def.type.designType) {
-			case "never": {
-				this.error(`This type is impossible, must be an internal problem`);
-				return false;
-			}
-			case "any": return true;
-			case "string": {
-				if (typeOfValue !== def.type.designType) {
-					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
-					return false;
-				}
-				return this.validateString(def, value);
-			}
-			case "number": {
-				if (typeOfValue !== def.type.designType) {
-					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
-					return false;
-				}
-				return this.validateNumber(def, value);
-			}
-			case "boolean": {
-				if (typeOfValue !== def.type.designType) {
-					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
-					return false;
-				}
-				return this.validateBoolean(def, value);
-			}
-			case "undefined": {
-				if (value !== undefined) {
-					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
-					return false;
-				}
-				return true;
-			}
-			case "null": {
-				if (value !== null) {
-					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
-					return false;
-				}
-				return true;
-			}
-			default: throw new Error(`Unknown type "${def.type.designType}"`);
-		}
-	}
-	validateString(def, value) {
-		const filled = def.metadata.get("meta.required");
-		if (filled) {
-			if (value.trim().length === 0) {
-				const message = typeof filled === "object" && filled.message ? filled.message : `Must not be empty`;
-				this.error(message);
-				return false;
-			}
-		}
-		const minLength = def.metadata.get("expect.minLength");
-		if (minLength) {
-			const length = typeof minLength === "number" ? minLength : minLength.length;
-			if (value.length < length) {
-				const message = typeof minLength === "object" && minLength.message ? minLength.message : `Expected minimum length of ${length} characters, got ${value.length} characters`;
-				this.error(message);
-				return false;
-			}
-		}
-		const maxLength = def.metadata.get("expect.maxLength");
-		if (maxLength) {
-			const length = typeof maxLength === "number" ? maxLength : maxLength.length;
-			if (value.length > length) {
-				const message = typeof maxLength === "object" && maxLength.message ? maxLength.message : `Expected maximum length of ${length} characters, got ${value.length} characters`;
-				this.error(message);
-				return false;
-			}
-		}
-		const patterns = def.metadata.get("expect.pattern");
-		for (const { pattern, flags, message } of patterns || []) {
-			if (!pattern) continue;
-			const cacheKey = `${pattern}//${flags || ""}`;
-			let regex = regexCache.get(cacheKey);
-			if (!regex) {
-				regex = new RegExp(pattern, flags);
-				regexCache.set(cacheKey, regex);
-			}
-			if (!regex.test(value)) {
-				this.error(message || `Value is expected to match pattern "${pattern}"`);
-				return false;
-			}
-		}
-		return true;
-	}
-	validateNumber(def, value) {
-		const int = def.metadata.get("expect.int");
-		if (int && value % 1 !== 0) {
-			const message = typeof int === "object" && int.message ? int.message : `Expected integer, got ${value}`;
-			this.error(message);
-			return false;
-		}
-		const min = def.metadata.get("expect.min");
-		if (min) {
-			const minValue = typeof min === "number" ? min : min.minValue;
-			if (value < minValue) {
-				const message = typeof min === "object" && min.message ? min.message : `Expected minimum ${minValue}, got ${value}`;
-				this.error(message);
-				return false;
-			}
-		}
-		const max = def.metadata.get("expect.max");
-		if (max) {
-			const maxValue = typeof max === "number" ? max : max.maxValue;
-			if (value > maxValue) {
-				const message = typeof max === "object" && max.message ? max.message : `Expected maximum ${maxValue}, got ${value}`;
-				this.error(message);
-				return false;
-			}
-		}
-		return true;
-	}
-	validateBoolean(def, value) {
-		const filled = def.metadata.get("meta.required");
-		if (filled) {
-			if (value !== true) {
-				const message = typeof filled === "object" && filled.message ? filled.message : `Must be checked`;
-				this.error(message);
-				return false;
-			}
-		}
-		return true;
-	}
-	constructor(def, opts) {
-		_define_property(this, "def", void 0);
-		_define_property(this, "opts", void 0);
-		/** Validation errors collected during the last {@link validate} call. */ _define_property(this, "errors", void 0);
-		_define_property(this, "stackErrors", void 0);
-		_define_property(this, "stackPath", void 0);
-		_define_property(this, "cachedPath", void 0);
-		_define_property(this, "context", void 0);
-		this.def = def;
-		this.errors = [];
-		this.stackErrors = [];
-		this.stackPath = [];
-		this.cachedPath = "";
-		this.opts = {
-			partial: false,
-			unknownProps: "error",
-			errorLimit: 10,
-			...opts,
-			plugins: opts?.plugins || []
-		};
-	}
-};
-var ValidatorError = class extends Error {
-	constructor(errors) {
-		super(`${errors[0].path ? errors[0].path + ": " : ""}${errors[0].message}`), _define_property(this, "errors", void 0), _define_property(this, "name", void 0), this.errors = errors, this.name = "Validation Error";
-	}
-};
-
-//#endregion
-//#region packages/typescript/src/annotated-type.ts
-const COMPLEX_KINDS = new Set([
-	"union",
-	"intersection",
-	"tuple"
-]);
-const NON_PRIMITIVE_KINDS = new Set(["array", "object"]);
-/** Shared validator method reused by all annotated type nodes. */ function validatorMethod(opts) {
-	return new Validator(this, opts);
-}
-function createAnnotatedTypeNode(type, metadata, opts) {
-	return {
-		__is_atscript_annotated_type: true,
-		type,
-		metadata,
-		validator: validatorMethod,
-		id: opts?.id,
-		optional: opts?.optional
-	};
-}
-function isAnnotatedType(type) {
-	return type && type.__is_atscript_annotated_type;
-}
-function annotate(metadata, key, value, asArray) {
-	if (!metadata) return;
-	if (asArray) if (metadata.has(key)) {
-		const a = metadata.get(key);
-		if (Array.isArray(a)) a.push(value);
-else metadata.set(key, [a, value]);
-	} else metadata.set(key, [value]);
-else metadata.set(key, value);
-}
-function cloneRefProp(parentType, propName) {
-	if (parentType.kind !== "object") return;
-	const objType = parentType;
-	const existing = objType.props.get(propName);
-	if (!existing) return;
-	const clonedType = cloneTypeDef(existing.type);
-	objType.props.set(propName, createAnnotatedTypeNode(clonedType, new Map(existing.metadata), {
-		id: existing.id,
-		optional: existing.optional
-	}));
-}
-function cloneTypeDef(type) {
-	if (type.kind === "object") {
-		const obj = type;
-		const props = new Map();
-		for (const [k, v] of obj.props) props.set(k, createAnnotatedTypeNode(v.type, new Map(v.metadata), {
-			id: v.id,
-			optional: v.optional
-		}));
-		return {
-			kind: "object",
-			props,
-			propsPatterns: [...obj.propsPatterns],
-			tags: new Set(obj.tags)
-		};
-	}
-	if (type.kind === "array") {
-		const arr = type;
-		return {
-			kind: "array",
-			of: arr.of,
-			tags: new Set(arr.tags)
-		};
-	}
-	if (type.kind === "union" || type.kind === "intersection" || type.kind === "tuple") {
-		const complex = type;
-		return {
-			kind: type.kind,
-			items: [...complex.items],
-			tags: new Set(complex.tags)
-		};
-	}
-	return {
-		...type,
-		tags: new Set(type.tags)
-	};
-}
-function defineAnnotatedType(_kind, base) {
-	const kind = _kind || "";
-	const type = base?.type || {};
-	type.kind = kind;
-	if (COMPLEX_KINDS.has(kind)) type.items = [];
-	if (kind === "object") {
-		type.props = new Map();
-		type.propsPatterns = [];
-	}
-	type.tags = new Set();
-	const metadata = base?.metadata || new Map();
-	const payload = {
-		__is_atscript_annotated_type: true,
-		metadata,
-		type,
-		validator: validatorMethod
-	};
-	base = base ? Object.assign(base, payload) : payload;
-	const handle = {
-		$type: base,
-		$def: type,
-		$metadata: metadata,
-		tags(...tags) {
-			for (const tag of tags) this.$def.tags.add(tag);
-			return this;
-		},
-		designType(value) {
-			this.$def.designType = value;
-			return this;
-		},
-		value(value) {
-			this.$def.value = value;
-			return this;
-		},
-		of(value) {
-			this.$def.of = value;
-			return this;
-		},
-		item(value) {
-			this.$def.items.push(value);
-			return this;
-		},
-		prop(name, value) {
-			this.$def.props.set(name, value);
-			return this;
-		},
-		propPattern(pattern, def) {
-			this.$def.propsPatterns.push({
-				pattern,
-				def
-			});
-			return this;
-		},
-		optional(value = true) {
-			this.$type.optional = value;
-			return this;
-		},
-		copyMetadata(fromMetadata, ignore) {
-			for (const [key, value] of fromMetadata.entries()) if (!ignore || !ignore.has(key)) this.$metadata.set(key, value);
-			return this;
-		},
-		refTo(type$1, chain) {
-			if (!isAnnotatedType(type$1)) throw new Error(`${type$1} is not annotated type`);
-			let newBase = type$1;
-			const typeName = type$1.name || "Unknown";
-			if (chain) for (let i = 0; i < chain.length; i++) {
-				const c = chain[i];
-				if (newBase.type.kind === "object" && newBase.type.props.has(c)) newBase = newBase.type.props.get(c);
-else {
-					const keys = chain.slice(0, i + 1).map((k) => `["${k}"]`).join("");
-					throw new Error(`Can't find prop ${typeName}${keys}`);
-				}
-			}
-			this.$type = createAnnotatedTypeNode(newBase.type, metadata, { id: newBase.id });
-			return this;
-		},
-		annotate(key, value, asArray) {
-			annotate(this.$metadata, key, value, asArray);
-			return this;
-		},
-		id(value) {
-			this.$type.id = value;
-			return this;
-		}
-	};
-	return handle;
-}
-function isPhantomType(def) {
-	return def.type.kind === "" && def.type.designType === "phantom";
-}
-function isAnnotatedTypeOfPrimitive(t) {
-	if (NON_PRIMITIVE_KINDS.has(t.type.kind)) return false;
-	if (!t.type.kind) return true;
-	if (COMPLEX_KINDS.has(t.type.kind)) {
-		for (const item of t.type.items) if (!isAnnotatedTypeOfPrimitive(item)) return false;
-		return true;
-	}
-	return false;
-}
-
-//#endregion
-//#region packages/typescript/src/traverse.ts
-function forAnnotatedType(def, handlers) {
-	switch (def.type.kind) {
-		case "": {
-			const typed = def;
-			if (handlers.phantom && typed.type.designType === "phantom") return handlers.phantom(typed);
-			return handlers.final(typed);
-		}
-		case "object": return handlers.object(def);
-		case "array": return handlers.array(def);
-		case "union": return handlers.union(def);
-		case "intersection": return handlers.intersection(def);
-		case "tuple": return handlers.tuple(def);
-		default: throw new Error(`Unknown type kind "${def.type.kind}"`);
-	}
-}
-
-//#endregion
-//#region packages/typescript/src/json-schema.ts
-/**
-* Detects a discriminator property across union items.
-*
-* Scans all items for object-typed members that share a common property
-* with distinct const/literal values. If exactly one such property exists,
-* it is returned as the discriminator.
-*/ function detectDiscriminator(items) {
-	if (items.length < 2) return null;
-	for (const item of items) if (item.type.kind !== "object") return null;
-	const firstObj = items[0].type;
-	const candidates = [];
-	for (const [propName, propType] of firstObj.props.entries()) if (propType.type.kind === "" && propType.type.value !== undefined) candidates.push(propName);
-	let result = null;
-	for (const candidate of candidates) {
-		const values = new Set();
-		const indexMapping = {};
-		let valid = true;
-		for (let i = 0; i < items.length; i++) {
-			const obj = items[i].type;
-			const prop = obj.props.get(candidate);
-			if (!prop || prop.type.kind !== "" || prop.type.value === undefined) {
-				valid = false;
-				break;
-			}
-			const val = prop.type.value;
-			if (values.has(val)) {
-				valid = false;
-				break;
-			}
-			values.add(val);
-			indexMapping[String(val)] = i;
-		}
-		if (valid) {
-			if (result) return null;
-			result = {
-				propertyName: candidate,
-				indexMapping
-			};
-		}
-	}
-	return result;
-}
-function buildJsonSchema(type) {
-	const defs = {};
-	let hasDefs = false;
-	const buildObject = (d) => {
-		const properties = {};
-		const required = [];
-		for (const [key, val] of d.type.props.entries()) {
-			if (isPhantomType(val)) continue;
-			properties[key] = build$1(val);
-			if (!val.optional) required.push(key);
-		}
-		const schema$1 = {
-			type: "object",
-			properties
-		};
-		if (required.length > 0) schema$1.required = required;
-		return schema$1;
-	};
-	const build$1 = (def) => {
-		if (def.id && def.type.kind === "object" && def !== type) {
-			const name = def.id;
-			if (!defs[name]) {
-				hasDefs = true;
-				defs[name] = {};
-				defs[name] = buildObject(def);
-			}
-			return { $ref: `#/$defs/${name}` };
-		}
-		const meta = def.metadata;
-		return forAnnotatedType(def, {
-			phantom() {
-				return {};
-			},
-			object(d) {
-				return buildObject(d);
-			},
-			array(d) {
-				const schema$1 = {
-					type: "array",
-					items: build$1(d.type.of)
-				};
-				const minLength = meta.get("expect.minLength");
-				if (minLength) schema$1.minItems = typeof minLength === "number" ? minLength : minLength.length;
-				const maxLength = meta.get("expect.maxLength");
-				if (maxLength) schema$1.maxItems = typeof maxLength === "number" ? maxLength : maxLength.length;
-				return schema$1;
-			},
-			union(d) {
-				const disc = detectDiscriminator(d.type.items);
-				if (disc) {
-					const oneOf = d.type.items.map(build$1);
-					const mapping = {};
-					for (const [val, idx] of Object.entries(disc.indexMapping)) {
-						const item = d.type.items[idx];
-						mapping[val] = item.id && defs[item.id] ? `#/$defs/${item.id}` : `#/oneOf/${idx}`;
-					}
-					return {
-						oneOf,
-						discriminator: {
-							propertyName: disc.propertyName,
-							mapping
-						}
-					};
-				}
-				return { anyOf: d.type.items.map(build$1) };
-			},
-			intersection(d) {
-				return { allOf: d.type.items.map(build$1) };
-			},
-			tuple(d) {
-				return {
-					type: "array",
-					items: d.type.items.map(build$1),
-					additionalItems: false
-				};
-			},
-			final(d) {
-				const schema$1 = {};
-				if (d.type.value !== undefined) schema$1.const = d.type.value;
-				if (d.type.designType && d.type.designType !== "any") {
-					schema$1.type = d.type.designType === "undefined" ? "null" : d.type.designType;
-					if (schema$1.type === "number" && meta.get("expect.int")) schema$1.type = "integer";
-				}
-				if (schema$1.type === "string") {
-					if (meta.get("meta.required")) schema$1.minLength = 1;
-					const minLength = meta.get("expect.minLength");
-					if (minLength) schema$1.minLength = typeof minLength === "number" ? minLength : minLength.length;
-					const maxLength = meta.get("expect.maxLength");
-					if (maxLength) schema$1.maxLength = typeof maxLength === "number" ? maxLength : maxLength.length;
-					const patterns = meta.get("expect.pattern");
-					if (patterns?.length) if (patterns.length === 1) schema$1.pattern = patterns[0].pattern;
-else schema$1.allOf = (schema$1.allOf || []).concat(patterns.map((p) => ({ pattern: p.pattern })));
-				}
-				if (schema$1.type === "number" || schema$1.type === "integer") {
-					const min = meta.get("expect.min");
-					if (min) schema$1.minimum = typeof min === "number" ? min : min.minValue;
-					const max = meta.get("expect.max");
-					if (max) schema$1.maximum = typeof max === "number" ? max : max.maxValue;
-				}
-				return schema$1;
-			}
-		});
-	};
-	const schema = build$1(type);
-	if (hasDefs) return {
-		...schema,
-		$defs: defs
-	};
-	return schema;
-}
-function fromJsonSchema(schema) {
-	const defsSource = schema.$defs || schema.definitions || {};
-	const resolved = new Map();
-	const convert = (s) => {
-		if (!s || Object.keys(s).length === 0) return defineAnnotatedType().designType("any").$type;
-		if (s.$ref) {
-			const refName = s.$ref.replace(/^#\/(\$defs|definitions)\//, "");
-			if (resolved.has(refName)) return resolved.get(refName);
-			if (defsSource[refName]) {
-				const placeholder = defineAnnotatedType().designType("any").$type;
-				resolved.set(refName, placeholder);
-				const type = convert(defsSource[refName]);
-				resolved.set(refName, type);
-				return type;
-			}
-			throw new Error(`Unresolvable $ref: ${s.$ref}`);
-		}
-		if ("const" in s) {
-			const val = s.const;
-			const dt = val === null ? "null" : typeof val;
-			return defineAnnotatedType().designType(dt).value(val).$type;
-		}
-		if (s.enum) {
-			const handle = defineAnnotatedType("union");
-			for (const val of s.enum) {
-				const dt = val === null ? "null" : typeof val;
-				handle.item(defineAnnotatedType().designType(dt).value(val).$type);
-			}
-			return handle.$type;
-		}
-		if (s.anyOf) {
-			const handle = defineAnnotatedType("union");
-			for (const item of s.anyOf) handle.item(convert(item));
-			return handle.$type;
-		}
-		if (s.oneOf) {
-			const handle = defineAnnotatedType("union");
-			for (const item of s.oneOf) handle.item(convert(item));
-			return handle.$type;
-		}
-		if (s.allOf && !s.type) {
-			const handle = defineAnnotatedType("intersection");
-			for (const item of s.allOf) handle.item(convert(item));
-			return handle.$type;
-		}
-		if (Array.isArray(s.type)) {
-			const handle = defineAnnotatedType("union");
-			for (const t of s.type) handle.item(convert({
-				...s,
-				type: t
-			}));
-			return handle.$type;
-		}
-		if (s.type === "object") {
-			const handle = defineAnnotatedType("object");
-			const required = new Set(s.required || []);
-			if (s.properties) for (const [key, propSchema] of Object.entries(s.properties)) {
-				const propType = convert(propSchema);
-				if (!required.has(key)) propType.optional = true;
-				handle.prop(key, propType);
-			}
-			return handle.$type;
-		}
-		if (s.type === "array") {
-			if (Array.isArray(s.items)) {
-				const handle$1 = defineAnnotatedType("tuple");
-				for (const item of s.items) handle$1.item(convert(item));
-				return handle$1.$type;
-			}
-			const itemType = s.items ? convert(s.items) : defineAnnotatedType().designType("any").$type;
-			const handle = defineAnnotatedType("array").of(itemType);
-			if (typeof s.minItems === "number") handle.annotate("expect.minLength", { length: s.minItems });
-			if (typeof s.maxItems === "number") handle.annotate("expect.maxLength", { length: s.maxItems });
-			return handle.$type;
-		}
-		if (s.type === "string") {
-			const handle = defineAnnotatedType().designType("string").tags("string");
-			if (typeof s.minLength === "number") handle.annotate("expect.minLength", { length: s.minLength });
-			if (typeof s.maxLength === "number") handle.annotate("expect.maxLength", { length: s.maxLength });
-			if (s.pattern) handle.annotate("expect.pattern", { pattern: s.pattern }, true);
-			if (s.allOf) {
-				for (const item of s.allOf) if (item.pattern) handle.annotate("expect.pattern", { pattern: item.pattern }, true);
-			}
-			return handle.$type;
-		}
-		if (s.type === "integer") {
-			const handle = defineAnnotatedType().designType("number").tags("number");
-			handle.annotate("expect.int", true);
-			if (typeof s.minimum === "number") handle.annotate("expect.min", { minValue: s.minimum });
-			if (typeof s.maximum === "number") handle.annotate("expect.max", { maxValue: s.maximum });
-			return handle.$type;
-		}
-		if (s.type === "number") {
-			const handle = defineAnnotatedType().designType("number").tags("number");
-			if (typeof s.minimum === "number") handle.annotate("expect.min", { minValue: s.minimum });
-			if (typeof s.maximum === "number") handle.annotate("expect.max", { maxValue: s.maximum });
-			return handle.$type;
-		}
-		if (s.type === "boolean") return defineAnnotatedType().designType("boolean").tags("boolean").$type;
-		if (s.type === "null") return defineAnnotatedType().designType("null").tags("null").$type;
-		return defineAnnotatedType().designType("any").$type;
-	};
-	return convert(schema);
-}
-function mergeJsonSchemas(types) {
-	const mergedDefs = {};
-	const schemas = {};
-	for (const type of types) {
-		const name = type.id;
-		if (!name) throw new Error("mergeJsonSchemas: all types must have an id");
-		const schema = buildJsonSchema(type);
-		if (schema.$defs) {
-			for (const [defName, defSchema] of Object.entries(schema.$defs)) if (!mergedDefs[defName]) mergedDefs[defName] = defSchema;
-			const { $defs: _,...rest } = schema;
-			schemas[name] = rest;
-		} else schemas[name] = schema;
-	}
-	return {
-		schemas,
-		$defs: mergedDefs
-	};
-}
-
-//#endregion
 //#region packages/typescript/src/default-value.ts
 /**
 * Attempts to resolve a value from the mode for the given annotated type.
@@ -924,7 +15,7 @@ function mergeJsonSchemas(types) {
 		return undefined;
 	}
 	if (mode === "db") {
-		const dbValue = prop.metadata.get("db.default.value");
+		const dbValue = prop.metadata.get("db.default");
 		if (dbValue !== undefined) {
 			const parsed$1 = parseRawValue(dbValue, prop);
 			if (parsed$1 !== undefined && prop.validator({ unknownProps: "ignore" }).validate(parsed$1, true)) return { value: parsed$1 };
@@ -970,13 +61,13 @@ function createDataFromAnnotatedType(type, opts) {
 function build(def, path, mode) {
 	const resolved = resolveValue(def, path, mode);
 	if (resolved !== undefined) return resolved.value;
-	return forAnnotatedType(def, {
+	return require_json_schema.forAnnotatedType(def, {
 		phantom: () => undefined,
 		final: (d) => finalDefault(d),
 		object: (d) => {
 			const data = {};
 			for (const [key, prop] of d.type.props.entries()) {
-				if (isPhantomType(prop)) continue;
+				if (require_json_schema.isPhantomType(prop)) continue;
 				const childPath = path ? `${path}.${key}` : key;
 				if (prop.optional) {
 					if (mode === "example") data[key] = build(prop, childPath, mode);
@@ -1020,10 +111,11 @@ function throwFeatureDisabled(feature, option, annotation) {
 function flattenAnnotatedType(type, options) {
 	const flatMap = new Map();
 	const skipPhantom = !!options?.excludePhantomTypes;
+	const visitedIds = new Set();
 	function addFieldToFlatMap(name, def) {
 		const existing = flatMap.get(name);
 		if (existing) {
-			const flatUnion = defineAnnotatedType("union").copyMetadata(existing.metadata).copyMetadata(def.metadata);
+			const flatUnion = require_json_schema.defineAnnotatedType("union").copyMetadata(existing.metadata).copyMetadata(def.metadata);
 			if (existing.__flat_union) existing.type.items.forEach((item) => flatUnion.item(item));
 else flatUnion.item(existing);
 			flatUnion.item(def);
@@ -1033,11 +125,20 @@ else flatUnion.item(existing);
 		} else flatMap.set(name, def);
 	}
 	function flattenArray(def, name) {
+		const resolvedId = def.id;
+		if (resolvedId) {
+			if (visitedIds.has(resolvedId)) return;
+			visitedIds.add(resolvedId);
+		}
 		switch (def.type.kind) {
 			case "object": {
+				if (!resolvedId && def.id) {
+					if (visitedIds.has(def.id)) return;
+					visitedIds.add(def.id);
+				}
 				const items = Array.from(def.type.props.entries());
 				for (const [key, value] of items) {
-					if (skipPhantom && isPhantomType(value)) continue;
+					if (skipPhantom && require_json_schema.isPhantomType(value)) continue;
 					flattenType(value, name ? `${name}.${key}` : key, true);
 				}
 				break;
@@ -1056,11 +157,28 @@ else flatUnion.item(existing);
 		}
 	}
 	function flattenType(def, prefix = "", inComplexTypeOrArray = false) {
-		switch (def.type.kind) {
+		let typeId = def.id;
+		if (typeId && visitedIds.has(typeId)) {
+			addFieldToFlatMap(prefix || "", def);
+			if (prefix) options?.onField?.(prefix, def, def.metadata);
+			return;
+		}
+		if (typeId) visitedIds.add(typeId);
+		const kind = def.type.kind;
+		if (!typeId && def.id) {
+			typeId = def.id;
+			if (visitedIds.has(typeId)) {
+				addFieldToFlatMap(prefix || "", def);
+				if (prefix) options?.onField?.(prefix, def, def.metadata);
+				return;
+			}
+			visitedIds.add(typeId);
+		}
+		switch (kind) {
 			case "object": {
 				addFieldToFlatMap(prefix || "", def);
 				for (const [key, value] of def.type.props.entries()) {
-					if (skipPhantom && isPhantomType(value)) continue;
+					if (skipPhantom && require_json_schema.isPhantomType(value)) continue;
 					flattenType(value, prefix ? `${prefix}.${key}` : key, inComplexTypeOrArray);
 				}
 				break;
@@ -1068,12 +186,12 @@ else flatUnion.item(existing);
 			case "array": {
 				let typeArray = def;
 				if (!inComplexTypeOrArray) {
-					typeArray = defineAnnotatedType().refTo(def).copyMetadata(def.metadata).$type;
+					typeArray = require_json_schema.defineAnnotatedType().refTo(def).copyMetadata(def.metadata).$type;
 					if (def.optional) typeArray.optional = def.optional;
 					if (options?.topLevelArrayTag) typeArray.metadata.set(options.topLevelArrayTag, true);
 				}
 				addFieldToFlatMap(prefix || "", typeArray);
-				if (!isAnnotatedTypeOfPrimitive(typeArray.type.of)) flattenArray(typeArray.type.of, prefix);
+				if (!require_json_schema.isAnnotatedTypeOfPrimitive(typeArray.type.of)) flattenArray(typeArray.type.of, prefix);
 				break;
 			}
 			case "intersection":
@@ -1102,21 +220,32 @@ else flatUnion.item(existing);
 //#region packages/typescript/src/serialize.ts
 const SERIALIZE_VERSION = 1;
 function serializeAnnotatedType(type, options) {
-	const result = serializeNode(type, [], options);
+	const visited = new Set();
+	const result = serializeNode(type, [], options, visited);
 	result.$v = SERIALIZE_VERSION;
 	return result;
 }
-function serializeNode(def, path, options) {
+function serializeNode(def, path, options, visited) {
+	if (def.id && visited.has(def.id)) return {
+		type: {
+			kind: "$ref",
+			id: def.id
+		},
+		metadata: {},
+		...def.optional ? { optional: true } : {},
+		id: def.id
+	};
+	if (def.id) visited.add(def.id);
 	const result = {
-		type: serializeTypeDef(def, path, options),
+		type: serializeTypeDef(def, path, options, visited),
 		metadata: serializeMetadata(def.metadata, path, def.type.kind, options)
 	};
 	if (def.optional) result.optional = true;
 	if (def.id) result.id = def.id;
 	return result;
 }
-function serializeTypeDef(def, path, options) {
-	return forAnnotatedType(def, {
+function serializeTypeDef(def, path, options, visited) {
+	return require_json_schema.forAnnotatedType(def, {
 		phantom(d) {
 			return {
 				kind: "",
@@ -1135,13 +264,13 @@ function serializeTypeDef(def, path, options) {
 		},
 		object(d) {
 			const props = {};
-			for (const [key, val] of d.type.props.entries()) props[key] = serializeNode(val, [...path, key], options);
+			for (const [key, val] of d.type.props.entries()) props[key] = serializeNode(val, [...path, key], options, visited);
 			const propsPatterns = d.type.propsPatterns.map((pp) => ({
 				pattern: {
 					source: pp.pattern.source,
 					flags: pp.pattern.flags
 				},
-				def: serializeNode(pp.def, path, options)
+				def: serializeNode(pp.def, path, options, visited)
 			}));
 			return {
 				kind: "object",
@@ -1153,28 +282,28 @@ function serializeTypeDef(def, path, options) {
 		array(d) {
 			return {
 				kind: "array",
-				of: serializeNode(d.type.of, path, options),
+				of: serializeNode(d.type.of, path, options, visited),
 				tags: Array.from(d.type.tags)
 			};
 		},
 		union(d) {
 			return {
 				kind: "union",
-				items: d.type.items.map((item) => serializeNode(item, path, options)),
+				items: d.type.items.map((item) => serializeNode(item, path, options, visited)),
 				tags: Array.from(d.type.tags)
 			};
 		},
 		intersection(d) {
 			return {
 				kind: "intersection",
-				items: d.type.items.map((item) => serializeNode(item, path, options)),
+				items: d.type.items.map((item) => serializeNode(item, path, options, visited)),
 				tags: Array.from(d.type.tags)
 			};
 		},
 		tuple(d) {
 			return {
 				kind: "tuple",
-				items: d.type.items.map((item) => serializeNode(item, path, options)),
+				items: d.type.items.map((item) => serializeNode(item, path, options, visited)),
 				tags: Array.from(d.type.tags)
 			};
 		}
@@ -1207,14 +336,14 @@ function deserializeAnnotatedType(data) {
 function deserializeNode(data) {
 	const metadata = new Map(Object.entries(data.metadata));
 	const type = deserializeTypeDef(data.type);
-	const result = createAnnotatedTypeNode(type, metadata, {
+	const result = require_json_schema.createAnnotatedTypeNode(type, metadata, {
 		optional: data.optional || undefined,
 		id: data.id || undefined
 	});
 	return result;
 }
 function deserializeTypeDef(t) {
-	const tags = new Set(t.tags);
+	const tags = "tags" in t ? new Set(t.tags) : new Set();
 	switch (t.kind) {
 		case "": {
 			const result = {
@@ -1251,27 +380,33 @@ function deserializeTypeDef(t) {
 			items: t.items.map((item) => deserializeNode(item)),
 			tags
 		};
+		case "$ref": return {
+			kind: "object",
+			props: new Map(),
+			propsPatterns: [],
+			tags
+		};
 		default: throw new Error(`Unknown serialized type kind "${t.kind}"`);
 	}
 }
 
 //#endregion
 exports.SERIALIZE_VERSION = SERIALIZE_VERSION
-exports.Validator = Validator
-exports.ValidatorError = ValidatorError
-exports.annotate = annotate
-exports.buildJsonSchema = buildJsonSchema
-exports.cloneRefProp = cloneRefProp
-exports.createAnnotatedTypeNode = createAnnotatedTypeNode
+exports.Validator = require_json_schema.Validator
+exports.ValidatorError = require_json_schema.ValidatorError
+exports.annotate = require_json_schema.annotate
+exports.buildJsonSchema = require_json_schema.buildJsonSchema
+exports.cloneRefProp = require_json_schema.cloneRefProp
+exports.createAnnotatedTypeNode = require_json_schema.createAnnotatedTypeNode
 exports.createDataFromAnnotatedType = createDataFromAnnotatedType
-exports.defineAnnotatedType = defineAnnotatedType
+exports.defineAnnotatedType = require_json_schema.defineAnnotatedType
 exports.deserializeAnnotatedType = deserializeAnnotatedType
 exports.flattenAnnotatedType = flattenAnnotatedType
-exports.forAnnotatedType = forAnnotatedType
-exports.fromJsonSchema = fromJsonSchema
-exports.isAnnotatedType = isAnnotatedType
-exports.isAnnotatedTypeOfPrimitive = isAnnotatedTypeOfPrimitive
-exports.isPhantomType = isPhantomType
-exports.mergeJsonSchemas = mergeJsonSchemas
+exports.forAnnotatedType = require_json_schema.forAnnotatedType
+exports.fromJsonSchema = require_json_schema.fromJsonSchema
+exports.isAnnotatedType = require_json_schema.isAnnotatedType
+exports.isAnnotatedTypeOfPrimitive = require_json_schema.isAnnotatedTypeOfPrimitive
+exports.isPhantomType = require_json_schema.isPhantomType
+exports.mergeJsonSchemas = require_json_schema.mergeJsonSchemas
 exports.serializeAnnotatedType = serializeAnnotatedType
 exports.throwFeatureDisabled = throwFeatureDisabled