@atscript/typescript 0.1.88 → 0.1.89

package/dist/index.cjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-const require_plugin = require('./plugin-CZ5g5D9I.cjs');
-require('./json-schema-3mti4G4J.cjs');
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_plugin = require('./plugin-DMBkdYCf.cjs');
 
-exports.default = require_plugin.tsPlugin
-exports.tsPlugin = require_plugin.tsPlugin
+exports.default = require_plugin.tsPlugin;
+exports.tsPlugin = require_plugin.tsPlugin;

package/dist/index.mjs

@@ -1,4 +1,3 @@
-import { tsPlugin } from "./plugin-CYzZm3rk.mjs";
-import "./json-schema-B64qclVa.mjs";
+import { t as tsPlugin } from "./plugin-BOoquMkD.mjs";
 
 export { tsPlugin as default, tsPlugin };

package/dist/{json-schema-3mti4G4J.cjs → json-schema-DXEiCfe1.cjs}

@@ -1,4 +1,3 @@
-"use strict";
 
 //#region packages/typescript/src/runtime/validator.ts
 function _define_property(obj, key, value) {
@@ -8,11 +7,31 @@ function _define_property(obj, key, value) {
 		configurable: true,
 		writable: true
 	});
-else obj[key] = value;
+	else obj[key] = value;
 	return obj;
 }
