@atscript/typescript 0.1.31 → 0.1.33

package/dist/cli.cjs

@@ -143,6 +143,9 @@ else obj[key] = value;
 	return obj;
 }
 var BaseRenderer = class extends CodePrinter {
+	get unused() {
+		return this._unused ?? (this._unused = new Set(this.doc.getUnusedTokens().map((t) => t.text)));
+	}
 	pre() {}
 	post() {}
 	render() {
@@ -196,15 +199,14 @@ var BaseRenderer = class extends CodePrinter {
 		}
 	}
 	constructor(doc) {
-		super(), _define_property$4(this, "doc", void 0), _define_property$4(this, "unused", void 0), this.doc = doc;
-		this.unused = new Set(this.doc.getUnusedTokens().map((t) => t.text));
+		super(), _define_property$4(this, "doc", void 0), _define_property$4(this, "_unused", void 0), this.doc = doc;
 	}
 };
 
 //#endregion
 //#region packages/typescript/src/codegen/utils.ts
+const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 function wrapProp(name) {
-	const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 	if (!validIdentifier.test(name)) return `"${escapeQuotes(name)}"`;
 	return name;
 }
@@ -291,13 +293,14 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 		}
 		if ((0, __atscript_core.isPrimitive)(def)) return this.write(renderPrimitiveTypeDef(def.config.type));
 	}
-	renderStructure(struct, asClass, interfaceNode) {
+	renderStructure(struct, asClass, interfaceNode, filterProps) {
 		this.blockln("{}");
 		const patterns = [];
 		const propsDefs = new Set();
-		for (const prop of Array.from(struct.props.values())) {
+		for (const prop of struct.props.values()) {
+			if (filterProps?.has(prop.id)) continue;
 			if (prop.token("identifier")?.pattern) {
-				patterns.push(prop);
+				if (!filterProps) patterns.push(prop);
 				continue;
 			}
 			const phantomType = this.phantomPropType(prop.getDefinition());
@@ -313,34 +316,36 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 		}
 		if (patterns.length > 0) {
 			this.write(`[key: string]: `);
-			if (patterns.length > 0) {
-				for (const prop of patterns) propsDefs.add(this.renderTypeDefString(prop.getDefinition()));
-				const defs = Array.from(propsDefs);
-				if (defs.length > 1) {
-					this.indent();
-					for (const def of defs) {
-						this.writeln();
-						this.write("| ");
-						def.split("\n").forEach((l) => this.write(l.trim()));
-					}
-					this.unindent();
+			for (const prop of patterns) propsDefs.add(this.renderTypeDefString(prop.getDefinition()));
+			const defs = Array.from(propsDefs);
+			if (defs.length > 1) {
+				this.indent();
+				for (const def of defs) {
 					this.writeln();
-				} else defs[0].split("\n").forEach((l) => this.writeln(l));
-			}
-		}
-		if (asClass) {
-			this.writeln("static __is_atscript_annotated_type: true");
-			this.writeln(`static type: TAtscriptTypeObject<keyof ${asClass}, ${asClass}>`);
-			this.writeln(`static metadata: TMetadataMap<AtscriptMetadata>`);
-			this.writeln(`static validator: (opts?: Partial<TValidatorOptions>) => Validator<typeof ${asClass}>`);
-			if (resolveJsonSchemaMode(this.opts) === false) this.writeln("/** @deprecated JSON Schema support is disabled. Calling this method will throw a runtime error. To enable, set `jsonSchema: 'lazy'` or `jsonSchema: 'bundle'` in tsPlugin options, or add `@emit.jsonSchema` annotation to individual interfaces. */");
-			this.writeln("static toJsonSchema: () => any");
-			if (!this.opts?.exampleData) this.writeln("/** @deprecated Example Data support is disabled. To enable, set `exampleData: true` in tsPlugin options. */");
-			this.writeln("static toExampleData?: () => any");
-			if (interfaceNode && this.hasDbTable(interfaceNode)) this.renderFlat(interfaceNode);
+					this.write("| ");
+					def.split("\n").forEach((l) => this.write(l.trim()));
+				}
+				this.unindent();
+				this.writeln();
+			} else defs[0].split("\n").forEach((l) => this.writeln(l));
 		}
+		if (asClass) this.renderStaticDeclarations(asClass, interfaceNode);
 		this.pop();
 	}
+	renderStaticDeclarations(asClass, interfaceNode) {
+		this.writeln("static __is_atscript_annotated_type: true");
+		this.writeln(`static type: TAtscriptTypeObject<keyof ${asClass}, ${asClass}>`);
+		this.writeln(`static metadata: TMetadataMap<AtscriptMetadata>`);
+		this.writeln(`static validator: (opts?: Partial<TValidatorOptions>) => Validator<typeof ${asClass}>`);
+		if (resolveJsonSchemaMode(this.opts) === false) this.writeln("/** @deprecated JSON Schema support is disabled. Calling this method will throw a runtime error. To enable, set `jsonSchema: 'lazy'` or `jsonSchema: 'bundle'` in tsPlugin options, or add `@emit.jsonSchema` annotation to individual interfaces. */");
+		this.writeln("static toJsonSchema: () => any");
+		if (!this.opts?.exampleData) this.writeln("/** @deprecated Example Data support is disabled. To enable, set `exampleData: true` in tsPlugin options. */");
+		this.writeln("static toExampleData?: () => any");
+		if (interfaceNode && this.hasDbTable(interfaceNode)) {
+			this.renderFlat(interfaceNode);
+			this.renderPk(interfaceNode);
+		}
+	}
 	renderInterface(node) {
 		this.writeln();
 		const exported = node.token("export")?.text === "export";
@@ -364,7 +369,7 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 					}
 					if (!firstParentProps && (0, __atscript_core.isStructure)(fpDef)) firstParentProps = fpDef.props;
 				}
-				this.renderStructureFiltered(resolved, node.id, firstParentProps, node);
+				this.renderStructure(resolved, node.id, node, firstParentProps);
 			} else this.writeln("{}");
 		} else {
 			this.write(`class ${node.id} `);
@@ -374,35 +379,6 @@ else this.writeln("{}");
 		}
 		this.writeln();
 	}
