@atscript/typescript 0.1.33 → 0.1.34

package/dist/cli.cjs

@@ -1058,7 +1058,8 @@ function createAnnotatedTypeNode(type, metadata, opts) {
 		metadata,
 		validator: validatorMethod,
 		id: opts?.id,
-		optional: opts?.optional
+		optional: opts?.optional,
+		ref: opts?.ref
 	};
 }
 function isAnnotatedType(type) {
@@ -1135,18 +1136,57 @@ function defineAnnotatedType(_kind, 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 (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);
+			if (isAnnotatedType(type$1)) {
+				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}`);
+						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 });
+				this.$type = createAnnotatedTypeNode(newBase.type, metadata, {
+					id: newBase.id,
+					ref: chain && chain.length > 0 ? {
+						type: () => type$1,
+						field: chain.join(".")
+					} : undefined
+				});
+			} else if (typeof type$1 === "function") {
+				const lazyType = type$1;
+				this.$type = createAnnotatedTypeNode({ kind: "" }, metadata, { ref: {
+					type: lazyType,
+					field: chain ? chain.join(".") : ""
+				} });
+				const node = this.$type;
+				const placeholder = node.type;
+				Object.defineProperty(node, "type", {
+					get() {
+						const t = lazyType();
+						if (!isAnnotatedType(t)) {
+							Object.defineProperty(node, "type", {
+								value: placeholder,
+								writable: false,
+								configurable: true
+							});
+							return placeholder;
+						}
+						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;
+						node.id = target.id || t.id;
+						Object.defineProperty(node, "type", {
+							value: target.type,
+							writable: false,
+							configurable: true
+						});
+						return target.type;
+					},
+					configurable: true
+				});
+			} else throw new Error(`${type$1} is not annotated type`);
 			return this;
 		},
 		annotate(key, value, asArray) {
@@ -1631,8 +1671,8 @@ else handle.prop(prop.id, propHandle.$type);
 				const ref = node;
 				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
 				if ((0, __atscript_core.isPrimitive)(decl)) {
-					const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
-					if (!ownerDecl?.node || ownerDecl.node.entity !== "type" && ownerDecl.node.entity !== "interface") {
+					const ownerDecl$1 = this.doc.getDeclarationOwnerNode(ref.id);
+					if (!ownerDecl$1?.node || ownerDecl$1.node.entity !== "type" && ownerDecl$1.node.entity !== "interface") {
 						this.annotateType(decl, name);
 						return this;
 					}
@@ -1646,9 +1686,11 @@ else handle.prop(prop.id, propHandle.$type);
 					}
 				}
 				const chain = ref.hasChain ? `, [${ref.chain.map((c) => `"${escapeQuotes(c.text)}"`).join(", ")}]` : "";
-				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${ref.id}${chain})`);
+				const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
+				const isImported = ownerDecl ? ownerDecl.doc !== this.doc : false;
+				const refExpr = isImported ? `() => ${ref.id}` : ref.id;
+				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${refExpr}${chain})`);
 				if (!ref.hasChain) {
-					const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
 					if (ownerDecl?.node) {
 						const typeAnnotations = ownerDecl.doc.evalAnnotationsForNode(ownerDecl.node);
 						typeAnnotations?.forEach((an) => {

package/dist/index.cjs

@@ -1056,7 +1056,8 @@ function createAnnotatedTypeNode(type, metadata, opts) {
 		metadata,
 		validator: validatorMethod,
 		id: opts?.id,
-		optional: opts?.optional
+		optional: opts?.optional,
+		ref: opts?.ref
 	};
 }
 function isAnnotatedType(type) {
@@ -1133,18 +1134,57 @@ function defineAnnotatedType(_kind, 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 (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);
+			if (isAnnotatedType(type$1)) {
+				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}`);
+						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 });
+				this.$type = createAnnotatedTypeNode(newBase.type, metadata, {
+					id: newBase.id,
+					ref: chain && chain.length > 0 ? {
+						type: () => type$1,
+						field: chain.join(".")
+					} : undefined
+				});
+			} else if (typeof type$1 === "function") {
+				const lazyType = type$1;
+				this.$type = createAnnotatedTypeNode({ kind: "" }, metadata, { ref: {
+					type: lazyType,
+					field: chain ? chain.join(".") : ""
+				} });
+				const node = this.$type;
+				const placeholder = node.type;
+				Object.defineProperty(node, "type", {
+					get() {
+						const t = lazyType();
+						if (!isAnnotatedType(t)) {
+							Object.defineProperty(node, "type", {
+								value: placeholder,
+								writable: false,
+								configurable: true
+							});
+							return placeholder;
+						}
+						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;
+						node.id = target.id || t.id;
+						Object.defineProperty(node, "type", {
+							value: target.type,
+							writable: false,
+							configurable: true
+						});
+						return target.type;
+					},
+					configurable: true
+				});
+			} else throw new Error(`${type$1} is not annotated type`);
 			return this;
 		},
 		annotate(key, value, asArray) {
@@ -1629,8 +1669,8 @@ else handle.prop(prop.id, propHandle.$type);
 				const ref = node;
 				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
 				if ((0, __atscript_core.isPrimitive)(decl)) {
-					const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
-					if (!ownerDecl?.node || ownerDecl.node.entity !== "type" && ownerDecl.node.entity !== "interface") {
+					const ownerDecl$1 = this.doc.getDeclarationOwnerNode(ref.id);
+					if (!ownerDecl$1?.node || ownerDecl$1.node.entity !== "type" && ownerDecl$1.node.entity !== "interface") {
 						this.annotateType(decl, name);
 						return this;
 					}
@@ -1644,9 +1684,11 @@ else handle.prop(prop.id, propHandle.$type);
 					}
 				}
 				const chain = ref.hasChain ? `, [${ref.chain.map((c) => `"${escapeQuotes(c.text)}"`).join(", ")}]` : "";
-				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${ref.id}${chain})`);
+				const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
+				const isImported = ownerDecl ? ownerDecl.doc !== this.doc : false;
+				const refExpr = isImported ? `() => ${ref.id}` : ref.id;
+				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${refExpr}${chain})`);
 				if (!ref.hasChain) {
-					const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
 					if (ownerDecl?.node) {
 						const typeAnnotations = ownerDecl.doc.evalAnnotationsForNode(ownerDecl.node);
 						typeAnnotations?.forEach((an) => {

package/dist/index.mjs

@@ -1031,7 +1031,8 @@ function createAnnotatedTypeNode(type, metadata, opts) {
 		metadata,
 		validator: validatorMethod,
 		id: opts?.id,
-		optional: opts?.optional
+		optional: opts?.optional,
+		ref: opts?.ref
 	};
 }
 function isAnnotatedType(type) {
@@ -1108,18 +1109,57 @@ function defineAnnotatedType(_kind, 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 (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);
+			if (isAnnotatedType(type$1)) {
+				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}`);
+						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 });
+				this.$type = createAnnotatedTypeNode(newBase.type, metadata, {
+					id: newBase.id,
+					ref: chain && chain.length > 0 ? {
+						type: () => type$1,
+						field: chain.join(".")
+					} : undefined
+				});
+			} else if (typeof type$1 === "function") {
+				const lazyType = type$1;
+				this.$type = createAnnotatedTypeNode({ kind: "" }, metadata, { ref: {
+					type: lazyType,
+					field: chain ? chain.join(".") : ""
+				} });
+				const node = this.$type;
+				const placeholder = node.type;
+				Object.defineProperty(node, "type", {
+					get() {
+						const t = lazyType();
+						if (!isAnnotatedType(t)) {
+							Object.defineProperty(node, "type", {
+								value: placeholder,
+								writable: false,
+								configurable: true
+							});
+							return placeholder;
+						}
+						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;
+						node.id = target.id || t.id;
+						Object.defineProperty(node, "type", {
+							value: target.type,
+							writable: false,
+							configurable: true
+						});
+						return target.type;
+					},
+					configurable: true
+				});
+			} else throw new Error(`${type$1} is not annotated type`);
 			return this;
 		},
 		annotate(key, value, asArray) {
@@ -1604,8 +1644,8 @@ else handle.prop(prop.id, propHandle.$type);
 				const ref = node;
 				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
 				if (isPrimitive(decl)) {
-					const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
-					if (!ownerDecl?.node || ownerDecl.node.entity !== "type" && ownerDecl.node.entity !== "interface") {
+					const ownerDecl$1 = this.doc.getDeclarationOwnerNode(ref.id);
+					if (!ownerDecl$1?.node || ownerDecl$1.node.entity !== "type" && ownerDecl$1.node.entity !== "interface") {
 						this.annotateType(decl, name);
 						return this;
 					}
@@ -1619,9 +1659,11 @@ else handle.prop(prop.id, propHandle.$type);
 					}
 				}
 				const chain = ref.hasChain ? `, [${ref.chain.map((c) => `"${escapeQuotes(c.text)}"`).join(", ")}]` : "";
-				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${ref.id}${chain})`);
+				const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
+				const isImported = ownerDecl ? ownerDecl.doc !== this.doc : false;
+				const refExpr = isImported ? `() => ${ref.id}` : ref.id;
+				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${refExpr}${chain})`);
 				if (!ref.hasChain) {
-					const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
 					if (ownerDecl?.node) {
 						const typeAnnotations = ownerDecl.doc.evalAnnotationsForNode(ownerDecl.node);
 						typeAnnotations?.forEach((an) => {

package/dist/utils.cjs

@@ -452,7 +452,8 @@ function createAnnotatedTypeNode(type, metadata, opts) {
 		metadata,
 		validator: validatorMethod,
 		id: opts?.id,
-		optional: opts?.optional
+		optional: opts?.optional,
+		ref: opts?.ref
 	};
 }
 function isAnnotatedType(type) {
@@ -576,18 +577,57 @@ function defineAnnotatedType(_kind, 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 (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);
+			if (isAnnotatedType(type$1)) {
+				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}`);
+						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 });
+				this.$type = createAnnotatedTypeNode(newBase.type, metadata, {
+					id: newBase.id,
+					ref: chain && chain.length > 0 ? {
+						type: () => type$1,
+						field: chain.join(".")
+					} : undefined
+				});
+			} else if (typeof type$1 === "function") {
+				const lazyType = type$1;
+				this.$type = createAnnotatedTypeNode({ kind: "" }, metadata, { ref: {
+					type: lazyType,
+					field: chain ? chain.join(".") : ""
+				} });
+				const node = this.$type;
+				const placeholder = node.type;
+				Object.defineProperty(node, "type", {
+					get() {
+						const t = lazyType();
+						if (!isAnnotatedType(t)) {
+							Object.defineProperty(node, "type", {
+								value: placeholder,
+								writable: false,
+								configurable: true
+							});
+							return placeholder;
+						}
+						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;
+						node.id = target.id || t.id;
+						Object.defineProperty(node, "type", {
+							value: target.type,
+							writable: false,
+							configurable: true
+						});
+						return target.type;
+					},
+					configurable: true
+				});
+			} else throw new Error(`${type$1} is not annotated type`);
 			return this;
 		},
 		annotate(key, value, asArray) {
@@ -1020,6 +1060,7 @@ 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) {
@@ -1056,6 +1097,13 @@ else flatUnion.item(existing);
 		}
 	}
 	function flattenType(def, prefix = "", inComplexTypeOrArray = false) {
+		const 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);
 		switch (def.type.kind) {
 			case "object": {
 				addFieldToFlatMap(prefix || "", def);
@@ -1102,20 +1150,31 @@ 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) {
+function serializeTypeDef(def, path, options, visited) {
 	return forAnnotatedType(def, {
 		phantom(d) {
 			return {
@@ -1135,13 +1194,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 +1212,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)
 			};
 		}
@@ -1251,6 +1310,12 @@ 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}"`);
 	}
 }

package/dist/utils.d.ts

@@ -103,6 +103,10 @@ declare class ValidatorError extends Error {
 declare function createAnnotatedTypeNode(type: TAtscriptTypeDef, metadata: TMetadataMap<AtscriptMetadata>, opts?: {
     id?: string;
     optional?: boolean;
+    ref?: {
+        type: () => TAtscriptAnnotatedType;
+        field: string;
+    };
 }): TAtscriptAnnotatedType;
 /** Type definition for union, intersection, or tuple types. */
 interface TAtscriptTypeComplex<DataType = unknown> {
@@ -191,6 +195,10 @@ interface TAtscriptAnnotatedType<T extends TAtscriptTypeDef = TAtscriptTypeDef,
     metadata: TMetadataMap<AtscriptMetadata>;
     optional?: boolean;
     id?: string;
+    ref?: {
+        type: () => TAtscriptAnnotatedType;
+        field: string;
+    };
 }
 /** An annotated type that is also a class constructor (i.e. a generated interface class). */
 type TAtscriptAnnotatedTypeConstructor = TAtscriptAnnotatedType & (new (...args: any[]) => any);
@@ -252,9 +260,11 @@ interface TAnnotatedTypeHandle {
     propPattern(pattern: RegExp, value: TAtscriptAnnotatedType): TAnnotatedTypeHandle;
     optional(value?: boolean): TAnnotatedTypeHandle;
     copyMetadata(fromMetadata: TMetadataMap<AtscriptMetadata>): TAnnotatedTypeHandle;
-    refTo(type: TAtscriptAnnotatedType & {
+    refTo(type: (TAtscriptAnnotatedType & {
         name?: string;
-    }, chain?: string[]): TAnnotatedTypeHandle;
+    }) | (() => TAtscriptAnnotatedType & {
+        name?: string;
+    }), chain?: string[]): TAnnotatedTypeHandle;
     annotate(key: keyof AtscriptMetadata, value: any, asArray?: boolean): TAnnotatedTypeHandle;
     id(value: string): TAnnotatedTypeHandle;
 }
@@ -478,7 +488,11 @@ interface TSerializedTypeComplex {
     items: TSerializedAnnotatedTypeInner[];
     tags: string[];
 }
-type TSerializedTypeDef = TSerializedTypeFinal | TSerializedTypeObject | TSerializedTypeArray | TSerializedTypeComplex;
+interface TSerializedTypeRef {
+    kind: '$ref';
+    id: string;
+}
+type TSerializedTypeDef = TSerializedTypeFinal | TSerializedTypeObject | TSerializedTypeArray | TSerializedTypeComplex | TSerializedTypeRef;
 /** Context passed to {@link TSerializeOptions.processAnnotation} for each annotation entry. */
 interface TProcessAnnotationContext {
     /** Annotation key, e.g. "meta.label" */

package/dist/utils.mjs

@@ -451,7 +451,8 @@ function createAnnotatedTypeNode(type, metadata, opts) {
 		metadata,
 		validator: validatorMethod,
 		id: opts?.id,
-		optional: opts?.optional
+		optional: opts?.optional,
+		ref: opts?.ref
 	};
 }
 function isAnnotatedType(type) {
@@ -575,18 +576,57 @@ function defineAnnotatedType(_kind, 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 (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);
+			if (isAnnotatedType(type$1)) {
+				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}`);
+						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 });
+				this.$type = createAnnotatedTypeNode(newBase.type, metadata, {
+					id: newBase.id,
+					ref: chain && chain.length > 0 ? {
+						type: () => type$1,
+						field: chain.join(".")
+					} : undefined
+				});
+			} else if (typeof type$1 === "function") {
+				const lazyType = type$1;
+				this.$type = createAnnotatedTypeNode({ kind: "" }, metadata, { ref: {
+					type: lazyType,
+					field: chain ? chain.join(".") : ""
+				} });
+				const node = this.$type;
+				const placeholder = node.type;
+				Object.defineProperty(node, "type", {
+					get() {
+						const t = lazyType();
+						if (!isAnnotatedType(t)) {
+							Object.defineProperty(node, "type", {
+								value: placeholder,
+								writable: false,
+								configurable: true
+							});
+							return placeholder;
+						}
+						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;
+						node.id = target.id || t.id;
+						Object.defineProperty(node, "type", {
+							value: target.type,
+							writable: false,
+							configurable: true
+						});
+						return target.type;
+					},
+					configurable: true
+				});
+			} else throw new Error(`${type$1} is not annotated type`);
 			return this;
 		},
 		annotate(key, value, asArray) {
@@ -1019,6 +1059,7 @@ 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) {
@@ -1055,6 +1096,13 @@ else flatUnion.item(existing);
 		}
 	}
 	function flattenType(def, prefix = "", inComplexTypeOrArray = false) {
+		const 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);
 		switch (def.type.kind) {
 			case "object": {
 				addFieldToFlatMap(prefix || "", def);
@@ -1101,20 +1149,31 @@ 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) {
+function serializeTypeDef(def, path, options, visited) {
 	return forAnnotatedType(def, {
 		phantom(d) {
 			return {
@@ -1134,13 +1193,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",
@@ -1152,28 +1211,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)
 			};
 		}
@@ -1250,6 +1309,12 @@ 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}"`);
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/typescript",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "description": "Atscript: typescript-gen support.",
   "keywords": [
     "annotations",
@@ -64,7 +64,7 @@
     "vitest": "3.2.4"
   },
   "peerDependencies": {
-    "@atscript/core": "^0.1.33"
+    "@atscript/core": "^0.1.34"
   },
   "build": [
     {},