-const regexCache = new Map();
-var Validator = class {
+const regexCache = /* @__PURE__ */ new Map();
+/**
+* Validates values against an {@link TAtscriptAnnotatedType} definition.
+*
+* `DataType` is automatically inferred from the type definition's phantom generic,
+* enabling the {@link validate} method to act as a type guard.
+*
+* @example
+* ```ts
+* // From a generated interface class:
+* const validator = new Validator(MyInterface)
+* if (validator.validate(data, true)) {
+*   data // narrowed to MyInterface
+* }
+*
+* // Or use the built-in factory:
+* MyInterface.validator().validate(data)
+* ```
+*
+* @typeParam T - The annotated type definition.
+* @typeParam DataType - The TypeScript type that `validate` narrows to (auto-inferred).
+*/ var Validator = class {
 	buildPath() {
 		if (this.depth <= 0) return "";
 		let path = this.pathSegments[0];
@@ -27,7 +46,7 @@ var Validator = class {
 	pop(saveErrors) {
 		this.depth--;
 		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);
+		if (saveErrors && popped !== null && popped !== void 0 && popped.length > 0) for (const err of popped) this.error(err.message, err.path, err.details);
 		return popped;
 	}
 	clear() {
@@ -68,7 +87,7 @@ var Validator = class {
 		this.limitExceeded = false;
 		this.context = context;
 		const passed = this.validateSafe(this.def, value);
-		this.context = undefined;
+		this.context = void 0;
 		if (!passed) {
 			if (safe) return false;
 			this.throw();
@@ -79,13 +98,13 @@ var Validator = class {
 		if (this.limitExceeded) return false;
 		if (this.hasReplace) {
 			let replaced = this.replaceCache.get(def);
-			if (replaced === undefined) {
+			if (replaced === void 0) {
 				replaced = this.opts.replace(def, this.buildPath());
 				this.replaceCache.set(def, replaced);
 			}
 			def = replaced;
 		}
-		if (def.optional && (value === undefined || value === null)) return true;
+		if (def.optional && (value === void 0 || value === null)) return true;
 		if (this.hasPlugins) for (const plugin of this.opts.plugins) {
 			const result = plugin(this, def, value);
 			if (result === false || result === true) return result;
@@ -97,10 +116,9 @@ var Validator = class {
 	}
 	validateAnnotatedType(def, value) {
 		switch (def.type.kind) {
-			case "": {
+			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);
@@ -121,10 +139,10 @@ var Validator = class {
 			const branchErrors = this.stackErrors.pop();
 			if (this.limitExceeded) this.limitExceeded = false;
 			if (branchErrors) if (details) for (const err of branchErrors) details.push(err);
-else details = branchErrors;
+			else details = branchErrors;
 		}
 		const expected = items.map((item, i) => `[${item.type.kind || item.type.designType}(${i})]`).join(", ");
-		this.error(`Value does not match any of the allowed types: ${expected}`, undefined, details);
+		this.error(`Value does not match any of the allowed types: ${expected}`, void 0, details);
 		return false;
 	}
 	validateIntersection(def, value) {
@@ -174,8 +192,8 @@ else details = branchErrors;
 		const uniqueItems = def.metadata.get("expect.array.uniqueItems");
 		if (uniqueItems) {
 			const separator = "▼↩";
-			const seen = new Set();
-			const keyProps = new Set();
+			const seen = /* @__PURE__ */ new Set();
+			const keyProps = /* @__PURE__ */ 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);
 			}
@@ -220,7 +238,7 @@ else details = branchErrors;
 			const path = this.depth > 0 ? `${this.buildPath()}.` : "";
 			for (const item of this.opts.skipList) if (item.startsWith(path)) {
 				const key = item.slice(path.length);
-				if (!skipList) skipList = new Set();
+				if (!skipList) skipList = /* @__PURE__ */ new Set();
 				skipList.add(key);
 			}
 		}
@@ -228,12 +246,12 @@ else details = branchErrors;
 		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.buildPath());
 		for (const [key, item] of def.type.props.entries()) {
 			if (skipList && skipList.has(key) || isPhantomType(item)) continue;
-			if (value[key] === undefined) {
+			if (value[key] === void 0) {
 				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.depth === 0) continue;
 			}
 			this.push(key);
 			if (this.validateSafe(item, value[key])) this.pop(false);
-else {
+			else {
 				passed = false;
 				this.pop(true);
 				if (this.limitExceeded) return false;
@@ -283,7 +301,7 @@ else {
 		return passed;
 	}
 	validatePrimitive(def, value) {
-		if (def.type.value !== undefined) {
+		if (def.type.value !== void 0) {
 			if (value !== def.type.value) {
 				this.error(`Expected ${def.type.value}, got ${value}`);
 				return false;
@@ -292,47 +310,41 @@ else {
 		}
 		const typeOfValue = Array.isArray(value) ? "array" : typeof value;
 		switch (def.type.designType) {
-			case "never": {
+			case "never":
 				this.error(`This type is impossible, must be an internal problem`);
 				return false;
-			}
 			case "any": return true;
-			case "string": {
+			case "string":
 				if (typeOfValue !== def.type.designType) {
 					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
 					return false;
 				}
 				return this.validateString(def, value);
-			}
-			case "number": {
+			case "number":
 				if (typeOfValue !== def.type.designType) {
 					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
 					return false;
 				}
 				return this.validateNumber(def, value);
-			}
-			case "boolean": {
+			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) {
+			case "undefined":
+				if (value !== void 0) {
 					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
 					return false;
 				}
 				return true;
-			}
-			case "null": {
+			case "null":
 				if (value !== null) {
 					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
 					return false;
 				}
 				return true;
-			}
-			case "decimal": {
+			case "decimal":
 				if (typeOfValue !== "string") {
 					this.error(`Expected string (decimal), got ${typeOfValue}`);
 					return false;
@@ -342,7 +354,6 @@ else {
 					return false;
 				}
 				return true;
-			}
 			default: throw new Error(`Unknown type "${def.type.designType}"`);
 		}
 	}
@@ -457,10 +468,10 @@ else {
 		};
 		this.hasPlugins = this.opts.plugins.length > 0;
 		this.hasReplace = typeof this.opts.replace === "function";
-		if (this.hasReplace) this.replaceCache = new WeakMap();
+		if (this.hasReplace) this.replaceCache = /* @__PURE__ */ new WeakMap();
 	}
 };
-var ValidatorError = class extends Error {
+/** Error thrown by {@link Validator.validate} when validation fails. Contains structured error details. */ 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";
 	}
@@ -477,7 +488,10 @@ 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) {
+/**
+* Creates a minimal annotated type node from a type def and metadata map.
+* Centralises the shape so callers never duplicate the boilerplate.
+*/ function createAnnotatedTypeNode(type, metadata, opts) {
 	return {
 		__is_atscript_annotated_type: true,
 		type,
@@ -488,19 +502,27 @@ function createAnnotatedTypeNode(type, metadata, opts) {
 		ref: opts?.ref
 	};
 }
-function isAnnotatedType(type) {
+/**
+* Type Guard to check if a type is atscript-annotated
+*/ function isAnnotatedType(type) {
 	return type && type.__is_atscript_annotated_type;
 }
-function annotate(metadata, key, value, asArray) {
+/**
+* Standalone annotate function that handles both replace and append (array) strategies.
+* Used by the handle's .annotate() method and by generated mutation statements.
+*/ 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, [a, value]);
 	} else metadata.set(key, [value]);
-else metadata.set(key, value);
+	else metadata.set(key, value);
 }
-function cloneRefProp(parentType, propName) {
+/**
+* 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.
+*/ function cloneRefProp(parentType, propName) {
 	if (parentType.kind !== "object") return;
 	const objType = parentType;
 	const existing = objType.props.get(propName);
@@ -514,7 +536,7 @@ function cloneRefProp(parentType, propName) {
 function cloneTypeDef(type) {
 	if (type.kind === "object") {
 		const obj = type;
-		const props = new Map();
+		const props = /* @__PURE__ */ 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
@@ -547,18 +569,36 @@ function cloneTypeDef(type) {
 		tags: new Set(type.tags)
 	};
 }
-function defineAnnotatedType(_kind, base) {
+/**
+* Creates a builder handle for constructing a {@link TAtscriptAnnotatedType} at runtime.
+*
+* This is primarily used by generated `.as.js` code. The returned handle provides
+* a fluent API for setting the type definition, metadata, and properties.
+*
+* @example
+* ```ts
+* const handle = defineAnnotatedType('object')
+*   .prop('name', defineAnnotatedType().designType('string').$type)
+*   .prop('age', defineAnnotatedType().designType('number').$type)
+*
+* handle.$type // the resulting TAtscriptAnnotatedType
+* ```
+*
+* @param _kind - The kind of type to create (e.g. `'object'`, `'array'`, `'union'`). Defaults to `''` (primitive/final).
+* @param base - Optional existing object to augment with annotated type fields.
+* @returns A builder handle for fluent type construction.
+*/ function defineAnnotatedType(_kind, base) {
 	const kind = _kind || "";
-	const baseProvided = base !== undefined;
+	const baseProvided = base !== void 0;
 	const type = base?.type || {};
 	type.kind = kind;
 	if (COMPLEX_KINDS.has(kind)) type.items = [];
 	if (kind === "object") {
-		type.props = new Map();
+		type.props = /* @__PURE__ */ new Map();
 		type.propsPatterns = [];
 	}
-	type.tags = new Set();
-	const metadata = base?.metadata || new Map();
+	type.tags = /* @__PURE__ */ new Set();
+	const metadata = base?.metadata || /* @__PURE__ */ new Map();
 	const payload = {
 		__is_atscript_annotated_type: true,
 		metadata,
@@ -566,7 +606,7 @@ function defineAnnotatedType(_kind, base) {
 		validator: validatorMethod
 	};
 	base = base ? Object.assign(base, payload) : payload;
-	const handle = {
+	return {
 		$type: base,
 		$def: type,
 		$metadata: metadata,
@@ -609,15 +649,15 @@ function defineAnnotatedType(_kind, base) {
 			for (const [key, value] of fromMetadata.entries()) if (!ignore || !ignore.has(key)) this.$metadata.set(key, value);
 			return this;
 		},
-		refTo(type$1, chain) {
+		refTo(type, chain) {
 			const node = this.$type;
-			if (isAnnotatedType(type$1)) {
-				let newBase = type$1;
-				const typeName = type$1.name || "Unknown";
+			if (isAnnotatedType(type)) {
+				let newBase = type;
+				const typeName = type.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 {
+					else {
 						const keys = chain.slice(0, i + 1).map((k) => `["${k}"]`).join("");
 						throw new Error(`Can't find prop ${typeName}${keys}`);
 					}
@@ -625,11 +665,11 @@ else {
 				node.type = baseProvided ? cloneTypeDef(newBase.type) : newBase.type;
 				node.id = node.id ?? newBase.id;
 				if (chain && chain.length > 0) node.ref = {
-					type: () => type$1,
+					type: () => type,
 					field: chain.join(".")
 				};
-			} else if (typeof type$1 === "function") {
-				const lazyType = type$1;
+			} else if (typeof type === "function") {
+				const lazyType = type;
 				const ownId = node.id;
 				node.ref = {
 					type: lazyType,
@@ -649,7 +689,7 @@ else {
 						}
 						let target = t;
 						if (chain) for (const c of chain) if (target.type.kind === "object" && target.type.props.has(c)) target = target.type.props.get(c);
-else return t.type;
+						else return t.type;
 						node.id = ownId ?? target.id;
 						const resolved = baseProvided ? cloneTypeDef(target.type) : target.type;
 						Object.defineProperty(node, "type", {
@@ -661,7 +701,7 @@ else return t.type;
 					},
 					configurable: true
 				});
-			} else throw new TypeError(`${type$1} is not annotated type`);
+			} else throw new TypeError(`${type} is not annotated type`);
 			return this;
 		},
 		annotate(key, value, asArray) {
@@ -673,12 +713,21 @@ else return t.type;
 			return this;
 		}
 	};
-	return handle;
 }
-function isPhantomType(def) {
+/**
+* Checks whether an annotated type is a phantom type.
+*
+* Phantom types do not affect the data type, validation, or schema,
+* but are discoverable via runtime type traversal.
+*/ function isPhantomType(def) {
 	return def.type.kind === "" && def.type.designType === "phantom";
 }
-function isAnnotatedTypeOfPrimitive(t) {
+/**
+* Checks whether an annotated type resolves to a primitive (non-object, non-array) shape.
+*
+* Returns `true` for final types and for unions/intersections/tuples
+* whose members are all primitives.
+*/ 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)) {
@@ -690,7 +739,17 @@ function isAnnotatedTypeOfPrimitive(t) {
 
 //#endregion
 //#region packages/typescript/src/runtime/traverse.ts
-function forAnnotatedType(def, handlers) {
+/**
+* Type-safe dispatch over `TAtscriptAnnotatedType` by its `type.kind`.
+*
+* Provides the common `switch (def.type.kind)` pattern used by
+* the validator, JSON-schema builder, and serializer.
+* Each caller supplies its own handlers that control recursion.
+*
+* When a `phantom` handler is provided, phantom types (`designType === 'phantom'`)
+* are dispatched to it instead of `final`. This allows consumers to skip or
+* handle phantom props without polluting their `final` handler.
+*/ function forAnnotatedType(def, handlers) {
 	switch (def.type.kind) {
 		case "": {
 			const typed = def;
@@ -708,21 +767,27 @@ function forAnnotatedType(def, handlers) {
 
 //#endregion
 //#region packages/typescript/src/runtime/json-schema.ts
-function detectDiscriminator(items) {
+/**
+* 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. Returns `null` when no qualifying
+* property exists, or when more than one does (ambiguous).
+*/ 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);
+	for (const [propName, propType] of firstObj.props.entries()) if (propType.type.kind === "" && propType.type.value !== void 0) candidates.push(propName);
 	let result = null;
 	for (const candidate of candidates) {
-		const values = new Set();
+		const values = /* @__PURE__ */ 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) {
+			const prop = items[i].type.props.get(candidate);
+			if (!prop || prop.type.kind !== "" || prop.type.value === void 0) {
 				valid = false;
 				break;
 			}
@@ -744,7 +809,23 @@ function detectDiscriminator(items) {
 	}
 	return result;
 }
-function buildJsonSchema(type) {
+/**
+* Builds a JSON Schema from an {@link TAtscriptAnnotatedType}.
+*
+* Translates the atscript type structure and validation metadata
+* (min/max, patterns, integer constraints, etc.) into a standard JSON Schema.
+*
+* @example
+* ```ts
+* import { buildJsonSchema } from '@atscript/typescript'
+*
+* const schema = buildJsonSchema(MyInterface)
+* // { type: 'object', properties: { ... }, required: [...] }
+* ```
+*
+* @param type - The annotated type to convert.
+* @returns A JSON Schema object.
+*/ function buildJsonSchema(type) {
 	const defs = {};
 	let hasDefs = false;
 	const buildObject = (d) => {
@@ -755,12 +836,12 @@ function buildJsonSchema(type) {
 			properties[key] = build(val);
 			if (!val.optional) required.push(key);
 		}
-		const schema$1 = {
+		const schema = {
 			type: "object",
 			properties
 		};
-		if (required.length > 0) schema$1.required = required;
-		return schema$1;
+		if (required.length > 0) schema.required = required;
+		return schema;
 	};
 	const build = (def) => {
 		if (def.id && def.type.kind === "object" && def !== type) {
@@ -781,15 +862,15 @@ function buildJsonSchema(type) {
 				return buildObject(d);
 			},
 			array(d) {
-				const schema$1 = {
+				const schema = {
 					type: "array",
 					items: build(d.type.of)
 				};
 				const minLength = meta.get("expect.minLength");
-				if (minLength) schema$1.minItems = typeof minLength === "number" ? minLength : minLength.length;
+				if (minLength) schema.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;
+				if (maxLength) schema.maxItems = typeof maxLength === "number" ? maxLength : maxLength.length;
+				return schema;
 			},
 			union(d) {
 				const disc = detectDiscriminator(d.type.items);
@@ -821,30 +902,30 @@ function buildJsonSchema(type) {
 				};
 			},
 			final(d) {
-				const schema$1 = {};
-				if (d.type.value !== undefined) schema$1.const = d.type.value;
+				const schema = {};
+				if (d.type.value !== void 0) schema.const = d.type.value;
 				if (d.type.designType && d.type.designType !== "any") {
 					const dt = d.type.designType;
-					schema$1.type = dt === "undefined" ? "null" : dt === "decimal" ? "string" : dt;
-					if (schema$1.type === "number" && meta.get("expect.int")) schema$1.type = "integer";
+					schema.type = dt === "undefined" ? "null" : dt === "decimal" ? "string" : dt;
+					if (schema.type === "number" && meta.get("expect.int")) schema.type = "integer";
 				}
-				if (schema$1.type === "string") {
-					if (meta.get("meta.required")) schema$1.minLength = 1;
+				if (schema.type === "string") {
+					if (meta.get("meta.required")) schema.minLength = 1;
 					const minLength = meta.get("expect.minLength");
-					if (minLength) schema$1.minLength = typeof minLength === "number" ? minLength : minLength.length;
+					if (minLength) schema.minLength = typeof minLength === "number" ? minLength : minLength.length;
 					const maxLength = meta.get("expect.maxLength");
-					if (maxLength) schema$1.maxLength = typeof maxLength === "number" ? maxLength : maxLength.length;
+					if (maxLength) schema.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 (patterns?.length) if (patterns.length === 1) schema.pattern = patterns[0].pattern;
+					else schema.allOf = (schema.allOf || []).concat(patterns.map((p) => ({ pattern: p.pattern })));
 				}
-				if (schema$1.type === "number" || schema$1.type === "integer") {
+				if (schema.type === "number" || schema.type === "integer") {
 					const min = meta.get("expect.min");
-					if (min) schema$1.minimum = typeof min === "number" ? min : min.minValue;
+					if (min) schema.minimum = typeof min === "number" ? min : min.minValue;
 					const max = meta.get("expect.max");
-					if (max) schema$1.maximum = typeof max === "number" ? max : max.maxValue;
+					if (max) schema.maximum = typeof max === "number" ? max : max.maxValue;
 				}
-				return schema$1;
+				return schema;
 			}
 		});
 	};
@@ -855,9 +936,28 @@ else schema$1.allOf = (schema$1.allOf || []).concat(patterns.map((p) => ({ patte
 	};
 	return schema;
 }
-function fromJsonSchema(schema) {
+/**
+* Converts a JSON Schema object into a {@link TAtscriptAnnotatedType}.
+*
+* This is the inverse of {@link buildJsonSchema}. A round-trip
+* `buildJsonSchema(fromJsonSchema(schema))` preserves structure and constraints.
+*
+* Supports the JSON Schema subset produced by `buildJsonSchema` plus
+* common extensions like `oneOf` (treated as union) and `enum` (union of literals).
+*
+* @example
+* ```ts
+* import { fromJsonSchema } from '@atscript/typescript'
+*
+* const type = fromJsonSchema({ type: 'object', properties: { name: { type: 'string' } }, required: ['name'] })
+* type.validator().validate({ name: 'Alice' }) // passes
+* ```
+*
+* @param schema - A JSON Schema object.
+* @returns An annotated type with full validator support.
+*/ function fromJsonSchema(schema) {
 	const defsSource = schema.$defs || schema.definitions || {};
-	const resolved = new Map();
+	const resolved = /* @__PURE__ */ new Map();
 	const convert = (s) => {
 		if (!s || Object.keys(s).length === 0) return defineAnnotatedType().designType("any").$type;
 		if (s.$ref) {
@@ -920,9 +1020,9 @@ function fromJsonSchema(schema) {
 		}
 		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 handle = defineAnnotatedType("tuple");
+				for (const item of s.items) handle.item(convert(item));
+				return handle.$type;
 			}
 			const itemType = s.items ? convert(s.items) : defineAnnotatedType().designType("any").$type;
 			const handle = defineAnnotatedType("array").of(itemType);
@@ -959,7 +1059,16 @@ function fromJsonSchema(schema) {
 	};
 	return convert(schema);
 }
-function mergeJsonSchemas(types) {
+/**
+* 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`.
+*/ function mergeJsonSchemas(types) {
 	const mergedDefs = {};
 	const schemas = {};
 	for (const type of types) {
@@ -968,7 +1077,7 @@ function mergeJsonSchemas(types) {
 		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;
+			const { $defs: _, ...rest } = schema;
 			schemas[name] = rest;
 		} else schemas[name] = schema;
 	}