-	/**
-	* Renders a structure block, optionally filtering out props that exist in a parent.
-	*/ renderStructureFiltered(struct, asClass, filterProps, interfaceNode) {
-		if (!filterProps) return this.renderStructure(struct, asClass, interfaceNode);
-		this.blockln("{}");
-		for (const prop of Array.from(struct.props.values())) {
-			if (filterProps.has(prop.id)) continue;
-			if (prop.token("identifier")?.pattern) continue;
-			const phantomType = this.phantomPropType(prop.getDefinition());
-			if (phantomType) {
-				this.writeln(`// ${prop.id}: ${phantomType}`);
-				continue;
-			}
-			const optional = !!prop.token("optional");
-			this.write(wrapProp(prop.id), optional ? "?" : "", ": ");
-			const renderedDef = this.renderTypeDefString(prop.getDefinition());
-			renderedDef.split("\n").forEach((l) => this.writeln(l));
-		}
-		this.writeln("static __is_atscript_annotated_type: true");
-		this.writeln(`static type: TAtscriptTypeObject<keyof ${asClass}, ${asClass}>`);
-		this.writeln(`static metadata: TMetadataMap<AtscriptMetadata>`);
-		this.writeln(`static validator: (opts?: Partial<TValidatorOptions>) => Validator<typeof ${asClass}>`);
-		if (resolveJsonSchemaMode(this.opts) === false) this.writeln("/** @deprecated JSON Schema support is disabled. Calling this method will throw a runtime error. To enable, set `jsonSchema: 'lazy'` or `jsonSchema: 'bundle'` in tsPlugin options, or add `@emit.jsonSchema` annotation to individual interfaces. */");
-		this.writeln("static toJsonSchema: () => any");
-		if (!this.opts?.exampleData) this.writeln("/** @deprecated Example Data support is disabled. To enable, set `exampleData: true` in tsPlugin options. */");
-		this.writeln("static toExampleData?: () => any");
-		if (interfaceNode && this.hasDbTable(interfaceNode)) this.renderFlat(interfaceNode);
-		this.pop();
-	}
 	renderType(node) {
 		this.writeln();
 		const exported = node.token("export")?.text === "export";
@@ -500,6 +476,88 @@ else {
 		}
 		this.pop();
 	}
+	/**
+	* Renders the `static __pk` property — the primary key type for type-safe
+	* `deleteOne`/`findById` signatures on `AtscriptDbTable`.
+	*
+	* - **Single PK** (one `@meta.id`) → `static __pk: <scalar type>`
+	* - **Compound PK** (multiple `@meta.id`) → `static __pk: { field1: Type1; field2: Type2 }`
+	* - **No PK** → no `__pk` emitted (unless unique indexes exist)
+	* - **Unique indexes** (`@db.index.unique`) → appended as union members
+	* - **Mongo collection** → always includes `string` (ObjectId) in the union;
+	*   if no `@meta.id` fields, `__pk` is just `string`
+	*/ renderPk(node) {
+		const isMongoCollection = !!node.annotations?.some((a) => a.name === "db.mongo.collection");
+		let struct;
+		if (node.hasExtends) struct = this.doc.resolveInterfaceExtends(node);
+		if (!struct) struct = node.getDefinition();
+		if (!struct || !(0, __atscript_core.isStructure)(struct)) return;
+		const structNode = struct;
+		const pkProps = [];
+		const uniqueByIndex = new Map();
+		for (const [name, prop] of structNode.props) {
+			if (prop.token("identifier")?.pattern) continue;
+			if (isMongoCollection && name === "_id") continue;
+			if (prop.countAnnotations("meta.id") > 0) pkProps.push({
+				name,
+				prop
+			});
+			if (prop.annotations) {
+				for (const ann of prop.annotations) if (ann.name === "db.index.unique") {
+					const indexName = ann.args[0]?.text ?? name;
+					let group = uniqueByIndex.get(indexName);
+					if (!group) {
+						group = [];
+						uniqueByIndex.set(indexName, group);
+					}
+					group.push({
+						name,
+						prop
+					});
+				}
+			}
+		}
+		const uniqueProps = [];
+		const pkNames = new Set(pkProps.map((p) => p.name));
+		for (const fields of uniqueByIndex.values()) if (fields.length === 1 && !pkNames.has(fields[0].name)) uniqueProps.push(fields[0]);
+		if (pkProps.length === 0 && uniqueProps.length === 0 && !isMongoCollection) return;
+		let mongoIdType;
+		if (isMongoCollection) {
+			const idProp = structNode.props.get("_id");
+			if (idProp) mongoIdType = this.renderTypeDefString(idProp.getDefinition()).trim();
+			mongoIdType ?? (mongoIdType = "string");
+		}
+		const uniqueTypes = [];
+		const seenTypes = new Set();
+		for (const { prop } of uniqueProps) {
+			const rendered = this.renderTypeDefString(prop.getDefinition()).trim();
+			if (!seenTypes.has(rendered)) {
+				seenTypes.add(rendered);
+				uniqueTypes.push(rendered);
+			}
+		}
+		this.writeln();
+		const uniqueSuffix = uniqueTypes.length > 0 ? ` | ${uniqueTypes.join(" | ")}` : "";
+		if (pkProps.length === 0 && !isMongoCollection) this.writeln(`static __pk: ${uniqueTypes.join(" | ")}`);
+else if (pkProps.length === 0) this.writeln(`static __pk: ${mongoIdType}${uniqueSuffix}`);
+else if (pkProps.length === 1) {
+			this.write("static __pk: ");
+			if (isMongoCollection) this.write(`${mongoIdType} | `);
+			const renderedDef = this.renderTypeDefString(pkProps[0].prop.getDefinition()).trim();
+			this.writeln(`${renderedDef}${uniqueSuffix}`);
+		} else {
+			this.write("static __pk: ");
+			if (isMongoCollection) this.write(`${mongoIdType} | `);
+			this.blockln("{}");
+			for (const { name, prop } of pkProps) {
+				this.write(wrapProp(name), ": ");
+				const renderedDef = this.renderTypeDefString(prop.getDefinition());
+				renderedDef.split("\n").forEach((l) => this.writeln(l));
+			}
+			this.pop();
+			this.writeln(uniqueSuffix);
+		}
+	}
 	phantomPropType(def) {
 		if (!def) return undefined;
 		if ((0, __atscript_core.isPrimitive)(def) && def.config.type === "phantom") return def.id;
@@ -548,24 +606,6 @@ function renderPrimitiveTypeDef(def) {
 	}
 }
 
-//#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/validator.ts
 function _define_property$2(obj, key, value) {
@@ -581,28 +621,35 @@ else obj[key] = value;
 const regexCache = new Map();
 var Validator = class {
 	isLimitExceeded() {
-		if (this.stackErrors.length > 0) return this.stackErrors[this.stackErrors.length - 1].length >= this.opts.errorLimit;
+		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([]);
+		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?.length) popped.forEach((error) => {
-			this.error(error.message, error.path, error.details);
-		});
+		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] = [];
+		this.stackErrors[this.stackErrors.length - 1] = null;
 	}
 	error(message, path$3, details) {
-		const errors = this.stackErrors[this.stackErrors.length - 1] || this.errors;
+		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$3 || this.path,
+			path: path$3 || this.cachedPath,
 			message
 		};
 		if (details?.length) error.details = details;
@@ -622,9 +669,10 @@ var Validator = class {
 	* @returns `true` if the value matches the type definition.
 	* @throws {ValidatorError} When validation fails and `safe` is not `true`.
 	*/ validate(value, safe, context) {
-		this.push("");
 		this.errors = [];
 		this.stackErrors = [];
+		this.stackPath = [""];
+		this.cachedPath = "";
 		this.context = context;
 		const passed = this.validateSafe(this.def, value);
 		this.pop(!passed);
@@ -638,7 +686,7 @@ var Validator = class {
 	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.path);
+		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);
@@ -647,18 +695,21 @@ var Validator = class {
 		return this.validateAnnotatedType(def, value);
 	}
 	get path() {
-		return this.stackPath.slice(1).join(".");
+		return this.cachedPath;
 	}
 	validateAnnotatedType(def, value) {
-		return forAnnotatedType(def, {
-			final: (d) => this.validatePrimitive(d, value),
-			phantom: () => true,
-			object: (d) => this.validateObject(d, value),
-			array: (d) => this.validateArray(d, value),
-			union: (d) => this.validateUnion(d, value),
-			intersection: (d) => this.validateIntersection(d, value),
-			tuple: (d) => this.validateTuple(d, 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;
@@ -722,6 +773,30 @@ var Validator = class {
 				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) {
@@ -743,21 +818,20 @@ var Validator = class {
 		let passed = true;
 		const valueKeys = new Set(Object.keys(value));
 		const typeKeys = new Set();
-		const skipList = new Set();
+		let skipList;
 		if (this.opts.skipList) {
-			const path$3 = this.stackPath.length > 1 ? `${this.path}.` : "";
-			this.opts.skipList.forEach((item) => {
-				if (item.startsWith(path$3)) {
-					const key = item.slice(path$3.length);
-					skipList.add(key);
-					valueKeys.delete(key);
-				}
-			});
+			const path$3 = this.stackPath.length > 1 ? `${this.cachedPath}.` : "";
+			for (const item of this.opts.skipList) if (item.startsWith(path$3)) {
+				const key = item.slice(path$3.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.path);
+		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.cachedPath);
 		for (const [key, item] of def.type.props.entries()) {
-			if (skipList.has(key) || isPhantomType(item)) continue;
+			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;
@@ -778,19 +852,21 @@ else {
 				def: propDef
 			});
 			if (matched.length > 0) {
+				this.push(key);
 				let keyPassed = false;
-				for (const { def: def$1 } of matched) if (this.validateSafe(def$1, value[key])) {
-					this.pop(false);
-					keyPassed = true;
-					break;
+				for (const { def: propDef } of matched) {
+					if (this.validateSafe(propDef, value[key])) {
+						keyPassed = true;
+						break;
+					}
+					this.clear();
 				}
 				if (!keyPassed) {
-					this.push(key);
 					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);
@@ -943,11 +1019,13 @@ else {
 		/** Validation errors collected during the last {@link validate} call. */ _define_property$2(this, "errors", void 0);
 		_define_property$2(this, "stackErrors", void 0);
 		_define_property$2(this, "stackPath", void 0);
+		_define_property$2(this, "cachedPath", void 0);
 		_define_property$2(this, "context", void 0);
 		this.def = def;
 		this.errors = [];
 		this.stackErrors = [];
 		this.stackPath = [];
+		this.cachedPath = "";
 		this.opts = {
 			partial: false,
 			unknownProps: "error",
@@ -965,6 +1043,24 @@ var ValidatorError = class extends Error {
 
 //#endregion
 //#region packages/typescript/src/annotated-type.ts
+const COMPLEX_KINDS = new Set([
+	"union",
+	"intersection",
+	"tuple"
+]);
+/** 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;
 }
@@ -981,38 +1077,24 @@ function defineAnnotatedType(_kind, base) {
 	const kind = _kind || "";
 	const type = base?.type || {};
 	type.kind = kind;
-	if ([
-		"union",
-		"intersection",
-		"tuple"
-	].includes(kind)) type.items = [];
+	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();
-	if (base) Object.assign(base, {
-		__is_atscript_annotated_type: true,
-		metadata,
-		type,
-		validator(opts) {
-			return new Validator(this, opts);
-		}
-	});
-else base = {
+	const payload = {
 		__is_atscript_annotated_type: true,
 		metadata,
 		type,
-		validator(opts) {
-			return new Validator(this, opts);
-		}
+		validator: validatorMethod
 	};
+	base = base ? Object.assign(base, payload) : payload;
 	const handle = {
 		$type: base,
 		$def: type,
 		$metadata: metadata,
-		_existingObject: undefined,
 		tags(...tags) {
 			for (const tag of tags) this.$def.tags.add(tag);
 			return this;
@@ -1053,27 +1135,18 @@ else base = {
 			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 (isAnnotatedType(newBase)) {
-				let keys = "";
-				for (const c of chain || []) {
-					keys += `["${c}"]`;
-					if (newBase.type.kind === "object" && newBase.type.props.has(c)) newBase = newBase.type.props.get(c);
-else throw new Error(`Can't find prop ${typeName}${keys}`);
+			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}`);
 				}
-				if (!newBase && keys) throw new Error(`Can't find prop ${typeName}${keys}`);
-else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
-				this.$type = {
-					__is_atscript_annotated_type: true,
-					type: newBase.type,
-					metadata,
-					id: newBase.id,
-					validator(opts) {
-						return new Validator(this, opts);
-					}
-				};
-			} else throw new Error(`${type$1} is not annotated type`);
+			}
+			this.$type = createAnnotatedTypeNode(newBase.type, metadata, { id: newBase.id });
 			return this;
 		},
 		annotate(key, value, asArray) {
@@ -1091,6 +1164,24 @@ function isPhantomType(def) {
 	return def.type.kind === "" && def.type.designType === "phantom";
 }
 
+//#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
 /**
@@ -1105,10 +1196,10 @@ function isPhantomType(def) {
 	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);
-	const validCandidates = [];
+	let result = null;
 	for (const candidate of candidates) {
 		const values = new Set();
-		const mapping = {};
+		const indexMapping = {};
 		let valid = true;
 		for (let i = 0; i < items.length; i++) {
 			const obj = items[i].type;
@@ -1123,19 +1214,21 @@ function isPhantomType(def) {
 				break;
 			}
 			values.add(val);
-			mapping[String(val)] = `#/oneOf/${i}`;
+			indexMapping[String(val)] = i;
+		}
+		if (valid) {
+			if (result) return null;
+			result = {
+				propertyName: candidate,
+				indexMapping
+			};
 		}
-		if (valid) validCandidates.push({
-			propertyName: candidate,
-			mapping
-		});
 	}
-	if (validCandidates.length === 1) return validCandidates[0];
-	return null;
+	return result;
 }
 function buildJsonSchema(type) {
 	const defs = {};
-	let isRoot = true;
+	let hasDefs = false;
 	const buildObject = (d) => {
 		const properties = {};
 		const required = [];
@@ -1152,15 +1245,15 @@ function buildJsonSchema(type) {
 		return schema$1;
 	};
 	const build$1 = (def) => {
-		if (def.id && def.type.kind === "object" && !isRoot) {
+		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}` };
 		}
-		isRoot = false;
 		const meta = def.metadata;
 		return forAnnotatedType(def, {
 			phantom() {
@@ -1185,11 +1278,9 @@ function buildJsonSchema(type) {
 				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);
+					for (const [val, idx] of Object.entries(disc.indexMapping)) {
 						const item = d.type.items[idx];
-						if (item.id && defs[item.id]) mapping[val] = `#/$defs/${item.id}`;
-else mapping[val] = origPath;
+						mapping[val] = item.id && defs[item.id] ? `#/$defs/${item.id}` : `#/oneOf/${idx}`;
 					}
 					return {
 						oneOf,
@@ -1239,7 +1330,7 @@ else schema$1.allOf = (schema$1.allOf || []).concat(patterns.map((p) => ({ patte
 		});
 	};
 	const schema = build$1(type);
-	if (Object.keys(defs).length > 0) return {
+	if (hasDefs) return {
 		...schema,
 		$defs: defs
 	};
@@ -1263,24 +1354,25 @@ var JsRenderer = class extends BaseRenderer {
 		this.writeln("// prettier-ignore-start");
 		this.writeln("/* eslint-disable */");
 		this.writeln("/* oxlint-disable */");
+		let hasMutatingAnnotate = false;
+		const nodesByName = new Map();
+		for (const node of this.doc.nodes) {
+			if (node.entity === "annotate" && node.isMutating) hasMutatingAnnotate = true;
+			if (node.__typeId !== null && node.__typeId !== undefined && node.id) {
+				const name = node.id;
+				if (!nodesByName.has(name)) nodesByName.set(name, []);
+				nodesByName.get(name).push(node);
+			}
+		}
+		for (const [name, nodes] of nodesByName) if (nodes.length === 1) this.typeIds.set(nodes[0], name);
+else for (let i = 0; i < nodes.length; i++) this.typeIds.set(nodes[i], `${name}__${i + 1}`);
 		const imports = ["defineAnnotatedType as $", "annotate as $a"];
-		const hasMutatingAnnotate = this.doc.nodes.some((n) => n.entity === "annotate" && n.isMutating);
 		if (hasMutatingAnnotate) imports.push("cloneRefProp as $c");
 		const jsonSchemaMode = resolveJsonSchemaMode(this.opts);
 		if (jsonSchemaMode === "lazy") imports.push("buildJsonSchema as $$");
 		if (this.opts?.exampleData) imports.push("createDataFromAnnotatedType as $e");
 		if (jsonSchemaMode === false) imports.push("throwFeatureDisabled as $d");
 		this.writeln(`import { ${imports.join(", ")} } from "@atscript/typescript/utils"`);
-		const nameCounts = new Map();
-		const nodesByName = new Map();
-		for (const node of this.doc.nodes) if (node.__typeId !== null && node.__typeId !== undefined && node.id) {
-			const name = node.id;
-			nameCounts.set(name, (nameCounts.get(name) || 0) + 1);
-			if (!nodesByName.has(name)) nodesByName.set(name, []);
-			nodesByName.get(name).push(node);
-		}
-		for (const [name, nodes] of nodesByName) if (nodes.length === 1) this.typeIds.set(nodes[0], name);
-else for (let i = 0; i < nodes.length; i++) this.typeIds.set(nodes[i], `${name}__${i + 1}`);
 	}
 	buildAdHocMap(annotateNodes) {
 		const map = new Map();
@@ -1289,7 +1381,8 @@ else for (let i = 0; i < nodes.length; i++) this.typeIds.set(nodes[i], `${name}_
 			const anns = entry.annotations || [];
 			if (anns.length > 0) {
 				const existing = map.get(path$3);
-				map.set(path$3, existing ? [...existing, ...anns] : anns);
+				if (existing) existing.push(...anns);
+else map.set(path$3, [...anns]);
 			}
 		}
 		return map.size > 0 ? map : null;
@@ -1348,35 +1441,20 @@ else def = def.getDefinition() || def;
 		this.renderExampleDataMethod(node);
 	}
 	renderInterface(node) {
-		this.writeln();
-		const exported = node.token("export")?.text === "export";
-		this.write(exported ? "export " : "");
-		this.write(`class ${node.id} `);
-		this.blockln("{}");
-		this.renderClassStatics(node);
-		this.popln();
-		this.postAnnotate.push(node);
-		this.writeln();
+		this.renderDefinitionClass(node);
 	}
 	renderType(node) {
-		this.writeln();
-		const exported = node.token("export")?.text === "export";
-		this.write(exported ? "export " : "");
-		this.write(`class ${node.id} `);
-		this.blockln("{}");
-		this.renderClassStatics(node);
-		this.popln();
-		this.postAnnotate.push(node);
-		this.writeln();
+		this.renderDefinitionClass(node);
 	}
 	renderAnnotate(node) {
 		if (node.isMutating) {
 			this.postAnnotate.push(node);
 			return;
 		}
-		const targetName = node.targetName;
-		const unwound = this.doc.unwindType(targetName);
-		if (!unwound?.def) return;
+		if (!this.doc.unwindType(node.targetName)?.def) return;
+		this.renderDefinitionClass(node);
+	}
+	renderDefinitionClass(node) {
 		this.writeln();
 		const exported = node.token("export")?.text === "export";
 		this.write(exported ? "export " : "");
@@ -1534,6 +1612,11 @@ else handle.prop(prop.id, propHandle.$type);
 					handle.annotate(a.name, true);
 					break;
 				}
+				case "expect.array.uniqueItems":
+				case "expect.array.key": {
+					handle.annotate(a.name, { message: a.args[0]?.text });
+					break;
+				}
 				default:
 			}
 		});
@@ -1601,10 +1684,7 @@ else handle.prop(prop.id, propHandle.$type);
 				this.writeln(`$("array"${name ? `, ${name}` : ""})`).indent().defineArray(node).unindent();
 				return this;
 			}
-			default: {
-				console.log("!!!!!!! UNKNOWN", node.entity);
-				return this;
-			}
+			default: return this;
 		}
 	}
 	defineConst(node) {
@@ -1816,40 +1896,25 @@ else targetValue = "true";
 				this.writeln(`$c(${clone.parentPath}, "${escapeQuotes(clone.propName)}")`);
 			}
 		}
-		for (const { entry, accessors } of entryAccessors) {
-			const anns = entry.annotations;
-			for (const accessor of accessors) {
-				const cleared = new Set();
-				for (const an of anns) {
-					const { value, multiple } = this.computeAnnotationValue(entry, an);
-					if (multiple) {
-						if (!cleared.has(an.name)) {
-							const spec = this.doc.resolveAnnotation(an.name);
-							if (!spec || spec.config.mergeStrategy !== "append") this.writeln(`${accessor}.metadata.delete("${escapeQuotes(an.name)}")`);
-							cleared.add(an.name);
-						}
-						this.writeln(`$a(${accessor}.metadata, "${escapeQuotes(an.name)}", ${value}, true)`);
-					} else this.writeln(`$a(${accessor}.metadata, "${escapeQuotes(an.name)}", ${value})`);
-				}
-			}
-		}
+		for (const { entry, accessors } of entryAccessors) for (const accessor of accessors) this.emitMutatingAnnotations(entry, entry.annotations, accessor);
 		const topAnnotations = node.annotations;
-		if (topAnnotations && topAnnotations.length > 0) {
-			const cleared = new Set();
-			for (const an of topAnnotations) {
-				const { value, multiple } = this.computeAnnotationValue(node, an);
-				if (multiple) {
-					if (!cleared.has(an.name)) {
-						const spec = this.doc.resolveAnnotation(an.name);
-						if (!spec || spec.config.mergeStrategy !== "append") this.writeln(`${targetName}.metadata.delete("${escapeQuotes(an.name)}")`);
-						cleared.add(an.name);
-					}
-					this.writeln(`$a(${targetName}.metadata, "${escapeQuotes(an.name)}", ${value}, true)`);
-				} else this.writeln(`$a(${targetName}.metadata, "${escapeQuotes(an.name)}", ${value})`);
-			}
-		}
+		if (topAnnotations && topAnnotations.length > 0) this.emitMutatingAnnotations(node, topAnnotations, targetName);
 		this.writeln();
 	}
+	emitMutatingAnnotations(node, annotations, accessor) {
+		const cleared = new Set();
+		for (const an of annotations) {
+			const { value, multiple } = this.computeAnnotationValue(node, an);
+			if (multiple) {
+				if (!cleared.has(an.name)) {
+					const spec = this.doc.resolveAnnotation(an.name);
+					if (!spec || spec.config.mergeStrategy !== "append") this.writeln(`${accessor}.metadata.delete("${escapeQuotes(an.name)}")`);
+					cleared.add(an.name);
+				}
+				this.writeln(`$a(${accessor}.metadata, "${escapeQuotes(an.name)}", ${value}, true)`);
+			} else this.writeln(`$a(${accessor}.metadata, "${escapeQuotes(an.name)}", ${value})`);
+		}
+	}
 	resolveTargetDef(targetName) {
 		const unwound = this.doc.unwindType(targetName);
 		if (!unwound?.def) return undefined;