@atscript/typescript 0.1.49 → 0.1.50

package/dist/index.mjs

@@ -1,1456 +1,4 @@
-import { buildJsonSchema, defineAnnotatedType } from "./json-schema-Bl8jkrCj.mjs";
-import path from "path";
-import { DEFAULT_FORMAT, flattenInterfaceNode, hasNavPropAnnotation, isArray, isConst, isGroup, isInterface, isPrimitive, isQueryLogical, isRef, isStructure } from "@atscript/core";
+import { tsPlugin } from "./plugin-D96fH7Va.mjs";
+import "./json-schema-DrJMwvm1.mjs";
 
-//#region packages/typescript/src/codegen/code-printer.ts
-function _define_property$3(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-else obj[key] = value;
-	return obj;
-}
-var CodePrinter = class {
-	/**
-	* Write text with NO automatic newline.
-	* If current line is empty, we prepend indentation.
-	*/ write(...text) {
-		if (!this.currentLine) this.currentLine = this.indentString();
-		this.currentLine += text.join("");
-		return this;
-	}
-	/**
-	* Write text and then finalize this line with a newline.
-	* Implemented by calling `write(...)` + push line + reset `currentLine`.
-	*/ writeln(...text) {
-		this.write(...text);
-		this.lines.push(this.currentLine);
-		this.currentLine = "";
-		return this;
-	}
-	/**
-	* Open a block with an opening/closing pair, e.g. "{}" or "()".
-	* By default, places the opening delimiter on the current line (no extra newline).
-	*/ block(pair) {
-		return this.doBlock(pair, false);
-	}
-	/**
-	* Same as `block()`, but adds a newline after writing the opening delimiter.
-	*/ blockln(pair) {
-		return this.doBlock(pair, true);
-	}
-	/**
-	* Close the most recent block. By default, closing delimiter goes on the current line.
-	*/ pop() {
-		return this.doPop(false);
-	}
-	/**
-	* Same as `pop()`, but puts the closing delimiter on a new line.
-	*/ popln() {
-		return this.doPop(true);
-	}
-	/**
-	* Increase indentation by one level.
-	*/ indent() {
-		this.indentLevel++;
-		return this;
-	}
-	/**
-	* Decrease indentation by one level (never below 0).
-	*/ unindent() {
-		this.indentLevel = Math.max(0, this.indentLevel - 1);
-		return this;
-	}
-	render() {
-		return this.toString();
-	}
-	/**
-	* Return the entire code as a string. Removes any half-finished current line if empty.
-	*/ toString() {
-		if (this.currentLine.trim() !== "") this.lines.push(this.currentLine);
-else if (this.currentLine.length > 0) this.lines.push(this.currentLine);
-		return this.lines.join("\n");
-	}
-	doBlock(pair, withNewLine) {
-		if (pair.length < 2) throw new Error(`Block pair must have at least 2 chars, e.g. "{}" or "()". Got "${pair}"`);
-		const opening = pair[0];
-		const closing = pair[pair.length - 1];
-		this.write(opening);
-		this.blockStack.push(closing);
-		if (withNewLine) this.writeln();
-		this.indent();
-		return this;
-	}
-	doPop(withNewLine) {
-		if (this.blockStack.length === 0) throw new Error("No block to pop (stack is empty).");
-		const closing = this.blockStack.pop();
-		this.unindent();
-		if (withNewLine) this.writeln(closing);
-else this.write(closing);
-		return this;
-	}
-	indentString() {
-		return " ".repeat(this.indentLevel * this.indentSize);
-	}
-	constructor() {
-		_define_property$3(this, "lines", []);
-		_define_property$3(this, "currentLine", "");
-		_define_property$3(this, "indentLevel", 0);
-		_define_property$3(this, "indentSize", 2);
-		_define_property$3(this, "blockStack", []);
-	}
-};
-
-//#endregion
-//#region packages/typescript/src/codegen/base-renderer.ts
-function _define_property$2(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-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() {
-		this.pre();
-		for (const node of this.doc.nodes) this.renderNode(node);
-		this.post();
-		return this.toString();
-	}
-	renderInterface(node) {}
-	renderType(node) {}
-	renderAnnotate(node) {}
-	transformFromPath(path$1) {
-		return `${path$1}.as`;
-	}
-	renderImport(node) {
-		const def = node.getDefinition();
-		const refs = [];
-		const from = this.transformFromPath(node.token("path").text);
-		let isUnusedImport = true;
-		if (isGroup(def)) {
-			for (const child of def.unwrap()) if (isRef(child) && !this.unused.has(child.id)) {
-				const node$1 = child;
-				refs.push(node$1.id);
-				isUnusedImport = false;
-			}
-		} else if (isRef(def) && !this.unused.has(def.id)) {
-			refs.push(def.id);
-			isUnusedImport = false;
-		}
-		if (!isUnusedImport) this.writeln(`import { ${refs.join(", ")} } from "${from}"`);
-	}
-	renderNode(node) {
-		switch (node.entity) {
-			case "interface": {
-				this.renderInterface(node);
-				break;
-			}
-			case "type": {
-				this.renderType(node);
-				break;
-			}
-			case "import": {
-				this.renderImport(node);
-				break;
-			}
-			case "annotate": {
-				this.renderAnnotate(node);
-				break;
-			}
-			default: break;
-		}
-	}
-	constructor(doc) {
-		super(), _define_property$2(this, "doc", void 0), _define_property$2(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) {
-	if (!validIdentifier.test(name)) return `"${escapeQuotes(name)}"`;
-	return name;
-}
-function escapeQuotes(str) {
-	return str.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
-}
-
-//#endregion
-//#region packages/typescript/src/codegen/type-renderer.ts
-function _define_property$1(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-else obj[key] = value;
-	return obj;
-}
-var TypeRenderer = class TypeRenderer extends BaseRenderer {
-	pre() {
-		this.writeln("// prettier-ignore-start");
-		this.writeln("/* eslint-disable */");
-		this.writeln("/* oxlint-disable */");
-		this.writeln(`/// <reference path="./${this.doc.name}" />`);
-		this.writeln("/**");
-		this.writeln(" * 🪄 This file was generated by Atscript");
-		this.writeln(" * Do not edit this file!");
-		this.writeln(" */");
-		this.writeln();
-		this.writeln("import type { TAtscriptTypeObject, TAtscriptTypeComplex, TAtscriptTypeFinal, TAtscriptTypeArray, TAtscriptAnnotatedType, TMetadataMap, Validator, TValidatorOptions } from \"@atscript/typescript/utils\"");
-	}
-	post() {
-		this.writeln("// prettier-ignore-end");
-	}
-	renderTypeDefString(def) {
-		const newThis = new TypeRenderer(this.doc, this.opts);
-		newThis.renderTypeDef(def);
-		return newThis.toString();
-	}
-	renderTypeDef(def) {
-		if (!def) {
-			this.write("unknown");
-			return;
-		}
-		if (isStructure(def)) return this.renderStructure(def);
-		if (isGroup(def)) {
-			const tuple = def.entity === "tuple";
-			const operator = tuple ? ", " : ` ${def.op} `;
-			const children = def.unwrap();
-			const hasSubgroup = !tuple && children.some((c) => c.entity === "group");
-			this.write(tuple ? "[" : hasSubgroup ? "(" : "");
-			this.renderTypeDef(def.first);
-			for (const child of children.slice(1)) {
-				this.write(operator);
-				this.renderTypeDef(child);
-			}
-			return this.write(tuple ? "]" : hasSubgroup ? ")" : "");
-		}
-		if (isConst(def)) {
-			const name = def.token("identifier")?.type === "number" ? def.id : `"${escapeQuotes(def.id)}"`;
-			return this.write(name);
-		}
-		if (isRef(def)) {
-			const node = def;
-			const unwound = this.doc.unwindType(node.id, node.chain);
-			if (isPrimitive(unwound?.def)) {
-				this.write(renderPrimitiveTypeDef(unwound.def.config.type));
-				if (node.hasChain) this.write(` /* ${node.chain.map((c) => c.text).join(".")} */`);
-				return;
-			}
-			let name = node.id;
-			for (const c of node.chain) name += `["${escapeQuotes(c.text)}"]`;
-			return this.write(name);
-		}
-		if (isArray(def)) {
-			const node = def;
-			const def2 = node.getDefinition();
-			const isGrp = def2?.entity === "group";
-			if (isGrp) this.write("(");
-			this.renderTypeDef(def2);
-			if (isGrp) this.write(")");
-			return this.write("[]");
-		}
-		if (isPrimitive(def)) return this.write(renderPrimitiveTypeDef(def.config.type));
-	}
-	renderStructure(struct, asClass, interfaceNode, filterProps) {
-		this.blockln("{}");
-		const patterns = [];
-		const propsDefs = new Set();
-		for (const prop of struct.props.values()) {
-			if (filterProps?.has(prop.id)) continue;
-			if (prop.token("identifier")?.pattern) {
-				if (!filterProps) patterns.push(prop);
-				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());
-			propsDefs.add(renderedDef);
-			renderedDef.split("\n").forEach((l) => this.writeln(l));
-		}
-		if (patterns.length > 0) {
-			this.write(`[key: string]: `);
-			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();
-				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.hasDbEntity(interfaceNode)) {
-			this.renderFlat(interfaceNode);
-			this.renderOwnProps(interfaceNode);
-			this.renderNavProps(interfaceNode);
-			this.renderPk(interfaceNode);
-			this.renderDimMeasure(interfaceNode);
-		}
-	}
-	renderInterface(node) {
-		this.writeln();
-		const exported = node.token("export")?.text === "export";
-		this.renderJsDoc(node);
-		this.write(exported ? "export declare " : "declare ");
-		if (node.hasExtends) {
-			const firstParent = node.extendsTokens[0].text;
-			this.write(`class ${node.id} extends ${firstParent} `);
-			const resolved = this.doc.resolveInterfaceExtends(node);
-			if (resolved?.entity === "structure") {
-				const firstParentUnwound = this.doc.unwindType(firstParent);
-				let firstParentProps;
-				if (firstParentUnwound?.def) {
-					let fpDef = firstParentUnwound.def;
-					if (isInterface(fpDef)) {
-						if (fpDef.hasExtends) {
-							const fpResolved = firstParentUnwound.doc.resolveInterfaceExtends(fpDef);
-							if (fpResolved && isStructure(fpResolved)) firstParentProps = fpResolved.props;
-						}
-						if (!firstParentProps) fpDef = fpDef.getDefinition() || fpDef;
-					}
-					if (!firstParentProps && isStructure(fpDef)) firstParentProps = fpDef.props;
-				}
-				this.renderStructure(resolved, node.id, node, firstParentProps);
-			} else this.writeln("{}");
-		} else {
-			this.write(`class ${node.id} `);
-			const struct = node.getDefinition();
-			if (struct?.entity === "structure") this.renderStructure(struct, node.id, node);
-else this.writeln("{}");
-		}
-		this.writeln();
-	}
-	renderType(node) {
-		this.writeln();
-		const exported = node.token("export")?.text === "export";
-		this.renderJsDoc(node);
-		this.write(exported ? "export " : "declare ");
-		this.write(`type ${node.id} = `);
-		this.renderTypeDef(node.getDefinition());
-		this.writeln();
-		this.renderTypeNamespace(node);
-	}
-	renderAnnotate(node) {
-		if (node.isMutating) return;
-		const targetName = node.targetName;
-		this.writeln();
-		const exported = node.token("export")?.text === "export";
-		this.renderJsDoc(node);
-		if (this.isTypeTarget(targetName)) {
-			this.write(exported ? "export " : "declare ");
-			this.write(`type ${node.id} = ${targetName}`);
-			this.writeln();
-			const unwound = this.doc.unwindType(targetName);
-			this.renderTypeNamespaceFor(node.id, unwound?.def);
-		} else {
-			this.write(exported ? "export declare " : "declare ");
-			this.writeln(`class ${node.id} extends ${targetName} {}`);
-		}
-	}
-	renderTypeNamespace(node) {
-		this.renderTypeNamespaceFor(node.id, node.getDefinition());
-	}
-	renderTypeNamespaceFor(name, inputDef) {
-		this.write(`declare namespace ${name} `);
-		this.blockln("{}");
-		let typeDef = "TAtscriptTypeDef";
-		if (inputDef) {
-			let realDef = inputDef;
-			if (isRef(inputDef)) realDef = this.doc.unwindType(inputDef.id, inputDef.chain)?.def || realDef;
-			realDef = this.doc.mergeIntersection(realDef);
-			if (isStructure(realDef) || isInterface(realDef)) typeDef = `TAtscriptTypeObject<keyof ${name}, ${name}>`;
-else if (isGroup(realDef)) typeDef = `TAtscriptTypeComplex<${name}>`;
-else if (isArray(realDef)) typeDef = `TAtscriptTypeArray<${name}>`;
-else if (isPrimitive(realDef)) typeDef = `TAtscriptTypeFinal<${name}>`;
-		}
-		this.writeln(`const __is_atscript_annotated_type: true`);
-		this.writeln(`const type: ${typeDef}`);
-		this.writeln(`const metadata: TMetadataMap<AtscriptMetadata>`);
-		this.writeln(`const validator: (opts?: Partial<TValidatorOptions>) => Validator<typeof ${name}>`);
-		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("const toJsonSchema: () => any");
-		if (!this.opts?.exampleData) this.writeln("/** @deprecated Example Data support is disabled. To enable, set `exampleData: true` in tsPlugin options. */");
-		this.writeln("const toExampleData: (() => any) | undefined");
-		this.popln();
-	}
-	/**
-	* Checks whether an interface is a DB entity (`@db.table` or `@db.view`).
-	*
-	* Only DB entities get `__flat`, `__pk`, `__ownProps`, and `__navProps` static properties.
-	* These exist solely to improve type-safety for filter expressions, `$select`/`$sort`,
-	* and `$with` operations in the DB layer.
-	*/ hasDbEntity(node) {
-		return !!node.annotations?.some((a) => a.name === "db.table" || a.name === "db.view" || a.name === "db.view.for");
-	}
-	/**
-	* Renders the `static __flat` property — a map of all dot-notation paths
-	* to their TypeScript value types.
-	*
-	* This enables type-safe autocomplete for filter keys and `$select`/`$sort`
-	* paths when using `AtscriptDbTable`. The `FlatOf<T>` utility type extracts
-	* this map at the type level.
-	*
-	* Special rendering rules:
-	* - **Intermediate paths** (structures, arrays of structures) → `never`
-	*   (prevents `$eq` comparisons, but allows `$select` and `$exists`)
-	* - **`@db.json` fields** → `string` (stored as serialized JSON in DB,
-	*   not individually queryable)
-	* - **Leaf fields** → their original TypeScript type
-	*/ renderFlat(node) {
-		this.renderFlatMap("__flat", flattenInterfaceNode(this.doc, node));
-	}
-	/**
-	* Renders the `static __ownProps` property — table-owned fields only (no nav props).
-	*/ renderOwnProps(node) {
-		this.renderFlatMap("__ownProps", flattenInterfaceNode(this.doc, node, { skipNavProps: true }), {
-			leadingNewline: true,
-			trailingNewline: true
-		});
-	}
-	/**
-	* Shared renderer for flat-map static properties (`__flat`, `__ownProps`).
-	*
-	* Special rendering rules:
-	* - **Intermediate paths** (structures, arrays of structures) → `never`
-	* - **`@db.json` fields** → `string` (stored as serialized JSON in DB)
-	* - **Leaf fields** → their original TypeScript type
-	*/ renderFlatMap(propName, flatMap, opts) {
-		if (flatMap.size === 0) return;
-		if (opts?.leadingNewline) this.writeln();
-		this.write(`static ${propName}: `);
-		this.blockln("{}");
-		for (const [path$1, descriptor] of flatMap) {
-			this.write(`"${escapeQuotes(path$1)}"`);
-			if (descriptor.optional) this.write("?");
-			this.write(": ");
-			if (descriptor.intermediate) this.writeln("never");
-else if (descriptor.dbJson) this.writeln("string");
-else {
-				const originalDef = descriptor.propNode?.getDefinition();
-				const defToRender = originalDef && !(isGroup(descriptor.def) && descriptor.def !== originalDef) ? originalDef : descriptor.def;
-				const renderedDef = this.renderTypeDefString(defToRender);
-				renderedDef.split("\n").forEach((l) => this.writeln(l));
-			}
-		}
-		if (opts?.trailingNewline) this.popln();
-else this.pop();
-	}
-	/**
-	* Renders the `static __navProps` property — a map of navigation property names
-	* to their declared TypeScript types.
-	*
-	* This enables type-safe `$with` in queries: `name` is constrained to known
-	* navigation property keys, and nested filter/controls are typed to the target entity.
-	*/ renderNavProps(node) {
-		let struct;
-		if (node.hasExtends) struct = this.doc.resolveInterfaceExtends(node);
-		if (!struct) struct = node.getDefinition();
-		if (!struct || !isStructure(struct)) return;
-		const structNode = struct;
-		const navProps = [];
-		for (const [name, prop] of structNode.props) {
-			if (prop.token("identifier")?.pattern) continue;
-			if (hasNavPropAnnotation(prop)) navProps.push({
-				name,
-				prop
-			});
-		}
-		if (navProps.length === 0) return;
-		this.writeln();
-		this.write("static __navProps: ");
-		this.blockln("{}");
-		for (const { name, prop } of navProps) {
-			this.write(`"${escapeQuotes(name)}"`);
-			if (prop.token("optional")) this.write("?");
-			this.write(": ");
-			const propDef = prop.getDefinition();
-			if (propDef) {
-				const renderedDef = this.renderTypeDefString(propDef);
-				renderedDef.split("\n").forEach((l) => this.writeln(l));
-			} else this.writeln("unknown");
-		}
-		this.popln();
-	}
-	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 || !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);
-		}
-	}
-	renderDimMeasure(node) {
-		let struct;
-		if (node.hasExtends) struct = this.doc.resolveInterfaceExtends(node);
-		if (!struct) struct = node.getDefinition();
-		if (!struct || !isStructure(struct)) return;
-		const structNode = struct;
-		const dims = [];
-		const measures = [];
-		for (const [name, prop] of structNode.props) {
-			if (prop.token("identifier")?.pattern) continue;
-			if (prop.countAnnotations("db.column.dimension") > 0) dims.push(name);
-			if (prop.countAnnotations("db.column.measure") > 0) measures.push(name);
-		}
-		if (dims.length === 0 && measures.length === 0) return;
-		this.writeln();
-		if (dims.length > 0) this.writeln(`static __dim: ${dims.map((d) => `"${escapeQuotes(d)}"`).join(" | ")}`);
-		if (measures.length > 0) this.writeln(`static __measure: ${measures.map((m) => `"${escapeQuotes(m)}"`).join(" | ")}`);
-	}
-	phantomPropType(def) {
-		if (!def) return undefined;
-		if (isPrimitive(def) && def.config.type === "phantom") return def.id;
-		if (isRef(def)) {
-			const ref = def;
-			const unwound = this.doc.unwindType(ref.id, ref.chain)?.def;
-			if (isPrimitive(unwound) && unwound.config.type === "phantom") return ref.hasChain ? `${ref.id}.${ref.chain.map((c) => c.text).join(".")}` : ref.id;
-		}
-		return undefined;
-	}
-	isTypeTarget(name, doc) {
-		const d = doc || this.doc;
-		const decl = d.getDeclarationOwnerNode(name);
-		if (!decl?.node) return false;
-		if (decl.node.entity === "type") return true;
-		if (decl.node.entity === "interface") return false;
-		if (decl.node.entity === "annotate") return this.isTypeTarget(decl.node.targetName, decl.doc);
-		return false;
-	}
-	renderJsDoc(node) {
-		const range = node.token("identifier")?.range;
-		const rangeStr = range ? `:${range.start.line + 1}:${range.start.character + 1}` : "";
-		this.writeln(`/**`);
-		this.writeln(` * Atscript ${node.entity} **${node.id}**`);
-		this.writeln(` * @see {@link ./${this.doc.name}${rangeStr}}`);
-		this.writeln(` */`);
-	}
-	constructor(doc, opts) {
-		super(doc), _define_property$1(this, "opts", void 0), this.opts = opts;
-	}
-};
-function renderPrimitiveTypeDef(def) {
-	if (!def) return "unknown";
-	if (typeof def === "string") return def === "void" ? "undefined" : def;
-	switch (def.kind) {
-		case "final": return def.value === "void" ? "undefined" : def.value;
-		case "union": return def.items.map(renderPrimitiveTypeDef).join(" | ");
-		case "intersection": return def.items.map(renderPrimitiveTypeDef).join(" & ");
-		case "tuple": return `[${def.items.map(renderPrimitiveTypeDef).join(", ")}]`;
-		case "array": return `${renderPrimitiveTypeDef(def.of)}[]`;
-		case "object": {
-			const props = Object.entries(def.props).map(([key, val]) => `${wrapProp(key)}${typeof val === "object" && val.optional ? "?" : ""}: ${renderPrimitiveTypeDef(val)}`).join("; ");
-			return `{ ${props} }`;
-		}
-		default: return "unknown";
-	}
-}
-
-//#endregion
-//#region packages/typescript/src/codegen/js-renderer.ts
-function _define_property(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-else obj[key] = value;
-	return obj;
-}
-const QUERY_OP_MAP = {
-	"=": "$eq",
-	"!=": "$ne",
-	">": "$gt",
-	">=": "$gte",
-	"<": "$lt",
-	"<=": "$lte",
-	"in": "$in",
-	"not in": "$nin",
-	"matches": "$regex",
-	"exists": "$exists",
-	"not exists": "$exists"
-};
-var JsRenderer = class extends BaseRenderer {
-	pre() {
-		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"];
-		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"`);
-	}
-	buildAdHocMap(annotateNodes) {
-		const map = new Map();
-		for (const annotateNode of annotateNodes) for (const entry of annotateNode.entries) {
-			const path$1 = entry.hasChain ? [entry.id, ...entry.chain.map((c) => c.text)].join(".") : entry.id;
-			const anns = entry.annotations || [];
-			if (anns.length > 0) {
-				const existing = map.get(path$1);
-				if (existing) existing.push(...anns);
-else map.set(path$1, [...anns]);
-			}
-		}
-		return map.size > 0 ? map : null;
-	}
-	/**
-	* Checks if any ad-hoc annotation path extends beyond the current _propPath,
-	* meaning annotations target properties inside a referenced type.
-	*/ hasAdHocAnnotationsThroughRef() {
-		if (!this._adHocAnnotations || this._propPath.length === 0) return false;
-		const prefix = `${this._propPath.join(".")}.`;
-		for (const key of this._adHocAnnotations.keys()) if (key.startsWith(prefix)) return true;
-		return false;
-	}
-	post() {
-		for (const node of this.postAnnotate) if (node.entity === "annotate") {
-			const annotateNode = node;
-			if (annotateNode.isMutating) this.renderMutatingAnnotateNode(annotateNode);
-else {
-				const unwound = this.doc.unwindType(annotateNode.targetName);
-				if (unwound?.def) {
-					let def = this.doc.mergeIntersection(unwound.def);
-					if (isInterface(def)) if (def.hasExtends) {
-						const resolved = unwound.doc.resolveInterfaceExtends(def);
-						if (resolved) def = resolved;
-else def = def.getDefinition() || def;
-					} else def = def.getDefinition() || def;
-					this._adHocAnnotations = this.buildAdHocMap([annotateNode]);
-					this.annotateType(def, node.id);
-					this._adHocAnnotations = null;
-					this.indent();
-					this.defineMetadataForAnnotateAlias(annotateNode);
-					this.unindent();
-					this.writeln();
-				}
-			}
-		} else {
-			let def = node.getDefinition();
-			if (isInterface(node) && node.hasExtends) {
-				const resolved = this.doc.resolveInterfaceExtends(node);
-				if (resolved) def = resolved;
-			}
-			this.annotateType(def, node.id);
-			this.indent().defineMetadata(node).unindent();
-			this.writeln();
-		}
-		this.writeln("// prettier-ignore-end");
-		super.post();
-	}
-	renderClassStatics(node) {
-		this.writeln("static __is_atscript_annotated_type = true");
-		this.writeln("static type = {}");
-		this.writeln("static metadata = new Map()");
-		const typeId = this.typeIds.get(node);
-		if (typeId) this.writeln(`static id = "${typeId}"`);
-		this.renderJsonSchemaMethod(node);
-		this.renderExampleDataMethod(node);
-		this.renderDimMeasure(node);
-	}
-	renderInterface(node) {
-		this.renderDefinitionClass(node);
-	}
-	renderType(node) {
-		this.renderDefinitionClass(node);
-	}
-	renderAnnotate(node) {
-		if (node.isMutating) {
-			this.postAnnotate.push(node);
-			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 " : "");
-		this.write(`class ${node.id} `);
-		this.blockln("{}");
-		this.renderClassStatics(node);
-		this.popln();
-		this.postAnnotate.push(node);
-		this.writeln();
-	}
-	renderJsonSchemaMethod(node) {
-		const mode = resolveJsonSchemaMode(this.opts);
-		const hasAnnotation = node.countAnnotations("emit.jsonSchema") > 0;
-		if (hasAnnotation || mode === "bundle") {
-			const schema = JSON.stringify(buildJsonSchema(this.toAnnotatedType(node)));
-			this.writeln("static toJsonSchema() {");
-			this.indent().writeln(`return ${schema}`).unindent();
-			this.writeln("}");
-		} else if (mode === "lazy") {
-			this.writeln("static toJsonSchema() {");
-			this.indent().writeln("return this._jsonSchema ?? (this._jsonSchema = $$(this))").unindent();
-			this.writeln("}");
-		} else {
-			this.writeln("static toJsonSchema() {");
-			this.indent().writeln("$d(\"JSON Schema\", \"jsonSchema\", \"emit.jsonSchema\")").unindent();
-			this.writeln("}");
-		}
-	}
-	renderExampleDataMethod(_node) {
-		if (this.opts?.exampleData) {
-			this.writeln("static toExampleData() {");
-			this.indent().writeln("return $e(this, { mode: \"example\" })").unindent();
-			this.writeln("}");
-		}
-	}
-	renderDimMeasure(node) {
-		if (!isInterface(node)) return;
-		const interfaceNode = node;
-		if (!interfaceNode.annotations?.some((a) => a.name === "db.table" || a.name === "db.view" || a.name === "db.view.for")) return;
-		let struct;
-		if (interfaceNode.hasExtends) struct = this.doc.resolveInterfaceExtends(interfaceNode);
-		if (!struct) struct = interfaceNode.getDefinition();
-		if (!struct || !isStructure(struct)) return;
-		const structNode = struct;
-		const dims = [];
-		const measures = [];
-		for (const [name, prop] of structNode.props) {
-			if (prop.token("identifier")?.pattern) continue;
-			if (prop.countAnnotations("db.column.dimension") > 0) dims.push(name);
-			if (prop.countAnnotations("db.column.measure") > 0) measures.push(name);
-		}
-		if (dims.length > 0) this.writeln(`static dimensions = [${dims.map((d) => `'${escapeQuotes(d)}'`).join(", ")}]`);
-		if (measures.length > 0) this.writeln(`static measures = [${measures.map((m) => `'${escapeQuotes(m)}'`).join(", ")}]`);
-	}
-	toAnnotatedType(node) {
-		return this.toAnnotatedHandle(node).$type;
-	}
-	toAnnotatedHandle(node, skipAnnotations = false) {
-		if (!node) return defineAnnotatedType();
-		switch (node.entity) {
-			case "interface":
-			case "type": {
-				let def = node.getDefinition();
-				if (isInterface(node) && node.hasExtends) {
-					const resolved = this.doc.resolveInterfaceExtends(node);
-					if (resolved) def = resolved;
-				}
-				const handle = this.toAnnotatedHandle(def, true);
-				const typeId = this.typeIds.get(node) ?? (node.__typeId !== null && node.__typeId !== undefined ? node.id : undefined);
-				if (typeId) handle.id(typeId);
-				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
-			}
-			case "prop": {
-				const prop = node;
-				const def = prop.getDefinition();
-				const handle = this.toAnnotatedHandle(def, true);
-				if (!skipAnnotations) {
-					this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(prop));
-					if (prop.token("optional")) handle.optional();
-				}
-				return handle;
-			}
-			case "ref": {
-				const ref = node;
-				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
-				const handle = this.toAnnotatedHandle(decl, true);
-				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
-			}
-			case "primitive": {
-				const prim = node;
-				const handle = defineAnnotatedType();
-				handle.designType(prim.id === "never" ? "never" : prim.config.type);
-				if (!skipAnnotations) this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
-				return handle;
-			}
-			case "const": {
-				const c = node;
-				const handle = defineAnnotatedType();
-				const t = c.token("identifier")?.type;
-				handle.designType(t === "number" ? "number" : "string");
-				handle.value(t === "number" ? Number(c.id) : c.id);
-				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
-			}
-			case "structure": {
-				const struct = node;
-				const handle = defineAnnotatedType("object");
-				for (const prop of Array.from(struct.props.values())) {
-					const propHandle = this.toAnnotatedHandle(prop);
-					const pattern = prop.token("identifier")?.pattern;
-					if (pattern) handle.propPattern(pattern, propHandle.$type);
-else handle.prop(prop.id, propHandle.$type);
-				}
-				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
-			}
-			case "group": {
-				const group = node;
-				const kind = group.op === "|" ? "union" : "intersection";
-				const handle = defineAnnotatedType(kind);
-				for (const item of group.unwrap()) handle.item(this.toAnnotatedHandle(item).$type);
-				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
-			}
-			case "tuple": {
-				const group = node;
-				const handle = defineAnnotatedType("tuple");
-				for (const item of group.unwrap()) handle.item(this.toAnnotatedHandle(item).$type);
-				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
-			}
-			case "array": {
-				const arr = node;
-				const handle = defineAnnotatedType("array");
-				handle.of(this.toAnnotatedHandle(arr.getDefinition()).$type);
-				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
-			}
-			default: {
-				const handle = defineAnnotatedType();
-				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
-			}
-		}
-	}
-	applyExpectAnnotations(handle, annotations) {
-		annotations?.forEach((a) => {
-			switch (a.name) {
-				case "expect.minLength":
-				case "expect.maxLength": {
-					if (a.args[0]) handle.annotate(a.name, {
-						length: Number(a.args[0].text),
-						message: a.args[1]?.text
-					});
-					break;
-				}
-				case "expect.min": {
-					if (a.args[0]) handle.annotate(a.name, {
-						minValue: Number(a.args[0].text),
-						message: a.args[1]?.text
-					});
-					break;
-				}
-				case "expect.max": {
-					if (a.args[0]) handle.annotate(a.name, {
-						maxValue: Number(a.args[0].text),
-						message: a.args[1]?.text
-					});
-					break;
-				}
-				case "expect.pattern": {
-					handle.annotate(a.name, {
-						pattern: a.args[0]?.text || "",
-						flags: a.args[1]?.text,
-						message: a.args[2]?.text
-					}, true);
-					break;
-				}
-				case "expect.int": {
-					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:
-			}
-		});
-		return handle;
-	}
-	annotateType(_node, name) {
-		if (!_node) return this;
-		const node = this.doc.mergeIntersection(_node);
-		let kind = node.entity;
-		switch (node.entity) {
-			case "ref": {
-				const ref = node;
-				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
-				if (isPrimitive(decl)) {
-					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;
-					}
-				}
-				if (this._adHocAnnotations && this.hasAdHocAnnotationsThroughRef()) {
-					let resolved = decl ? this.doc.mergeIntersection(decl) : undefined;
-					if (resolved && isInterface(resolved)) resolved = resolved.getDefinition() || resolved;
-					if (resolved) {
-						this.annotateType(resolved, name);
-						return this;
-					}
-				}
-				const chain = ref.hasChain ? `, [${ref.chain.map((c) => `"${escapeQuotes(c.text)}"`).join(", ")}]` : "";
-				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) {
-					if (ownerDecl?.node) {
-						const typeAnnotations = ownerDecl.doc.evalAnnotationsForNode(ownerDecl.node);
-						typeAnnotations?.forEach((an) => {
-							this.resolveAnnotationValue(ownerDecl.node, an);
-						});
-					}
-				}
-				this.unindent();
-				return this;
-			}
-			case "primitive": {
-				this.definePrimitive(node, name);
-				return this;
-			}
-			case "const": {
-				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().defineConst(node).unindent();
-				return this;
-			}
-			case "structure": {
-				this.writeln(`$("object"${name ? `, ${name}` : ""})`).indent().defineObject(node).unindent();
-				return this;
-			}
-			case "group": {
-				kind = node.op === "|" ? "union" : "intersection";
-				this.writeln(`$("${kind}"${name ? `, ${name}` : ""})`).indent().defineGroup(node).unindent();
-				return this;
-			}
-			case "tuple": {
-				this.writeln(`$("tuple"${name ? `, ${name}` : ""})`).indent().defineGroup(node).unindent();
-				return this;
-			}
-			case "array": {
-				this.writeln(`$("array"${name ? `, ${name}` : ""})`).indent().defineArray(node).unindent();
-				return this;
-			}
-			default: return this;
-		}
-	}
-	defineConst(node) {
-		const t = node.token("identifier")?.type;
-		const designType = t === "text" ? "string" : t === "number" ? "number" : "unknown";
-		this.writeln(`.designType("${escapeQuotes(designType)}")`);
-		this.writeln(`.value(${t === "text" ? `"${escapeQuotes(node.id)}"` : node.id})`);
-		return this;
-	}
-	definePrimitive(node, name) {
-		this.renderPrimitiveDef(node.id === "never" ? "never" : node.config.type, name);
-		this.writeln(`  .tags(${Array.from(node.tags).map((f) => `"${escapeQuotes(f)}"`).join(", ")})`);
-		return this;
-	}
-	renderPrimitiveDef(def, name) {
-		const d = (t) => [`"${t || ""}"`, name].filter(Boolean).join(", ").replace(/^""$/, "");
-		if (!def) return this.writeln(`$(${d()}).designType("any")`);
-		if (typeof def === "string") return this.writeln(`$(${d()}).designType("${def === "void" ? "undefined" : def}")`);
-		switch (def.kind) {
-			case "final": return this.writeln(`$(${d()}).designType("${def.value === "void" ? "undefined" : def.value}")`);
-			case "union":
-			case "intersection":
-			case "tuple": {
-				this.writeln(`$(${d(def.kind)})`);
-				this.indent();
-				for (const itemDef of def.items) {
-					this.write(`.item(`);
-					this.indent();
-					this.renderPrimitiveDef(itemDef);
-					this.writeln(".$type");
-					this.unindent();
-					this.write(`)`);
-				}
-				this.unindent();
-				return;
-			}
-			case "array": {
-				this.writeln(`$(${d("array")})`);
-				this.indent();
-				this.write(".of(");
-				this.indent();
-				this.renderPrimitiveDef(def.of);
-				this.writeln(`.$type`);
-				this.unindent();
-				this.writeln(`)`);
-				this.unindent();
-				return;
-			}
-			case "object": {
-				this.writeln(`$(${d("object")})`);
-				this.indent();
-				for (const [key, propDef] of Object.entries(def.props)) {
-					const optional = typeof propDef === "object" && propDef.optional;
-					this.writeln(`.prop(`);
-					this.indent();
-					this.writeln(`"${escapeQuotes(key)}",`);
-					this.renderPrimitiveDef(propDef);
-					if (optional) this.writeln(".optional()");
-					this.writeln(".$type");
-					this.unindent();
-					this.write(`)`);
-				}
-				for (const [key, propDef] of Object.entries(def.propsPatterns)) {
-					const optional = typeof propDef === "object" && propDef.optional;
-					this.writeln(`.propPattern(`);
-					this.indent();
-					this.writeln(`${key},`);
-					this.renderPrimitiveDef(propDef);
-					if (optional) this.writeln(".optional()");
-					this.writeln(".$type");
-					this.unindent();
-					this.write(`)`);
-				}
-				this.unindent();
-				return;
-			}
-			default: return this.writeln(`$(${d()}).designType("any")`);
-		}
-	}
-	defineObject(node) {
-		const props = Array.from(node.props.values());
-		for (const prop of props) {
-			const pattern = prop.token("identifier")?.pattern;
-			const optional = !!prop.token("optional");
-			this._propPath.push(prop.id);
-			if (pattern) {
-				this.writeln(`.propPattern(`);
-				this.indent();
-				this.writeln(`/${pattern.source}/${pattern.flags},`);
-			} else {
-				this.writeln(`.prop(`);
-				this.indent();
-				this.writeln(`"${escapeQuotes(prop.id)}",`);
-			}
-			this.annotateType(prop.getDefinition());
-			this.indent().defineMetadata(prop).unindent();
-			if (optional) this.writeln("  .optional()");
-			this.writeln("  .$type");
-			this.unindent();
-			this.write(`)`);
-			this._propPath.pop();
-		}
-		this.writeln();
-		return this;
-	}
-	defineGroup(node) {
-		const items = node.unwrap();
-		for (const item of items) this.write(".item(").indent().annotateType(item).write("  .$type").writeln(`)`).unindent();
-		return this;
-	}
-	defineArray(node) {
-		this.write(".of(").indent().annotateType(node.getDefinition()).write("  .$type").writeln(`)`).unindent();
-		return this;
-	}
-	defineMetadata(node) {
-		let annotations;
-		const nodeDef = node.getDefinition?.();
-		if (nodeDef && isRef(nodeDef)) {
-			const refNode = nodeDef;
-			if (!refNode.hasChain) {
-				const resolved = this.doc.unwindType(refNode.id, refNode.chain)?.def;
-				if (resolved && !isPrimitive(resolved)) annotations = node.annotations ?? [];
-else if (resolved && isPrimitive(resolved)) {
-					const ownerDecl = this.doc.getDeclarationOwnerNode(refNode.id);
-					if (ownerDecl?.node && (ownerDecl.node.entity === "type" || ownerDecl.node.entity === "interface")) annotations = node.annotations ?? [];
-				}
-			}
-		}
-		if (annotations === undefined) annotations = this.doc.evalAnnotationsForNode(node);
-		if (this._adHocAnnotations && this._propPath.length > 0) {
-			const path$1 = this._propPath.join(".");
-			const adHoc = this._adHocAnnotations.get(path$1);
-			if (adHoc) annotations = this.doc.mergeNodesAnnotations(annotations, adHoc);
-		}
-		annotations?.forEach((an) => {
-			this.resolveAnnotationValue(node, an);
-		});
-		return this;
-	}
-	/**
-	* For non-mutating annotate aliases: merge the target's type-level annotations
-	* with the annotate block's own annotations (annotate's take priority).
-	*/ defineMetadataForAnnotateAlias(annotateNode) {
-		const annotateAnnotations = this.doc.evalAnnotationsForNode(annotateNode);
-		const targetDecl = this.doc.getDeclarationOwnerNode(annotateNode.targetName);
-		const targetAnnotations = targetDecl?.node ? targetDecl.doc.evalAnnotationsForNode(targetDecl.node) : undefined;
-		const merged = this.doc.mergeNodesAnnotations(targetAnnotations, annotateAnnotations);
-		merged.forEach((an) => {
-			this.resolveAnnotationValue(annotateNode, an);
-		});
-		return this;
-	}
-	resolveAnnotationValue(node, an) {
-		const { value, multiple } = this.computeAnnotationValue(node, an);
-		if (multiple) this.writeln(`.annotate("${escapeQuotes(an.name)}", ${value}, true)`);
-else this.writeln(`.annotate("${escapeQuotes(an.name)}", ${value})`);
-	}
-	emitRefValue(text) {
-		const dotIdx = text.indexOf(".");
-		if (dotIdx === -1) return `() => ${text}`;
-		const typeName = text.slice(0, dotIdx);
-		const field = text.slice(dotIdx + 1);
-		return `{ type: () => ${typeName}, field: "${escapeQuotes(field)}" }`;
-	}
-	emitArgValue(aSpec, argToken) {
-		if (aSpec.type === "ref") return this.emitRefValue(argToken.text);
-		if (aSpec.type === "query" && argToken.queryNode) return this.emitQueryTree(argToken.queryNode);
-		return aSpec.type === "string" ? `"${escapeQuotes(argToken.text)}"` : argToken.text;
-	}
-	emitQueryTree(queryNode) {
-		return this.emitQueryExpr(queryNode.expression);
-	}
-	emitQueryExpr(node) {
-		if (isQueryLogical(node)) return this.emitQueryLogical(node);
-		return this.emitQueryComparison(node);
-	}
-	emitQueryLogical(node) {
-		if (node.operator === "not") return `{ "$not": ${this.emitQueryExpr(node.operands[0])} }`;
-		const key = node.operator === "and" ? "$and" : "$or";
-		const items = node.operands.map((op) => this.emitQueryExpr(op)).join(", ");
-		return `{ "${key}": [${items}] }`;
-	}
-	emitQueryComparison(node) {
-		const left = this.emitQueryFieldRef(node.left);
-		const mappedOp = QUERY_OP_MAP[node.operator] || node.operator;
-		const parts = [`left: ${left}`, `op: "${mappedOp}"`];
-		if (node.right) {
-			if ("fieldRef" in node.right && node.right.fieldRef) parts.push(`right: ${this.emitQueryFieldRef(node.right)}`);
-else if ("values" in node.right && node.right.values) {
-				const values = node.right.values.map((v) => this.emitQueryLiteral(v)).join(", ");
-				parts.push(`right: [${values}]`);
-			} else if ("valueToken" in node.right) parts.push(`right: ${this.emitQueryLiteral(node.right)}`);
-		} else if (node.operator === "exists") parts.push("right: true");
-else if (node.operator === "not exists") parts.push("right: false");
-		return `{ ${parts.join(", ")} }`;
-	}
-	emitQueryFieldRef(node) {
-		const parts = [];
-		if (node.typeRef) parts.push(`type: () => ${node.typeRef.text}`);
-		parts.push(`field: "${escapeQuotes(node.fieldRef.text)}"`);
-		return `{ ${parts.join(", ")} }`;
-	}
-	emitQueryLiteral(node) {
-		const token = node.valueToken;
-		switch (token.type) {
-			case "text": return `"${escapeQuotes(token.text)}"`;
-			case "number": return token.text;
-			case "regexp": {
-				const match = /^\/(.*)\/[a-z]*$/.exec(token.text);
-				return `"${escapeQuotes(match ? match[1] : token.text)}"`;
-			}
-			case "identifier": {
-				if (token.text === "true" || token.text === "false") return token.text;
-				if (token.text === "null" || token.text === "undefined") return "null";
-				return token.text;
-			}
-			default: return token.text;
-		}
-	}
-	computeAnnotationValue(node, an) {
-		const spec = this.doc.resolveAnnotation(an.name);
-		let targetValue = "true";
-		let multiple = false;
-		if (spec) {
-			multiple = spec.config.multiple;
-			const length = spec.arguments.length;
-			if (length !== 0) if (Array.isArray(spec.config.argument)) {
-				targetValue = "{ ";
-				let i = 0;
-				for (const aSpec of spec.arguments) {
-					if (an.args[i]) targetValue += `${wrapProp(aSpec.name)}: ${this.emitArgValue(aSpec, an.args[i])}${i === length - 1 ? "" : ", "} `;
-					i++;
-				}
-				targetValue += "}";
-			} else {
-				const aSpec = spec.arguments[0];
-				if (an.args[0]) targetValue = this.emitArgValue(aSpec, an.args[0]);
-else targetValue = "true";
-			}
-		} else {
-			multiple = node.countAnnotations(an.name) > 1 || an.args.length > 1;
-			if (an.args.length > 0) targetValue = an.args[0].type === "text" ? `"${escapeQuotes(an.args[0].text)}"` : an.args[0].text;
-		}
-		return {
-			value: targetValue,
-			multiple: !!multiple
-		};
-	}
-	renderMutatingAnnotateNode(node) {
-		const targetName = node.targetName;
-		const targetDef = this.resolveTargetDef(targetName);
-		this.writeln("// Ad-hoc annotations for ", targetName);
-		const allClones = [];
-		const entryAccessors = [];
-		for (const entry of node.entries) {
-			const anns = entry.annotations;
-			if (!anns || anns.length === 0) continue;
-			const parts = entry.hasChain ? [entry.id, ...entry.chain.map((c) => c.text)] : [entry.id];
-			const { accessors, clones } = this.buildMutatingAccessors(targetName, targetDef, parts);
-			allClones.push(...clones);
-			entryAccessors.push({
-				entry,
-				accessors
-			});
-		}
-		const cloneKeys = new Set();
-		for (const clone of allClones) {
-			const key = `${clone.parentPath}|${clone.propName}`;
-			if (!cloneKeys.has(key)) {
-				cloneKeys.add(key);
-				this.writeln(`$c(${clone.parentPath}, "${escapeQuotes(clone.propName)}")`);
-			}
-		}
-		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) 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;
-		let def = unwound.def;
-		if (isInterface(def)) def = def.getDefinition() || def;
-		return def;
-	}
-	/**
-	* Builds the runtime accessor paths for mutating annotate entries.
-	* Computes exact paths at compile time by walking the AST,
-	* so the generated JS accesses props directly without runtime search.
-	* Returns multiple paths when a property appears in multiple union branches.
-	*/ buildMutatingAccessors(targetName, targetDef, parts) {
-		let accessors = [{
-			prefix: `${targetName}.type`,
-			def: targetDef
-		}];
-		const clones = [];
-		for (let i = 0; i < parts.length; i++) {
-			const nextAccessors = [];
-			for (const { prefix, def } of accessors) {
-				const results = this.buildPropPaths(def, parts[i]);
-				if (results.length > 0) for (const result of results) if (i < parts.length - 1) {
-					if (result.propDef && isRef(result.propDef)) clones.push({
-						parentPath: prefix,
-						propName: parts[i]
-					});
-					nextAccessors.push({
-						prefix: `${prefix}${result.path}?.type`,
-						def: result.propDef
-					});
-				} else nextAccessors.push({
-					prefix: `${prefix}${result.path}?`,
-					def: result.propDef
-				});
-else {
-					const suffix = `.props.get("${escapeQuotes(parts[i])}")${i < parts.length - 1 ? "?.type" : "?"}`;
-					nextAccessors.push({
-						prefix: `${prefix}${suffix}`,
-						def: undefined
-					});
-				}
-			}
-			accessors = nextAccessors;
-		}
-		return {
-			accessors: accessors.map((a) => a.prefix),
-			clones
-		};
-	}
-	/**
-	* Finds a property in a type tree at compile time, returning all
-	* matching runtime path strings and prop definitions for further chaining.
-	* Returns multiple results when the same property appears in different union branches.
-	*/ buildPropPaths(def, propName) {
-		if (!def) return [];
-		def = this.doc.mergeIntersection(def);
-		if (isRef(def)) {
-			const ref = def;
-			const unwound = this.doc.unwindType(ref.id, ref.chain)?.def;
-			return this.buildPropPaths(unwound, propName);
-		}
-		if (isInterface(def)) return this.buildPropPaths(def.getDefinition(), propName);
-		if (isStructure(def)) {
-			const prop = def.props.get(propName);
-			if (prop) return [{
-				path: `.props.get("${escapeQuotes(propName)}")`,
-				propDef: prop.getDefinition()
-			}];
-			return [];
-		}
-		if (isGroup(def)) {
-			const group = def;
-			const items = group.unwrap();
-			const results = [];
-			for (let i = 0; i < items.length; i++) for (const result of this.buildPropPaths(items[i], propName)) results.push({
-				path: `.items[${i}].type${result.path}`,
-				propDef: result.propDef
-			});
-			return results;
-		}
-		return [];
-	}
-	constructor(doc, opts) {
-		super(doc), _define_property(this, "opts", void 0), _define_property(this, "postAnnotate", void 0), _define_property(this, "_adHocAnnotations", void 0), _define_property(this, "_propPath", void 0), _define_property(this, "typeIds", void 0), this.opts = opts, this.postAnnotate = [], this._adHocAnnotations = null, this._propPath = [], this.typeIds = new Map();
-	}
-};
-
-//#endregion
-//#region packages/typescript/src/plugin.ts
-function resolveJsonSchemaMode(opts) {
-	if (opts?.jsonSchema !== undefined) return opts.jsonSchema;
-	return false;
-}
-const tsPlugin = (opts) => {
-	return {
-		name: "typescript",
-		render(doc, format) {
-			if (format === "dts" || format === DEFAULT_FORMAT) return [{
-				fileName: `${doc.name}.d.ts`,
-				content: new TypeRenderer(doc, opts).render()
-			}];
-			if (format === "js") return [{
-				fileName: `${doc.name}.js`,
-				content: new JsRenderer(doc, opts).render()
-			}];
-		},
-		async buildEnd(output, format, repo) {
-			if (format === "dts" || format === DEFAULT_FORMAT) {
-				const annotations = await repo.getUsedAnnotations();
-				const tags = await repo.getPrimitivesTags() || new Set();
-				const rendered = [];
-				for (const [key, val] of Object.entries(annotations)) {
-					const multiple = val.multiple;
-					const typeLine = Array.from(val.types).map((t) => {
-						if (t.type === "object" && "props" in t) return `{ ${Object.entries(t.props).map(([k, v]) => `${wrapProp(k)}${v.optional ? "?" : ""}: ${v.type}`).join(", ")} }`;
-else return "optional" in t && t.optional ? `${t.type} | true` : t.type;
-					}).join(" | ");
-					rendered.push(`${wrapProp(key)}: ${multiple ? "(" : ""}${typeLine}${multiple ? ")[]" : ""}`);
-				}
-				const renderedTags = Array.from(tags).map((f) => `"${escapeQuotes(f)}"`).join(" | ");
-				output.push({
-					content: "// prettier-ignore-start\n/* eslint-disable */\n/* oxlint-disable */\n/**\n * 🪄 This file was generated by Atscript\n * It is generated based on annotations used in this project\n * Do not edit this file!\n *\n * Use `npx asc -f dts` command to re-generate this file\n */\nexport {}\n\ndeclare global {\n  interface AtscriptMetadata {\n    " + rendered.join("\n    ") + "\n  }\n" + "  type AtscriptPrimitiveTags = " + renderedTags + "\n" + "}\n" + "// prettier-ignore-end",
-					fileName: "atscript.d.ts",
-					source: "",
-					target: path.join(repo.root, "atscript.d.ts")
-				});
-			}
-		}
-	};
-};
-
-//#endregion
 export { tsPlugin as default, tsPlugin };