@atscript/typescript 0.1.25 → 0.1.27

package/dist/utils.cjs

@@ -428,6 +428,63 @@ 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, {
+		__is_atscript_annotated_type: true,
+		type: clonedType,
+		metadata: new Map(existing.metadata),
+		id: existing.id,
+		optional: existing.optional,
+		validator(opts) {
+			return new Validator(this, opts);
+		}
+	});
+}
+function cloneTypeDef(type) {
+	if (type.kind === "object") {
+		const obj = type;
+		return {
+			kind: "object",
+			props: new Map(Array.from(obj.props.entries()).map(([k, v]) => [k, {
+				__is_atscript_annotated_type: true,
+				type: v.type,
+				metadata: new Map(v.metadata),
+				id: v.id,
+				optional: v.optional,
+				validator(opts) {
+					return new Validator(this, opts);
+				}
+			}])),
+			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 || {};
@@ -519,6 +576,7 @@ else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
 					__is_atscript_annotated_type: true,
 					type: newBase.type,
 					metadata,
+					id: newBase.id,
 					validator(opts) {
 						return new Validator(this, opts);
 					}
@@ -529,6 +587,10 @@ else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
 		annotate(key, value, asArray) {
 			annotate(this.$metadata, key, value, asArray);
 			return this;
+		},
+		id(value) {
+			this.$type.id = value;
+			return this;
 		}
 	};
 	return handle;
@@ -593,47 +655,71 @@ function isAnnotatedTypeOfPrimitive(t) {
 	return null;
 }
 function buildJsonSchema(type) {
+	const defs = {};
+	let isRoot = true;
+	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" && !isRoot) {
+			const name = def.id;
+			if (!defs[name]) {
+				defs[name] = {};
+				defs[name] = buildObject(def);
+			}
+			return { $ref: `#/$defs/${name}` };
+		}
+		isRoot = false;
 		const meta = def.metadata;
 		return forAnnotatedType(def, {
 			phantom() {
 				return {};
 			},
 			object(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 = {
-					type: "object",
-					properties
-				};
-				if (required.length > 0) schema.required = required;
-				return schema;
+				return buildObject(d);
 			},
 			array(d) {
-				const schema = {
+				const schema$1 = {
 					type: "array",
 					items: build$1(d.type.of)
 				};
 				const minLength = meta.get("expect.minLength");
-				if (minLength) schema.minItems = typeof minLength === "number" ? minLength : minLength.length;
+				if (minLength) schema$1.minItems = typeof minLength === "number" ? minLength : minLength.length;
 				const maxLength = meta.get("expect.maxLength");
-				if (maxLength) schema.maxItems = typeof maxLength === "number" ? maxLength : maxLength.length;
-				return schema;
+				if (maxLength) schema$1.maxItems = typeof maxLength === "number" ? maxLength : maxLength.length;
+				return schema$1;
 			},
 			union(d) {
 				const disc = detectDiscriminator(d.type.items);
-				if (disc) return {
-					oneOf: d.type.items.map(build$1),
-					discriminator: {
-						propertyName: disc.propertyName,
-						mapping: disc.mapping
+				if (disc) {
+					const oneOf = d.type.items.map(build$1);
+					const mapping = {};
+					for (const [val, origPath] of Object.entries(disc.mapping)) {
+						const idx = Number.parseInt(origPath.split("/").pop(), 10);
+						const item = d.type.items[idx];
+						if (item.id && defs[item.id]) mapping[val] = `#/$defs/${item.id}`;
+else mapping[val] = origPath;
 					}
-				};
+					return {
+						oneOf,
+						discriminator: {
+							propertyName: disc.propertyName,
+							mapping
+						}
+					};
+				}
 				return { anyOf: d.type.items.map(build$1) };
 			},
 			intersection(d) {
@@ -647,38 +733,54 @@ function buildJsonSchema(type) {
 				};
 			},
 			final(d) {
-				const schema = {};
-				if (d.type.value !== undefined) schema.const = d.type.value;
+				const schema$1 = {};
+				if (d.type.value !== undefined) schema$1.const = d.type.value;
 				if (d.type.designType && d.type.designType !== "any") {
-					schema.type = d.type.designType === "undefined" ? "null" : d.type.designType;
-					if (schema.type === "number" && meta.get("expect.int")) schema.type = "integer";
+					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.type === "string") {
-					if (meta.get("meta.required")) schema.minLength = 1;
+				if (schema$1.type === "string") {
+					if (meta.get("meta.required")) schema$1.minLength = 1;
 					const minLength = meta.get("expect.minLength");
-					if (minLength) schema.minLength = typeof minLength === "number" ? minLength : minLength.length;
+					if (minLength) schema$1.minLength = typeof minLength === "number" ? minLength : minLength.length;
 					const maxLength = meta.get("expect.maxLength");
-					if (maxLength) schema.maxLength = typeof maxLength === "number" ? maxLength : maxLength.length;
+					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.pattern = patterns[0].pattern;
-else schema.allOf = (schema.allOf || []).concat(patterns.map((p) => ({ pattern: p.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.type === "number" || schema.type === "integer") {
+				if (schema$1.type === "number" || schema$1.type === "integer") {
 					const min = meta.get("expect.min");
-					if (min) schema.minimum = typeof min === "number" ? min : min.minValue;
+					if (min) schema$1.minimum = typeof min === "number" ? min : min.minValue;
 					const max = meta.get("expect.max");
-					if (max) schema.maximum = typeof max === "number" ? max : max.maxValue;
+					if (max) schema$1.maximum = typeof max === "number" ? max : max.maxValue;
 				}
-				return schema;
+				return schema$1;
 			}
 		});
 	};
-	return build$1(type);
+	const schema = build$1(type);
+	if (Object.keys(defs).length > 0) 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) throw new Error("$ref is not supported by fromJsonSchema. Dereference the schema first.");
+		if (s.$ref) {
+			const refName = s.$ref.replace(/^#\/(\$defs|definitions)\//, "");
+			if (resolved.has(refName)) return resolved.get(refName);
+			if (defsSource[refName]) {
+				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;
@@ -766,6 +868,24 @@ function fromJsonSchema(schema) {
 	};
 	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
@@ -959,6 +1079,7 @@ function serializeNode(def, path, options) {
 		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) {
@@ -1062,6 +1183,7 @@ function deserializeNode(data) {
 		}
 	};
 	if (data.optional) result.optional = true;
+	if (data.id) result.id = data.id;
 	return result;
 }
 function deserializeTypeDef(t) {
@@ -1112,6 +1234,7 @@ exports.Validator = Validator
 exports.ValidatorError = ValidatorError
 exports.annotate = annotate
 exports.buildJsonSchema = buildJsonSchema
+exports.cloneRefProp = cloneRefProp
 exports.createDataFromAnnotatedType = createDataFromAnnotatedType
 exports.defineAnnotatedType = defineAnnotatedType
 exports.deserializeAnnotatedType = deserializeAnnotatedType
@@ -1121,5 +1244,6 @@ exports.fromJsonSchema = fromJsonSchema
 exports.isAnnotatedType = isAnnotatedType
 exports.isAnnotatedTypeOfPrimitive = isAnnotatedTypeOfPrimitive
 exports.isPhantomType = isPhantomType
+exports.mergeJsonSchemas = mergeJsonSchemas
 exports.serializeAnnotatedType = serializeAnnotatedType
 exports.throwFeatureDisabled = throwFeatureDisabled

package/dist/utils.d.ts

@@ -181,6 +181,7 @@ interface TAtscriptAnnotatedType<T extends TAtscriptTypeDef = TAtscriptTypeDef,
     validator(opts?: Partial<TValidatorOptions>): Validator<this, DataType>;
     metadata: TMetadataMap<AtscriptMetadata>;
     optional?: boolean;
+    id?: string;
 }
 /** An annotated type that is also a class constructor (i.e. a generated interface class). */
 type TAtscriptAnnotatedTypeConstructor = TAtscriptAnnotatedType & (new (...args: any[]) => any);
@@ -193,6 +194,11 @@ declare function isAnnotatedType(type: any): type is TAtscriptAnnotatedType;
  * Used by the handle's .annotate() method and by generated mutation statements.
  */
 declare function annotate<K extends keyof AtscriptMetadata>(metadata: TMetadataMap<AtscriptMetadata> | undefined, key: K, value: AtscriptMetadata[K] extends Array<infer E> ? E : AtscriptMetadata[K], asArray?: boolean): void;
+/**
+ * Clones a property's type tree in-place so mutations don't leak to shared refs.
+ * Used by mutating annotate codegen when paths cross ref boundaries.
+ */
+declare function cloneRefProp(parentType: TAtscriptTypeDef, propName: string): void;
 type TKind = '' | 'array' | 'object' | 'union' | 'intersection' | 'tuple';
 /**
  * Creates a builder handle for constructing a {@link TAtscriptAnnotatedType} at runtime.
@@ -242,6 +248,7 @@ interface TAnnotatedTypeHandle {
         name?: string;
     }, chain?: string[]): TAnnotatedTypeHandle;
     annotate(key: keyof AtscriptMetadata, value: any, asArray?: boolean): TAnnotatedTypeHandle;
+    id(value: string): TAnnotatedTypeHandle;
 }
 /**
  * Checks whether an annotated type is a phantom type.
@@ -299,6 +306,20 @@ declare function buildJsonSchema(type: TAtscriptAnnotatedType): TJsonSchema;
  * @returns An annotated type with full validator support.
  */
 declare function fromJsonSchema(schema: TJsonSchema): TAtscriptAnnotatedType;
+/**
+ * Merges multiple annotated types into a combined schema map with shared `$defs`.
+ *
+ * Each type must have an `id`. The returned `schemas` object contains individual
+ * schemas keyed by type id, and `$defs` contains all shared type definitions
+ * deduplicated across schemas.
+ *
+ * @param types - Array of annotated types, each with an `id`.
+ * @returns An object with `schemas` (keyed by id) and shared `$defs`.
+ */
+declare function mergeJsonSchemas(types: TAtscriptAnnotatedType[]): {
+    schemas: Record<string, TJsonSchema>;
+    $defs: Record<string, TJsonSchema>;
+};
 
 /**
  * Type-safe dispatch over `TAtscriptAnnotatedType` by its `type.kind`.
@@ -417,6 +438,7 @@ interface TSerializedAnnotatedTypeInner {
     type: TSerializedTypeDef;
     metadata: Record<string, unknown>;
     optional?: boolean;
+    id?: string;
 }
 interface TSerializedTypeFinal {
     kind: '';
@@ -511,5 +533,5 @@ declare function serializeAnnotatedType(type: TAtscriptAnnotatedType, options?:
  */
 declare function deserializeAnnotatedType(data: TSerializedAnnotatedType): TAtscriptAnnotatedType;
 
-export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, serializeAnnotatedType, throwFeatureDisabled };
-export type { InferDataType, TAnnotatedTypeHandle, TAtscriptAnnotatedType, TAtscriptAnnotatedTypeConstructor, TAtscriptDataType, TAtscriptTypeArray, TAtscriptTypeComplex, TAtscriptTypeDef, TAtscriptTypeFinal, TAtscriptTypeObject, TCreateDataOptions, TFlattenOptions, TMetadataMap, TProcessAnnotationContext, TSerializeOptions, TSerializedAnnotatedType, TSerializedAnnotatedTypeInner, TSerializedTypeArray, TSerializedTypeComplex, TSerializedTypeDef, TSerializedTypeFinal, TSerializedTypeObject, TValidatorOptions, TValidatorPlugin, TValidatorPluginContext, TValueResolver };
+export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };
+export type { InferDataType, TAnnotatedTypeHandle, TAtscriptAnnotatedType, TAtscriptAnnotatedTypeConstructor, TAtscriptDataType, TAtscriptTypeArray, TAtscriptTypeComplex, TAtscriptTypeDef, TAtscriptTypeFinal, TAtscriptTypeObject, TCreateDataOptions, TFlattenOptions, TJsonSchema, TMetadataMap, TProcessAnnotationContext, TSerializeOptions, TSerializedAnnotatedType, TSerializedAnnotatedTypeInner, TSerializedTypeArray, TSerializedTypeComplex, TSerializedTypeDef, TSerializedTypeFinal, TSerializedTypeObject, TValidatorOptions, TValidatorPlugin, TValidatorPluginContext, TValueResolver };

package/dist/utils.mjs

@@ -427,6 +427,63 @@ 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, {
+		__is_atscript_annotated_type: true,
+		type: clonedType,
+		metadata: new Map(existing.metadata),
+		id: existing.id,
+		optional: existing.optional,
+		validator(opts) {
+			return new Validator(this, opts);
+		}
+	});
+}
+function cloneTypeDef(type) {
+	if (type.kind === "object") {
+		const obj = type;
+		return {
+			kind: "object",
+			props: new Map(Array.from(obj.props.entries()).map(([k, v]) => [k, {
+				__is_atscript_annotated_type: true,
+				type: v.type,
+				metadata: new Map(v.metadata),
+				id: v.id,
+				optional: v.optional,
+				validator(opts) {
+					return new Validator(this, opts);
+				}
+			}])),
+			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 || {};
@@ -518,6 +575,7 @@ else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
 					__is_atscript_annotated_type: true,
 					type: newBase.type,
 					metadata,
+					id: newBase.id,
 					validator(opts) {
 						return new Validator(this, opts);
 					}
@@ -528,6 +586,10 @@ else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
 		annotate(key, value, asArray) {
 			annotate(this.$metadata, key, value, asArray);
 			return this;
+		},
+		id(value) {
+			this.$type.id = value;
+			return this;
 		}
 	};
 	return handle;
@@ -592,47 +654,71 @@ function isAnnotatedTypeOfPrimitive(t) {
 	return null;
 }
 function buildJsonSchema(type) {
+	const defs = {};
+	let isRoot = true;
+	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" && !isRoot) {
+			const name = def.id;
+			if (!defs[name]) {
+				defs[name] = {};
+				defs[name] = buildObject(def);
+			}
+			return { $ref: `#/$defs/${name}` };
+		}
+		isRoot = false;
 		const meta = def.metadata;
 		return forAnnotatedType(def, {
 			phantom() {
 				return {};
 			},
 			object(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 = {
-					type: "object",
-					properties
-				};
-				if (required.length > 0) schema.required = required;
-				return schema;
+				return buildObject(d);
 			},
 			array(d) {
-				const schema = {
+				const schema$1 = {
 					type: "array",
 					items: build$1(d.type.of)
 				};
 				const minLength = meta.get("expect.minLength");
-				if (minLength) schema.minItems = typeof minLength === "number" ? minLength : minLength.length;
+				if (minLength) schema$1.minItems = typeof minLength === "number" ? minLength : minLength.length;
 				const maxLength = meta.get("expect.maxLength");
-				if (maxLength) schema.maxItems = typeof maxLength === "number" ? maxLength : maxLength.length;
-				return schema;
+				if (maxLength) schema$1.maxItems = typeof maxLength === "number" ? maxLength : maxLength.length;
+				return schema$1;
 			},
 			union(d) {
 				const disc = detectDiscriminator(d.type.items);
-				if (disc) return {
-					oneOf: d.type.items.map(build$1),
-					discriminator: {
-						propertyName: disc.propertyName,
-						mapping: disc.mapping
+				if (disc) {
+					const oneOf = d.type.items.map(build$1);
+					const mapping = {};
+					for (const [val, origPath] of Object.entries(disc.mapping)) {
+						const idx = Number.parseInt(origPath.split("/").pop(), 10);
+						const item = d.type.items[idx];
+						if (item.id && defs[item.id]) mapping[val] = `#/$defs/${item.id}`;
+else mapping[val] = origPath;
 					}
-				};
+					return {
+						oneOf,
+						discriminator: {
+							propertyName: disc.propertyName,
+							mapping
+						}
+					};
+				}
 				return { anyOf: d.type.items.map(build$1) };
 			},
 			intersection(d) {
@@ -646,38 +732,54 @@ function buildJsonSchema(type) {
 				};
 			},
 			final(d) {
-				const schema = {};
-				if (d.type.value !== undefined) schema.const = d.type.value;
+				const schema$1 = {};
+				if (d.type.value !== undefined) schema$1.const = d.type.value;
 				if (d.type.designType && d.type.designType !== "any") {
-					schema.type = d.type.designType === "undefined" ? "null" : d.type.designType;
-					if (schema.type === "number" && meta.get("expect.int")) schema.type = "integer";
+					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.type === "string") {
-					if (meta.get("meta.required")) schema.minLength = 1;
+				if (schema$1.type === "string") {
+					if (meta.get("meta.required")) schema$1.minLength = 1;
 					const minLength = meta.get("expect.minLength");
-					if (minLength) schema.minLength = typeof minLength === "number" ? minLength : minLength.length;
+					if (minLength) schema$1.minLength = typeof minLength === "number" ? minLength : minLength.length;
 					const maxLength = meta.get("expect.maxLength");
-					if (maxLength) schema.maxLength = typeof maxLength === "number" ? maxLength : maxLength.length;
+					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.pattern = patterns[0].pattern;
-else schema.allOf = (schema.allOf || []).concat(patterns.map((p) => ({ pattern: p.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.type === "number" || schema.type === "integer") {
+				if (schema$1.type === "number" || schema$1.type === "integer") {
 					const min = meta.get("expect.min");
-					if (min) schema.minimum = typeof min === "number" ? min : min.minValue;
+					if (min) schema$1.minimum = typeof min === "number" ? min : min.minValue;
 					const max = meta.get("expect.max");
-					if (max) schema.maximum = typeof max === "number" ? max : max.maxValue;
+					if (max) schema$1.maximum = typeof max === "number" ? max : max.maxValue;
 				}
-				return schema;
+				return schema$1;
 			}
 		});
 	};
-	return build$1(type);
+	const schema = build$1(type);
+	if (Object.keys(defs).length > 0) 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) throw new Error("$ref is not supported by fromJsonSchema. Dereference the schema first.");
+		if (s.$ref) {
+			const refName = s.$ref.replace(/^#\/(\$defs|definitions)\//, "");
+			if (resolved.has(refName)) return resolved.get(refName);
+			if (defsSource[refName]) {
+				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;
@@ -765,6 +867,24 @@ function fromJsonSchema(schema) {
 	};
 	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
@@ -958,6 +1078,7 @@ function serializeNode(def, path, options) {
 		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) {
@@ -1061,6 +1182,7 @@ function deserializeNode(data) {
 		}
 	};
 	if (data.optional) result.optional = true;
+	if (data.id) result.id = data.id;
 	return result;
 }
 function deserializeTypeDef(t) {
@@ -1106,4 +1228,4 @@ function deserializeTypeDef(t) {
 }
 
 //#endregion
-export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, serializeAnnotatedType, throwFeatureDisabled };
+export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };