@atscript/typescript 0.1.88 → 0.1.90

package/dist/cli.cjs

@@ -1,5 +1,4 @@
-"use strict";
-//#region rolldown:runtime
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -7,12 +6,16 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
 	}
 	return to;
 };
@@ -22,14 +25,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const __moostjs_event_cli = __toESM(require("@moostjs/event-cli"));
-const __atscript_core = __toESM(require("@atscript/core"));
-const moost = __toESM(require("moost"));
-const fs = __toESM(require("fs"));
-const path = __toESM(require("path"));
-const node_module = __toESM(require("node:module"));
-const node_readline = __toESM(require("node:readline"));
-const node_url = __toESM(require("node:url"));
+let _moostjs_event_cli = require("@moostjs/event-cli");
+let _atscript_core = require("@atscript/core");
+let moost = require("moost");
+let fs = require("fs");
+let path = require("path");
+path = __toESM(path);
+let node_module = require("node:module");
+let node_readline = require("node:readline");
+let node_url = require("node:url");
 
 //#region packages/typescript/src/codegen/code-printer.ts
 function _define_property$7(obj, key, value) {
@@ -39,7 +43,7 @@ function _define_property$7(obj, key, value) {
 		configurable: true,
 		writable: true
 	});
-else obj[key] = value;
+	else obj[key] = value;
 	return obj;
 }
 var CodePrinter = class {
@@ -100,7 +104,7 @@ var CodePrinter = class {
 	* 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);
+		else if (this.currentLine.length > 0) this.lines.push(this.currentLine);
 		return this.lines.join("\n");
 	}
 	doBlock(pair, withNewLine) {
@@ -118,7 +122,7 @@ else if (this.currentLine.length > 0) this.lines.push(this.currentLine);
 		const closing = this.blockStack.pop();
 		this.unindent();
 		if (withNewLine) this.writeln(closing);
-else this.write(closing);
+		else this.write(closing);
 		return this;
 	}
 	indentString() {
@@ -142,7 +146,7 @@ function _define_property$6(obj, key, value) {
 		configurable: true,
 		writable: true
 	});
-else obj[key] = value;
+	else obj[key] = value;
 	return obj;
 }
 var BaseRenderer = class extends CodePrinter {
@@ -160,21 +164,21 @@ var BaseRenderer = class extends CodePrinter {
 	renderInterface(node) {}
 	renderType(node) {}
 	renderAnnotate(node) {}
-	transformFromPath(path$4) {
-		return `${path$4}.as`;
+	transformFromPath(path) {
+		return `${path}.as`;
 	}
 	renderImport(node) {
 		const def = node.getDefinition();
 		const refs = [];
 		const from = this.transformFromPath(node.token("path").text);
 		let isUnusedImport = true;
-		if ((0, __atscript_core.isGroup)(def)) {
-			for (const child of def.unwrap()) if ((0, __atscript_core.isRef)(child) && !this.unused.has(child.id)) {
-				const node$1 = child;
-				refs.push(node$1.id);
+		if ((0, _atscript_core.isGroup)(def)) {
+			for (const child of def.unwrap()) if ((0, _atscript_core.isRef)(child) && !this.unused.has(child.id)) {
+				const node = child;
+				refs.push(node.id);
 				isUnusedImport = false;
 			}
-		} else if ((0, __atscript_core.isRef)(def) && !this.unused.has(def.id)) {
+		} else if ((0, _atscript_core.isRef)(def) && !this.unused.has(def.id)) {
 			refs.push(def.id);
 			isUnusedImport = false;
 		}
@@ -182,22 +186,18 @@ var BaseRenderer = class extends CodePrinter {
 	}
 	renderNode(node) {
 		switch (node.entity) {
-			case "interface": {
+			case "interface":
 				this.renderInterface(node);
 				break;
-			}
-			case "type": {
+			case "type":
 				this.renderType(node);
 				break;
-			}
-			case "import": {
+			case "import":
 				this.renderImport(node);
 				break;
-			}
-			case "annotate": {
+			case "annotate":
 				this.renderAnnotate(node);
 				break;
-			}
 			default: break;
 		}
 	}
@@ -209,7 +209,13 @@ var BaseRenderer = class extends CodePrinter {
 //#endregion
 //#region packages/typescript/src/codegen/utils.ts
 const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-function wrapProp(name) {
+/**
+* Wraps a property name in double quotes if it's not a valid identifier (contains special chars, etc.).
+*
+* Examples:
+*  - "validName" => "validName"
+*  - "some-prop" => "\"some-prop\""
+*/ function wrapProp(name) {
 	if (!validIdentifier.test(name)) return `"${escapeQuotes(name)}"`;
 	return name;
 }
@@ -226,7 +232,7 @@ function _define_property$5(obj, key, value) {
 		configurable: true,
 		writable: true
 	});
-else obj[key] = value;
+	else obj[key] = value;
 	return obj;
 }
 var TypeRenderer = class TypeRenderer extends BaseRenderer {
@@ -255,8 +261,8 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 			this.write("unknown");
 			return;
 		}
-		if ((0, __atscript_core.isStructure)(def)) return this.renderStructure(def);
-		if ((0, __atscript_core.isGroup)(def)) {
+		if ((0, _atscript_core.isStructure)(def)) return this.renderStructure(def);
+		if ((0, _atscript_core.isGroup)(def)) {
 			const tuple = def.entity === "tuple";
 			const operator = tuple ? ", " : ` ${def.op} `;
 			const children = def.unwrap();
@@ -269,14 +275,14 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 			}
 			return this.write(tuple ? "]" : hasSubgroup ? ")" : "");
 		}
-		if ((0, __atscript_core.isConst)(def)) {
+		if ((0, _atscript_core.isConst)(def)) {
 			const name = def.token("identifier")?.type === "number" ? def.id : `"${escapeQuotes(def.id)}"`;
 			return this.write(name);
 		}
-		if ((0, __atscript_core.isRef)(def)) {
+		if ((0, _atscript_core.isRef)(def)) {
 			const node = def;
 			const unwound = this.doc.unwindType(node.id, node.chain);
-			if ((0, __atscript_core.isPrimitive)(unwound?.def)) {
+			if ((0, _atscript_core.isPrimitive)(unwound?.def)) {
 				this.write(renderPrimitiveTypeDef(unwound.def.config.type));
 				if (node.hasChain) this.write(` /* ${node.chain.map((c) => c.text).join(".")} */`);
 				return;
@@ -285,21 +291,20 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 			for (const c of node.chain) name += `["${escapeQuotes(c.text)}"]`;
 			return this.write(name);
 		}
-		if ((0, __atscript_core.isArray)(def)) {
-			const node = def;
-			const def2 = node.getDefinition();
+		if ((0, _atscript_core.isArray)(def)) {
+			const def2 = def.getDefinition();
 			const isGrp = def2?.entity === "group";
 			if (isGrp) this.write("(");
 			this.renderTypeDef(def2);
 			if (isGrp) this.write(")");
 			return this.write("[]");
 		}
-		if ((0, __atscript_core.isPrimitive)(def)) return this.write(renderPrimitiveTypeDef(def.config.type));
+		if ((0, _atscript_core.isPrimitive)(def)) return this.write(renderPrimitiveTypeDef(def.config.type));
 	}
 	renderStructure(struct, asClass, interfaceNode, filterProps) {
 		this.blockln("{}");
 		const patterns = [];
-		const propsDefs = new Set();
+		const propsDefs = /* @__PURE__ */ new Set();
 		for (const prop of struct.props.values()) {
 			if (filterProps?.has(prop.id)) continue;
 			if (prop.token("identifier")?.pattern) {
@@ -366,14 +371,14 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 				let firstParentProps;
 				if (firstParentUnwound?.def) {
 					let fpDef = firstParentUnwound.def;
-					if ((0, __atscript_core.isInterface)(fpDef)) {
+					if ((0, _atscript_core.isInterface)(fpDef)) {
 						if (fpDef.hasExtends) {
 							const fpResolved = firstParentUnwound.doc.resolveInterfaceExtends(fpDef);
-							if (fpResolved && (0, __atscript_core.isStructure)(fpResolved)) firstParentProps = fpResolved.props;
+							if (fpResolved && (0, _atscript_core.isStructure)(fpResolved)) firstParentProps = fpResolved.props;
 						}
 						if (!firstParentProps) fpDef = fpDef.getDefinition() || fpDef;
 					}
-					if (!firstParentProps && (0, __atscript_core.isStructure)(fpDef)) firstParentProps = fpDef.props;
+					if (!firstParentProps && (0, _atscript_core.isStructure)(fpDef)) firstParentProps = fpDef.props;
 				}
 				this.renderStructure(resolved, node.id, node, firstParentProps);
 			} else this.writeln("{}");
@@ -381,7 +386,7 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 			this.write(`class ${node.id} `);
 			const struct = node.getDefinition();
 			if (struct?.entity === "structure") this.renderStructure(struct, node.id, node);
-else this.writeln("{}");
+			else this.writeln("{}");
 		}
 		this.writeln();
 	}
@@ -421,12 +426,12 @@ else this.writeln("{}");
 		let typeDef = "TAtscriptTypeDef";
 		if (inputDef) {
 			let realDef = inputDef;
-			if ((0, __atscript_core.isRef)(inputDef)) realDef = this.doc.unwindType(inputDef.id, inputDef.chain)?.def || realDef;
+			if ((0, _atscript_core.isRef)(inputDef)) realDef = this.doc.unwindType(inputDef.id, inputDef.chain)?.def || realDef;
 			realDef = this.doc.mergeIntersection(realDef);
-			if ((0, __atscript_core.isStructure)(realDef) || (0, __atscript_core.isInterface)(realDef)) typeDef = `TAtscriptTypeObject<keyof ${name}, ${name}>`;
-else if ((0, __atscript_core.isGroup)(realDef)) typeDef = `TAtscriptTypeComplex<${name}>`;
-else if ((0, __atscript_core.isArray)(realDef)) typeDef = `TAtscriptTypeArray<${name}>`;
-else if ((0, __atscript_core.isPrimitive)(realDef)) typeDef = `TAtscriptTypeFinal<${name}>`;
+			if ((0, _atscript_core.isStructure)(realDef) || (0, _atscript_core.isInterface)(realDef)) typeDef = `TAtscriptTypeObject<keyof ${name}, ${name}>`;
+			else if ((0, _atscript_core.isGroup)(realDef)) typeDef = `TAtscriptTypeComplex<${name}>`;
+			else if ((0, _atscript_core.isArray)(realDef)) typeDef = `TAtscriptTypeArray<${name}>`;
+			else if ((0, _atscript_core.isPrimitive)(realDef)) typeDef = `TAtscriptTypeFinal<${name}>`;
 		}
 		this.writeln(`const __is_atscript_annotated_type: true`);
 		this.writeln(`const type: ${typeDef}`);
@@ -462,12 +467,12 @@ else if ((0, __atscript_core.isPrimitive)(realDef)) typeDef = `TAtscriptTypeFina
 	*   not individually queryable)
 	* - **Leaf fields** → their original TypeScript type
 	*/ renderFlat(node) {
-		this.renderFlatMap("__flat", (0, __atscript_core.flattenInterfaceNode)(this.doc, node));
+		this.renderFlatMap("__flat", (0, _atscript_core.flattenInterfaceNode)(this.doc, node));
 	}
 	/**
 	* Renders the `static __ownProps` property — table-owned fields only (no nav props).
 	*/ renderOwnProps(node) {
-		this.renderFlatMap("__ownProps", (0, __atscript_core.flattenInterfaceNode)(this.doc, node, { skipNavProps: true }), {
+		this.renderFlatMap("__ownProps", (0, _atscript_core.flattenInterfaceNode)(this.doc, node, { skipNavProps: true }), {
 			leadingNewline: true,
 			trailingNewline: true
 		});
@@ -484,21 +489,20 @@ else if ((0, __atscript_core.isPrimitive)(realDef)) typeDef = `TAtscriptTypeFina
 		if (opts?.leadingNewline) this.writeln();
 		this.write(`static ${propName}: `);
 		this.blockln("{}");
-		for (const [path$4, descriptor] of flatMap) {
-			this.write(`"${escapeQuotes(path$4)}"`);
+		for (const [path, descriptor] of flatMap) {
+			this.write(`"${escapeQuotes(path)}"`);
 			if (descriptor.optional) this.write("?");
 			this.write(": ");
 			if (descriptor.intermediate) this.writeln("never");
-else if (descriptor.dbJson) this.writeln("string");
-else {
+			else if (descriptor.dbJson) this.writeln("string");
+			else {
 				const originalDef = descriptor.propNode?.getDefinition();
-				const defToRender = originalDef && !((0, __atscript_core.isGroup)(descriptor.def) && descriptor.def !== originalDef) ? originalDef : descriptor.def;
-				const renderedDef = this.renderTypeDefString(defToRender);
-				renderedDef.split("\n").forEach((l) => this.writeln(l));
+				const defToRender = originalDef && !((0, _atscript_core.isGroup)(descriptor.def) && descriptor.def !== originalDef) ? originalDef : descriptor.def;
+				this.renderTypeDefString(defToRender).split("\n").forEach((l) => this.writeln(l));
 			}
 		}
 		if (opts?.trailingNewline) this.popln();
-else this.pop();
+		else this.pop();
 	}
 	/**
 	* Renders the `static __navProps` property — a map of navigation property names
@@ -510,12 +514,12 @@ else this.pop();
 		let struct;
 		if (node.hasExtends) struct = this.doc.resolveInterfaceExtends(node);
 		if (!struct) struct = node.getDefinition();
-		if (!struct || !(0, __atscript_core.isStructure)(struct)) return;
+		if (!struct || !(0, _atscript_core.isStructure)(struct)) return;
 		const structNode = struct;
 		const navProps = [];
 		for (const [name, prop] of structNode.props) {
 			if (prop.token("identifier")?.pattern) continue;
-			if ((0, __atscript_core.hasNavPropAnnotation)(prop)) navProps.push({
+			if ((0, _atscript_core.hasNavPropAnnotation)(prop)) navProps.push({
 				name,
 				prop
 			});
@@ -529,10 +533,8 @@ else this.pop();
 			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");
+			if (propDef) this.renderTypeDefString(propDef).split("\n").forEach((l) => this.writeln(l));
+			else this.writeln("unknown");
 		}
 		this.popln();
 	}
@@ -541,10 +543,10 @@ else this.pop();
 		let struct;
 		if (node.hasExtends) struct = this.doc.resolveInterfaceExtends(node);
 		if (!struct) struct = node.getDefinition();
-		if (!struct || !(0, __atscript_core.isStructure)(struct)) return;
+		if (!struct || !(0, _atscript_core.isStructure)(struct)) return;
 		const structNode = struct;
 		const pkProps = [];
-		const uniqueByIndex = new Map();
+		const uniqueByIndex = /* @__PURE__ */ new Map();
 		for (const [name, prop] of structNode.props) {
 			if (prop.token("identifier")?.pattern) continue;
 			if (isMongoCollection && name === "_id") continue;
@@ -578,7 +580,7 @@ else this.pop();
 			mongoIdType ?? (mongoIdType = "string");
 		}
 		const uniqueTypes = [];
-		const seenTypes = new Set();
+		const seenTypes = /* @__PURE__ */ new Set();
 		for (const { prop } of uniqueProps) {
 			const rendered = this.renderTypeDefString(prop.getDefinition()).trim();
 			if (!seenTypes.has(rendered)) {
@@ -589,8 +591,8 @@ else this.pop();
 		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) {
+		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();
@@ -601,8 +603,7 @@ else if (pkProps.length === 1) {
 			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.renderTypeDefString(prop.getDefinition()).split("\n").forEach((l) => this.writeln(l));
 			}
 			this.pop();
 			this.writeln(uniqueSuffix);
@@ -612,7 +613,7 @@ else if (pkProps.length === 1) {
 		let struct;
 		if (node.hasExtends) struct = this.doc.resolveInterfaceExtends(node);
 		if (!struct) struct = node.getDefinition();
-		if (!struct || !(0, __atscript_core.isStructure)(struct)) return;
+		if (!struct || !(0, _atscript_core.isStructure)(struct)) return;
 		const structNode = struct;
 		const dims = [];
 		const measures = [];
@@ -627,18 +628,16 @@ else if (pkProps.length === 1) {
 		if (measures.length > 0) this.writeln(`static __measure: ${measures.map((m) => `"${escapeQuotes(m)}"`).join(" | ")}`);
 	}
 	phantomPropType(def) {
-		if (!def) return undefined;
-		if ((0, __atscript_core.isPrimitive)(def) && def.config.type === "phantom") return def.id;
-		if ((0, __atscript_core.isRef)(def)) {
+		if (!def) return;
+		if ((0, _atscript_core.isPrimitive)(def) && def.config.type === "phantom") return def.id;
+		if ((0, _atscript_core.isRef)(def)) {
 			const ref = def;
 			const unwound = this.doc.unwindType(ref.id, ref.chain)?.def;
-			if ((0, __atscript_core.isPrimitive)(unwound) && unwound.config.type === "phantom") return ref.hasChain ? `${ref.id}.${ref.chain.map((c) => c.text).join(".")}` : ref.id;
+			if ((0, _atscript_core.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);
+		const decl = (doc || this.doc).getDeclarationOwnerNode(name);
 		if (!decl?.node) return false;
 		if (decl.node.entity === "type") return true;
 		if (decl.node.entity === "interface") return false;
@@ -666,10 +665,7 @@ function renderPrimitiveTypeDef(def) {
 		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} }`;
-		}
+		case "object": return `{ ${Object.entries(def.props).map(([key, val]) => `${wrapProp(key)}${typeof val === "object" && val.optional ? "?" : ""}: ${renderPrimitiveTypeDef(val)}`).join("; ")} }`;
 		default: return "unknown";
 	}
 }
@@ -683,16 +679,36 @@ function _define_property$4(obj, key, value) {
 		configurable: true,
 		writable: true
 	});
-else obj[key] = value;
+	else obj[key] = value;
 	return obj;
 }
-const regexCache = new Map();
-var Validator = class {
+const regexCache = /* @__PURE__ */ new Map();
+/**
+* Validates values against an {@link TAtscriptAnnotatedType} definition.
+*
+* `DataType` is automatically inferred from the type definition's phantom generic,
+* enabling the {@link validate} method to act as a type guard.
+*
+* @example
+* ```ts
+* // From a generated interface class:
+* const validator = new Validator(MyInterface)
+* if (validator.validate(data, true)) {
+*   data // narrowed to MyInterface
+* }
+*
+* // Or use the built-in factory:
+* MyInterface.validator().validate(data)
+* ```
+*
+* @typeParam T - The annotated type definition.
+* @typeParam DataType - The TypeScript type that `validate` narrows to (auto-inferred).
+*/ var Validator = class {
 	buildPath() {
 		if (this.depth <= 0) return "";
-		let path$4 = this.pathSegments[0];
-		for (let i = 1; i < this.depth; i++) path$4 += `.${this.pathSegments[i]}`;
-		return path$4;
+		let path = this.pathSegments[0];
+		for (let i = 1; i < this.depth; i++) path += `.${this.pathSegments[i]}`;
+		return path;
 	}
 	push(name) {
 		this.pathSegments[this.depth] = name;
@@ -702,21 +718,21 @@ var Validator = class {
 	pop(saveErrors) {
 		this.depth--;
 		const popped = this.stackErrors.pop();
-		if (saveErrors && popped !== null && popped !== undefined && popped.length > 0) for (const err of popped) this.error(err.message, err.path, err.details);
+		if (saveErrors && popped !== null && popped !== void 0 && popped.length > 0) for (const err of popped) this.error(err.message, err.path, err.details);
 		return popped;
 	}
 	clear() {
 		this.stackErrors[this.stackErrors.length - 1] = null;
 		if (this.limitExceeded) this.limitExceeded = false;
 	}
-	error(message, path$4, details) {
+	error(message, path, details) {
 		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$4 || this.buildPath(),
+			path: path || this.buildPath(),
 			message
 		};
 		if (details?.length) error.details = details;
@@ -743,7 +759,7 @@ var Validator = class {
 		this.limitExceeded = false;
 		this.context = context;
 		const passed = this.validateSafe(this.def, value);
-		this.context = undefined;
+		this.context = void 0;
 		if (!passed) {
 			if (safe) return false;
 			this.throw();
@@ -754,13 +770,13 @@ var Validator = class {
 		if (this.limitExceeded) return false;
 		if (this.hasReplace) {
 			let replaced = this.replaceCache.get(def);
-			if (replaced === undefined) {
+			if (replaced === void 0) {
 				replaced = this.opts.replace(def, this.buildPath());
 				this.replaceCache.set(def, replaced);
 			}
 			def = replaced;
 		}
-		if (def.optional && (value === undefined || value === null)) return true;
+		if (def.optional && (value === void 0 || value === null)) return true;
 		if (this.hasPlugins) for (const plugin of this.opts.plugins) {
 			const result = plugin(this, def, value);
 			if (result === false || result === true) return result;
@@ -772,10 +788,9 @@ var Validator = class {
 	}
 	validateAnnotatedType(def, value) {
 		switch (def.type.kind) {
-			case "": {
+			case "":
 				if (def.type.designType === "phantom") return true;
 				return this.validatePrimitive(def, value);
-			}
 			case "object": return this.validateObject(def, value);
 			case "array": return this.validateArray(def, value);
 			case "union": return this.validateUnion(def, value);
@@ -796,10 +811,10 @@ var Validator = class {
 			const branchErrors = this.stackErrors.pop();
 			if (this.limitExceeded) this.limitExceeded = false;
 			if (branchErrors) if (details) for (const err of branchErrors) details.push(err);
-else details = branchErrors;
+			else details = branchErrors;
 		}
 		const expected = items.map((item, i) => `[${item.type.kind || item.type.designType}(${i})]`).join(", ");
-		this.error(`Value does not match any of the allowed types: ${expected}`, undefined, details);
+		this.error(`Value does not match any of the allowed types: ${expected}`, void 0, details);
 		return false;
 	}
 	validateIntersection(def, value) {
@@ -849,8 +864,8 @@ else details = branchErrors;
 		const uniqueItems = def.metadata.get("expect.array.uniqueItems");
 		if (uniqueItems) {
 			const separator = "▼↩";
-			const seen = new Set();
-			const keyProps = new Set();
+			const seen = /* @__PURE__ */ new Set();
+			const keyProps = /* @__PURE__ */ new Set();
 			if (def.type.of.type.kind === "object") {
 				for (const [key, val] of def.type.of.type.props.entries()) if (val.metadata.get("expect.array.key")) keyProps.add(key);
 			}
@@ -892,10 +907,10 @@ else details = branchErrors;
 		let keysToStrip;
 		let skipList;
 		if (this.opts.skipList) {
-			const path$4 = this.depth > 0 ? `${this.buildPath()}.` : "";
-			for (const item of this.opts.skipList) if (item.startsWith(path$4)) {
-				const key = item.slice(path$4.length);
-				if (!skipList) skipList = new Set();
+			const path = this.depth > 0 ? `${this.buildPath()}.` : "";
+			for (const item of this.opts.skipList) if (item.startsWith(path)) {
+				const key = item.slice(path.length);
+				if (!skipList) skipList = /* @__PURE__ */ new Set();
 				skipList.add(key);
 			}
 		}
@@ -903,12 +918,12 @@ else details = branchErrors;
 		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.buildPath());
 		for (const [key, item] of def.type.props.entries()) {
 			if (skipList && skipList.has(key) || isPhantomType(item)) continue;
-			if (value[key] === undefined) {
+			if (value[key] === void 0) {
 				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.depth === 0) continue;
 			}
 			this.push(key);
 			if (this.validateSafe(item, value[key])) this.pop(false);
-else {
+			else {
 				passed = false;
 				this.pop(true);
 				if (this.limitExceeded) return false;
@@ -958,7 +973,7 @@ else {
 		return passed;
 	}
 	validatePrimitive(def, value) {
-		if (def.type.value !== undefined) {
+		if (def.type.value !== void 0) {
 			if (value !== def.type.value) {
 				this.error(`Expected ${def.type.value}, got ${value}`);
 				return false;
@@ -967,47 +982,41 @@ else {
 		}
 		const typeOfValue = Array.isArray(value) ? "array" : typeof value;
 		switch (def.type.designType) {
-			case "never": {
+			case "never":
 				this.error(`This type is impossible, must be an internal problem`);
 				return false;
-			}
 			case "any": return true;
-			case "string": {
+			case "string":
 				if (typeOfValue !== def.type.designType) {
 					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
 					return false;
 				}
 				return this.validateString(def, value);
-			}
-			case "number": {
+			case "number":
 				if (typeOfValue !== def.type.designType) {
 					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
 					return false;
 				}
 				return this.validateNumber(def, value);
-			}
-			case "boolean": {
+			case "boolean":
 				if (typeOfValue !== def.type.designType) {
 					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
 					return false;
 				}
 				return this.validateBoolean(def, value);
-			}
-			case "undefined": {
-				if (value !== undefined) {
+			case "undefined":
+				if (value !== void 0) {
 					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
 					return false;
 				}
 				return true;
-			}
-			case "null": {
+			case "null":
 				if (value !== null) {
 					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
 					return false;
 				}
 				return true;
-			}
-			case "decimal": {
+			case "decimal":
 				if (typeOfValue !== "string") {
 					this.error(`Expected string (decimal), got ${typeOfValue}`);
 					return false;
@@ -1017,7 +1026,6 @@ else {
 					return false;
 				}
 				return true;
-			}
 			default: throw new Error(`Unknown type "${def.type.designType}"`);
 		}
 	}
@@ -1132,10 +1140,10 @@ else {
 		};
 		this.hasPlugins = this.opts.plugins.length > 0;
 		this.hasReplace = typeof this.opts.replace === "function";
-		if (this.hasReplace) this.replaceCache = new WeakMap();
+		if (this.hasReplace) this.replaceCache = /* @__PURE__ */ new WeakMap();
 	}
 };
-var ValidatorError = class extends Error {
+/** Error thrown by {@link Validator.validate} when validation fails. Contains structured error details. */ var ValidatorError = class extends Error {
 	constructor(errors) {
 		super(`${errors[0].path ? errors[0].path + ": " : ""}${errors[0].message}`), _define_property$4(this, "errors", void 0), _define_property$4(this, "name", void 0), this.errors = errors, this.name = "Validation Error";
 	}
@@ -1151,7 +1159,10 @@ const COMPLEX_KINDS = new Set([
 /** Shared validator method reused by all annotated type nodes. */ function validatorMethod(opts) {
 	return new Validator(this, opts);
 }
-function createAnnotatedTypeNode(type, metadata, opts) {
+/**
+* Creates a minimal annotated type node from a type def and metadata map.
+* Centralises the shape so callers never duplicate the boilerplate.
+*/ function createAnnotatedTypeNode(type, metadata, opts) {
 	return {
 		__is_atscript_annotated_type: true,
 		type,
@@ -1162,22 +1173,27 @@ function createAnnotatedTypeNode(type, metadata, opts) {
 		ref: opts?.ref
 	};
 }
-function isAnnotatedType(type) {
+/**
+* Type Guard to check if a type is atscript-annotated
+*/ function isAnnotatedType(type) {
 	return type && type.__is_atscript_annotated_type;
 }
-function annotate(metadata, key, value, asArray) {
+/**
+* Standalone annotate function that handles both replace and append (array) strategies.
+* Used by the handle's .annotate() method and by generated mutation statements.
+*/ function annotate(metadata, key, value, asArray) {
 	if (!metadata) return;
 	if (asArray) if (metadata.has(key)) {
 		const a = metadata.get(key);
 		if (Array.isArray(a)) a.push(value);
-else metadata.set(key, [a, value]);
+		else metadata.set(key, [a, value]);
 	} else metadata.set(key, [value]);
-else metadata.set(key, value);
+	else metadata.set(key, value);
 }
 function cloneTypeDef(type) {
 	if (type.kind === "object") {
 		const obj = type;
-		const props = new Map();
+		const props = /* @__PURE__ */ new Map();
 		for (const [k, v] of obj.props) props.set(k, createAnnotatedTypeNode(v.type, new Map(v.metadata), {
 			id: v.id,
 			optional: v.optional
@@ -1210,18 +1226,36 @@ function cloneTypeDef(type) {
 		tags: new Set(type.tags)
 	};
 }
-function defineAnnotatedType(_kind, base) {
+/**
+* Creates a builder handle for constructing a {@link TAtscriptAnnotatedType} at runtime.
+*
+* This is primarily used by generated `.as.js` code. The returned handle provides
+* a fluent API for setting the type definition, metadata, and properties.
+*
+* @example
+* ```ts
+* const handle = defineAnnotatedType('object')
+*   .prop('name', defineAnnotatedType().designType('string').$type)
+*   .prop('age', defineAnnotatedType().designType('number').$type)
+*
+* handle.$type // the resulting TAtscriptAnnotatedType
+* ```
+*
+* @param _kind - The kind of type to create (e.g. `'object'`, `'array'`, `'union'`). Defaults to `''` (primitive/final).
+* @param base - Optional existing object to augment with annotated type fields.
+* @returns A builder handle for fluent type construction.
+*/ function defineAnnotatedType(_kind, base) {
 	const kind = _kind || "";
-	const baseProvided = base !== undefined;
+	const baseProvided = base !== void 0;
 	const type = base?.type || {};
 	type.kind = kind;
 	if (COMPLEX_KINDS.has(kind)) type.items = [];
 	if (kind === "object") {
-		type.props = new Map();
+		type.props = /* @__PURE__ */ new Map();
 		type.propsPatterns = [];
 	}
-	type.tags = new Set();
-	const metadata = base?.metadata || new Map();
+	type.tags = /* @__PURE__ */ new Set();
+	const metadata = base?.metadata || /* @__PURE__ */ new Map();
 	const payload = {
 		__is_atscript_annotated_type: true,
 		metadata,
@@ -1229,7 +1263,7 @@ function defineAnnotatedType(_kind, base) {
 		validator: validatorMethod
 	};
 	base = base ? Object.assign(base, payload) : payload;
-	const handle = {
+	return {
 		$type: base,
 		$def: type,
 		$metadata: metadata,
@@ -1272,15 +1306,15 @@ function defineAnnotatedType(_kind, base) {
 			for (const [key, value] of fromMetadata.entries()) if (!ignore || !ignore.has(key)) this.$metadata.set(key, value);
 			return this;
 		},
-		refTo(type$1, chain) {
+		refTo(type, chain) {
 			const node = this.$type;
-			if (isAnnotatedType(type$1)) {
-				let newBase = type$1;
-				const typeName = type$1.name || "Unknown";
+			if (isAnnotatedType(type)) {
+				let newBase = type;
+				const typeName = type.name || "Unknown";
 				if (chain) for (let i = 0; i < chain.length; i++) {
 					const c = chain[i];
 					if (newBase.type.kind === "object" && newBase.type.props.has(c)) newBase = newBase.type.props.get(c);
-else {
+					else {
 						const keys = chain.slice(0, i + 1).map((k) => `["${k}"]`).join("");
 						throw new Error(`Can't find prop ${typeName}${keys}`);
 					}
@@ -1288,11 +1322,11 @@ else {
 				node.type = baseProvided ? cloneTypeDef(newBase.type) : newBase.type;
 				node.id = node.id ?? newBase.id;
 				if (chain && chain.length > 0) node.ref = {
-					type: () => type$1,
+					type: () => type,
 					field: chain.join(".")
 				};
-			} else if (typeof type$1 === "function") {
-				const lazyType = type$1;
+			} else if (typeof type === "function") {
+				const lazyType = type;
 				const ownId = node.id;
 				node.ref = {
 					type: lazyType,
@@ -1312,7 +1346,7 @@ else {
 						}
 						let target = t;
 						if (chain) for (const c of chain) if (target.type.kind === "object" && target.type.props.has(c)) target = target.type.props.get(c);
-else return t.type;
+						else return t.type;
 						node.id = ownId ?? target.id;
 						const resolved = baseProvided ? cloneTypeDef(target.type) : target.type;
 						Object.defineProperty(node, "type", {
@@ -1324,7 +1358,7 @@ else return t.type;
 					},
 					configurable: true
 				});
-			} else throw new TypeError(`${type$1} is not annotated type`);
+			} else throw new TypeError(`${type} is not annotated type`);
 			return this;
 		},
 		annotate(key, value, asArray) {
@@ -1336,15 +1370,29 @@ else return t.type;
 			return this;
 		}
 	};
-	return handle;
 }
-function isPhantomType(def) {
+/**
+* Checks whether an annotated type is a phantom type.
+*
+* Phantom types do not affect the data type, validation, or schema,
+* but are discoverable via runtime type traversal.
+*/ function isPhantomType(def) {
 	return def.type.kind === "" && def.type.designType === "phantom";
 }
 
 //#endregion
 //#region packages/typescript/src/runtime/traverse.ts
-function forAnnotatedType(def, handlers) {
+/**
+* Type-safe dispatch over `TAtscriptAnnotatedType` by its `type.kind`.
+*
+* Provides the common `switch (def.type.kind)` pattern used by
+* the validator, JSON-schema builder, and serializer.
+* Each caller supplies its own handlers that control recursion.
+*
+* When a `phantom` handler is provided, phantom types (`designType === 'phantom'`)
+* are dispatched to it instead of `final`. This allows consumers to skip or
+* handle phantom props without polluting their `final` handler.
+*/ function forAnnotatedType(def, handlers) {
 	switch (def.type.kind) {
 		case "": {
 			const typed = def;
@@ -1362,21 +1410,27 @@ function forAnnotatedType(def, handlers) {
 
 //#endregion
 //#region packages/typescript/src/runtime/json-schema.ts
-function detectDiscriminator(items) {
+/**
+* Detects a discriminator property across union items.
+*
+* Scans all items for object-typed members that share a common property
+* with distinct const/literal values. If exactly one such property exists,
+* it is returned as the discriminator. Returns `null` when no qualifying
+* property exists, or when more than one does (ambiguous).
+*/ function detectDiscriminator(items) {
 	if (items.length < 2) return null;
 	for (const item of items) if (item.type.kind !== "object") return null;
 	const firstObj = items[0].type;
 	const candidates = [];
-	for (const [propName, propType] of firstObj.props.entries()) if (propType.type.kind === "" && propType.type.value !== undefined) candidates.push(propName);
+	for (const [propName, propType] of firstObj.props.entries()) if (propType.type.kind === "" && propType.type.value !== void 0) candidates.push(propName);
 	let result = null;
 	for (const candidate of candidates) {
-		const values = new Set();
+		const values = /* @__PURE__ */ new Set();
 		const indexMapping = {};
 		let valid = true;
 		for (let i = 0; i < items.length; i++) {
-			const obj = items[i].type;
-			const prop = obj.props.get(candidate);
-			if (!prop || prop.type.kind !== "" || prop.type.value === undefined) {
+			const prop = items[i].type.props.get(candidate);
+			if (!prop || prop.type.kind !== "" || prop.type.value === void 0) {
 				valid = false;
 				break;
 			}
@@ -1398,7 +1452,23 @@ function detectDiscriminator(items) {
 	}
 	return result;
 }
-function buildJsonSchema(type) {
+/**
+* Builds a JSON Schema from an {@link TAtscriptAnnotatedType}.
+*
+* Translates the atscript type structure and validation metadata
+* (min/max, patterns, integer constraints, etc.) into a standard JSON Schema.
+*
+* @example
+* ```ts
+* import { buildJsonSchema } from '@atscript/typescript'
+*
+* const schema = buildJsonSchema(MyInterface)
+* // { type: 'object', properties: { ... }, required: [...] }
+* ```
+*
+* @param type - The annotated type to convert.
+* @returns A JSON Schema object.
+*/ function buildJsonSchema(type) {
 	const defs = {};
 	let hasDefs = false;
 	const buildObject = (d) => {
@@ -1406,17 +1476,17 @@ function buildJsonSchema(type) {
 		const required = [];
 		for (const [key, val] of d.type.props.entries()) {
 			if (isPhantomType(val)) continue;
-			properties[key] = build$2(val);
+			properties[key] = build(val);
 			if (!val.optional) required.push(key);
 		}
-		const schema$1 = {
+		const schema = {
 			type: "object",
 			properties
 		};
-		if (required.length > 0) schema$1.required = required;
-		return schema$1;
+		if (required.length > 0) schema.required = required;
+		return schema;
 	};
-	const build$2 = (def) => {
+	const build = (def) => {
 		if (def.id && def.type.kind === "object" && def !== type) {
 			const name = def.id;
 			if (!defs[name]) {
@@ -1435,20 +1505,20 @@ function buildJsonSchema(type) {
 				return buildObject(d);
 			},
 			array(d) {
-				const schema$1 = {
+				const schema = {
 					type: "array",
-					items: build$2(d.type.of)
+					items: build(d.type.of)
 				};
 				const minLength = meta.get("expect.minLength");
-				if (minLength) schema$1.minItems = typeof minLength === "number" ? minLength : minLength.length;
+				if (minLength) schema.minItems = typeof minLength === "number" ? minLength : minLength.length;
 				const maxLength = meta.get("expect.maxLength");
-				if (maxLength) schema$1.maxItems = typeof maxLength === "number" ? maxLength : maxLength.length;
-				return schema$1;
+				if (maxLength) schema.maxItems = typeof maxLength === "number" ? maxLength : maxLength.length;
+				return schema;
 			},
 			union(d) {
 				const disc = detectDiscriminator(d.type.items);
 				if (disc) {
-					const oneOf = d.type.items.map(build$2);
+					const oneOf = d.type.items.map(build);
 					const mapping = {};
 					for (const [val, idx] of Object.entries(disc.indexMapping)) {
 						const item = d.type.items[idx];
@@ -1462,47 +1532,47 @@ function buildJsonSchema(type) {
 						}
 					};
 				}
-				return { anyOf: d.type.items.map(build$2) };
+				return { anyOf: d.type.items.map(build) };
 			},
 			intersection(d) {
-				return { allOf: d.type.items.map(build$2) };
+				return { allOf: d.type.items.map(build) };
 			},
 			tuple(d) {
 				return {
 					type: "array",
-					items: d.type.items.map(build$2),
+					items: d.type.items.map(build),
 					additionalItems: false
 				};
 			},
 			final(d) {
-				const schema$1 = {};
-				if (d.type.value !== undefined) schema$1.const = d.type.value;
+				const schema = {};
+				if (d.type.value !== void 0) schema.const = d.type.value;
 				if (d.type.designType && d.type.designType !== "any") {
 					const dt = d.type.designType;
-					schema$1.type = dt === "undefined" ? "null" : dt === "decimal" ? "string" : dt;
-					if (schema$1.type === "number" && meta.get("expect.int")) schema$1.type = "integer";
+					schema.type = dt === "undefined" ? "null" : dt === "decimal" ? "string" : dt;
+					if (schema.type === "number" && meta.get("expect.int")) schema.type = "integer";
 				}
-				if (schema$1.type === "string") {
-					if (meta.get("meta.required")) schema$1.minLength = 1;
+				if (schema.type === "string") {
+					if (meta.get("meta.required")) schema.minLength = 1;
 					const minLength = meta.get("expect.minLength");
-					if (minLength) schema$1.minLength = typeof minLength === "number" ? minLength : minLength.length;
+					if (minLength) schema.minLength = typeof minLength === "number" ? minLength : minLength.length;
 					const maxLength = meta.get("expect.maxLength");
-					if (maxLength) schema$1.maxLength = typeof maxLength === "number" ? maxLength : maxLength.length;
+					if (maxLength) schema.maxLength = typeof maxLength === "number" ? maxLength : maxLength.length;
 					const patterns = meta.get("expect.pattern");
-					if (patterns?.length) if (patterns.length === 1) schema$1.pattern = patterns[0].pattern;
-else schema$1.allOf = (schema$1.allOf || []).concat(patterns.map((p) => ({ pattern: p.pattern })));
+					if (patterns?.length) if (patterns.length === 1) schema.pattern = patterns[0].pattern;
+					else schema.allOf = (schema.allOf || []).concat(patterns.map((p) => ({ pattern: p.pattern })));
 				}
-				if (schema$1.type === "number" || schema$1.type === "integer") {
+				if (schema.type === "number" || schema.type === "integer") {
 					const min = meta.get("expect.min");
-					if (min) schema$1.minimum = typeof min === "number" ? min : min.minValue;
+					if (min) schema.minimum = typeof min === "number" ? min : min.minValue;
 					const max = meta.get("expect.max");
-					if (max) schema$1.maximum = typeof max === "number" ? max : max.maxValue;
+					if (max) schema.maximum = typeof max === "number" ? max : max.maxValue;
 				}
-				return schema$1;
+				return schema;
 			}
 		});
 	};
-	const schema = build$2(type);
+	const schema = build(type);
 	if (hasDefs) return {
 		...schema,
 		$defs: defs
@@ -1519,7 +1589,7 @@ function _define_property$3(obj, key, value) {
 		configurable: true,
 		writable: true
 	});
-else obj[key] = value;
+	else obj[key] = value;
 	return obj;
 }
 const QUERY_OP_MAP = {
@@ -1548,31 +1618,31 @@ var JsRenderer = class extends BaseRenderer {
 	}
 	getExtendsRefs() {
 		if (this._extendsRefs) return this._extendsRefs;
-		const out = new Map();
-		const visitedInterfaces = new Set();
-		for (const node of this.doc.nodes) if ((0, __atscript_core.isInterface)(node) && node.hasExtends) this.walkExtendsParents(node, this.doc, out, visitedInterfaces);
+		const out = /* @__PURE__ */ new Map();
+		const visitedInterfaces = /* @__PURE__ */ new Set();
+		for (const node of this.doc.nodes) if ((0, _atscript_core.isInterface)(node) && node.hasExtends) this.walkExtendsParents(node, this.doc, out, visitedInterfaces);
 		return this._extendsRefs = out;
 	}
 	walkRefs(node, visited, visit) {
 		if (!node || visited.has(node)) return;
 		visited.add(node);
-		if ((0, __atscript_core.isRef)(node)) {
+		if ((0, _atscript_core.isRef)(node)) {
 			visit(node);
 			return;
 		}
-		if ((0, __atscript_core.isGroup)(node)) {
+		if ((0, _atscript_core.isGroup)(node)) {
 			for (const item of node.unwrap()) this.walkRefs(item, visited, visit);
 			return;
 		}
-		if ((0, __atscript_core.isArray)(node) || (0, __atscript_core.isProp)(node)) this.walkRefs(node.getDefinition(), visited, visit);
+		if ((0, _atscript_core.isArray)(node) || (0, _atscript_core.isProp)(node)) this.walkRefs(node.getDefinition(), visited, visit);
 	}
 	walkExtendsParents(iface, doc, out, visited) {
 		if (visited.has(iface)) return;
 		visited.add(iface);
-		const visitedNodes = new Set();
+		const visitedNodes = /* @__PURE__ */ new Set();
 		for (const token of iface.extendsTokens) {
 			const unwound = doc.unwindType(token.text);
-			if (!unwound?.def || !(0, __atscript_core.isInterface)(unwound.def)) continue;
+			if (!unwound?.def || !(0, _atscript_core.isInterface)(unwound.def)) continue;
 			const parentInterface = unwound.def;
 			const parentDoc = unwound.doc;
 			this.walkRefs(parentInterface.getDefinition(), visitedNodes, (ref) => {
@@ -1587,18 +1657,18 @@ var JsRenderer = class extends BaseRenderer {
 		const refToOriginDoc = this.getExtendsRefs();
 		if (refToOriginDoc.size === 0) return;
 		const taken = new Set(this.doc.registry.definitions.keys());
-		const allocated = new Map();
-		const synthPathCache = new Map();
+		const allocated = /* @__PURE__ */ new Map();
+		const synthPathCache = /* @__PURE__ */ new Map();
 		for (const [refNode, originDoc] of refToOriginDoc) {
 			const refId = refNode.id;
 			if (!refId) continue;
 			const ownerInfo = this.resolveOwner(originDoc, refId);
 			if (!ownerInfo?.doc || ownerInfo.doc === this.doc) continue;
-			if (ownerInfo.node && (0, __atscript_core.isPrimitive)(ownerInfo.node)) continue;
+			if (ownerInfo.node && (0, _atscript_core.isPrimitive)(ownerInfo.node)) continue;
 			const ownerDoc = ownerInfo.doc;
 			let synthPath;
 			if (synthPathCache.has(ownerDoc)) synthPath = synthPathCache.get(ownerDoc);
-else {
+			else {
 				synthPath = this.computeSynthPath(ownerDoc);
 				synthPathCache.set(ownerDoc, synthPath);
 			}
@@ -1615,7 +1685,7 @@ else {
 	resolveOwner(fromDoc, refId) {
 		const key = `${fromDoc.id}::${refId}`;
 		let v = this._ownerCache.get(key);
-		if (v === undefined && !this._ownerCache.has(key)) {
+		if (v === void 0 && !this._ownerCache.has(key)) {
 			v = fromDoc.getDeclarationOwnerNode(refId);
 			this._ownerCache.set(key, v);
 		}
@@ -1624,8 +1694,7 @@ else {
 	allocateSynthInfo(refId, synthPath, ownerInfo, taken) {
 		const ownerDoc = ownerInfo.doc;
 		const ownerNode = ownerInfo.node;
-		const existing = this.doc.importedDefs.get(refId);
-		if (existing?.text === synthPath) return {
+		if (this.doc.importedDefs.get(refId)?.text === synthPath) return {
 			alias: refId,
 			ownerDoc,
 			ownerNode
@@ -1658,26 +1727,26 @@ else {
 		return alias;
 	}
 	computeSynthPath(ownerDoc) {
-		if ((0, __atscript_core.isBareId)(ownerDoc.id)) return ownerDoc.id.slice("bare:".length, -".as".length);
-		if (!ownerDoc.id.startsWith("file://")) return undefined;
-		return (0, __atscript_core.getRelPath)(this.doc.id, ownerDoc.id);
+		if ((0, _atscript_core.isBareId)(ownerDoc.id)) return ownerDoc.id.slice(5, -3);
+		if (!ownerDoc.id.startsWith("file://")) return;
+		return (0, _atscript_core.getRelPath)(this.doc.id, ownerDoc.id);
 	}
 	pre() {
 		this.writeln("// prettier-ignore-start");
 		this.writeln("/* eslint-disable */");
 		this.writeln("/* oxlint-disable */");
 		let hasMutatingAnnotate = false;
-		const nodesByName = new Map();
+		const nodesByName = /* @__PURE__ */ 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) {
+			if (node.__typeId !== null && node.__typeId !== void 0 && 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}`);
+		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);
@@ -1692,14 +1761,14 @@ else for (let i = 0; i < nodes.length; i++) this.typeIds.set(nodes[i], `${name}_
 		}
 	}
 	buildAdHocMap(annotateNodes) {
-		const map = new Map();
+		const map = /* @__PURE__ */ new Map();
 		for (const annotateNode of annotateNodes) for (const entry of annotateNode.entries) {
-			const path$4 = entry.hasChain ? [entry.id, ...entry.chain.map((c) => c.text)].join(".") : entry.id;
+			const path = 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$4);
+				const existing = map.get(path);
 				if (existing) existing.push(...anns);
-else map.set(path$4, [...anns]);
+				else map.set(path, [...anns]);
 			}
 		}
 		return map.size > 0 ? map : null;
@@ -1717,15 +1786,12 @@ else map.set(path$4, [...anns]);
 		for (const node of this.postAnnotate) if (node.entity === "annotate") {
 			const annotateNode = node;
 			if (annotateNode.isMutating) this.renderMutatingAnnotateNode(annotateNode);
-else {
+			else {
 				const unwound = this.doc.unwindType(annotateNode.targetName);
 				if (unwound?.def) {
 					let def = this.doc.mergeIntersection(unwound.def);
-					if ((0, __atscript_core.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;
+					if ((0, _atscript_core.isInterface)(def)) if (def.hasExtends) def = unwound.doc.resolveInterfaceExtends(def) || def.getDefinition() || def;
+					else def = def.getDefinition() || def;
 					this._adHocAnnotations = this.buildAdHocMap([annotateNode]);
 					this.annotateType(def, node.id);
 					this._adHocAnnotations = null;
@@ -1737,7 +1803,7 @@ else def = def.getDefinition() || def;
 			}
 		} else {
 			let def = node.getDefinition();
-			if ((0, __atscript_core.isInterface)(node) && node.hasExtends) {
+			if ((0, _atscript_core.isInterface)(node) && node.hasExtends) {
 				const resolved = this.doc.resolveInterfaceExtends(node);
 				if (resolved) def = resolved;
 			}
@@ -1785,8 +1851,7 @@ else def = def.getDefinition() || def;
 	}
 	renderJsonSchemaMethod(node) {
 		const mode = resolveJsonSchemaMode(this.opts);
-		const hasAnnotation = node.countAnnotations("emit.jsonSchema") > 0;
-		if (hasAnnotation || mode === "bundle") {
+		if (node.countAnnotations("emit.jsonSchema") > 0 || mode === "bundle") {
 			const schema = JSON.stringify(buildJsonSchema(this.toAnnotatedType(node)));
 			this.writeln("static toJsonSchema() {");
 			this.indent().writeln(`return ${schema}`).unindent();
@@ -1809,13 +1874,13 @@ else def = def.getDefinition() || def;
 		}
 	}
 	renderDimMeasure(node) {
-		if (!(0, __atscript_core.isInterface)(node)) return;
+		if (!(0, _atscript_core.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 || !(0, __atscript_core.isStructure)(struct)) return;
+		if (!struct || !(0, _atscript_core.isStructure)(struct)) return;
 		const structNode = struct;
 		const dims = [];
 		const measures = [];
@@ -1836,12 +1901,12 @@ else def = def.getDefinition() || def;
 			case "interface":
 			case "type": {
 				let def = node.getDefinition();
-				if ((0, __atscript_core.isInterface)(node) && node.hasExtends) {
+				if ((0, _atscript_core.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);
+				const typeId = this.typeIds.get(node) ?? (node.__typeId !== null && node.__typeId !== void 0 ? node.id : void 0);
 				if (typeId) handle.id(typeId);
 				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
 			}
@@ -1883,14 +1948,13 @@ else def = def.getDefinition() || def;
 					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);
+					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);
+				const handle = defineAnnotatedType(group.op === "|" ? "union" : "intersection");
 				for (const item of group.unwrap()) handle.item(this.toAnnotatedHandle(item).$type);
 				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
 			}
@@ -1916,44 +1980,38 @@ else handle.prop(prop.id, propHandle.$type);
 		annotations?.forEach((a) => {
 			switch (a.name) {
 				case "expect.minLength":
-				case "expect.maxLength": {
+				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": {
+				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": {
+				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": {
+				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": {
+				case "expect.int":
 					handle.annotate(a.name, true);
 					break;
-				}
 				case "expect.array.uniqueItems":
-				case "expect.array.key": {
+				case "expect.array.key":
 					handle.annotate(a.name, { message: a.args[0]?.text });
 					break;
-				}
 				default:
 			}
 		});
@@ -1967,16 +2025,16 @@ else handle.prop(prop.id, propHandle.$type);
 			case "ref": {
 				const ref = node;
 				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
-				if ((0, __atscript_core.isPrimitive)(decl)) {
-					const ownerDecl$1 = this.resolveOwner(this.doc, ref.id);
-					if (!ownerDecl$1?.node || ownerDecl$1.node.entity !== "type" && ownerDecl$1.node.entity !== "interface") {
+				if ((0, _atscript_core.isPrimitive)(decl)) {
+					const ownerDecl = this.resolveOwner(this.doc, ref.id);
+					if (!ownerDecl?.node || ownerDecl.node.entity !== "type" && ownerDecl.node.entity !== "interface") {
 						this.annotateType(decl, name);
 						return this;
 					}
 				}
 				if (this._adHocAnnotations && this.hasAdHocAnnotationsThroughRef()) {
-					let resolved = decl ? this.doc.mergeIntersection(decl) : undefined;
-					if (resolved && (0, __atscript_core.isInterface)(resolved)) resolved = resolved.getDefinition() || resolved;
+					let resolved = decl ? this.doc.mergeIntersection(decl) : void 0;
+					if (resolved && (0, _atscript_core.isInterface)(resolved)) resolved = resolved.getDefinition() || resolved;
 					if (resolved) {
 						this.annotateType(resolved, name);
 						return this;
@@ -1989,45 +2047,35 @@ else handle.prop(prop.id, propHandle.$type);
 					node: synth.ownerNode
 				} : this.resolveOwner(this.doc, ref.id);
 				const refName = synth?.alias ?? ref.id;
-				const isImported = !!synth || (ownerDecl ? ownerDecl.doc !== this.doc : false);
-				const refExpr = isImported ? `() => ${refName}` : refName;
+				const refExpr = !!synth || (ownerDecl ? ownerDecl.doc !== this.doc : false) ? `() => ${refName}` : refName;
 				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${refExpr}${chain})`);
 				if (!ref.hasChain) {
-					if (ownerDecl?.node) {
-						const typeAnnotations = ownerDecl.doc.filterPassedWhenReferred(ownerDecl.doc.evalAnnotationsForNode(ownerDecl.node));
-						typeAnnotations?.forEach((an) => {
-							this.resolveAnnotationValue(ownerDecl.node, an);
-						});
-					}
+					if (ownerDecl?.node) ownerDecl.doc.filterPassedWhenReferred(ownerDecl.doc.evalAnnotationsForNode(ownerDecl.node))?.forEach((an) => {
+						this.resolveAnnotationValue(ownerDecl.node, an);
+					});
 				}
 				this.unindent();
 				return this;
 			}
-			case "primitive": {
+			case "primitive":
 				this.definePrimitive(node, name);
 				return this;
-			}
-			case "const": {
+			case "const":
 				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().defineConst(node).unindent();
 				return this;
-			}
-			case "structure": {
+			case "structure":
 				this.writeln(`$("object"${name ? `, ${name}` : ""})`).indent().defineObject(node).unindent();
 				return this;
-			}
-			case "group": {
+			case "group":
 				kind = node.op === "|" ? "union" : "intersection";
 				this.writeln(`$("${kind}"${name ? `, ${name}` : ""})`).indent().defineGroup(node).unindent();
 				return this;
-			}
-			case "tuple": {
+			case "tuple":
 				this.writeln(`$("tuple"${name ? `, ${name}` : ""})`).indent().defineGroup(node).unindent();
 				return this;
-			}
-			case "array": {
+			case "array":
 				this.writeln(`$("array"${name ? `, ${name}` : ""})`).indent().defineArray(node).unindent();
 				return this;
-			}
 			default: return this;
 		}
 	}
@@ -2051,7 +2099,7 @@ else handle.prop(prop.id, propHandle.$type);
 			case "final": return this.writeln(`$(${d()}).designType("${def.value === "void" ? "undefined" : def.value}")`);
 			case "union":
 			case "intersection":
-			case "tuple": {
+			case "tuple":
 				this.writeln(`$(${d(def.kind)})`);
 				this.indent();
 				for (const itemDef of def.items) {
@@ -2064,8 +2112,7 @@ else handle.prop(prop.id, propHandle.$type);
 				}
 				this.unindent();
 				return;
-			}
-			case "array": {
+			case "array":
 				this.writeln(`$(${d("array")})`);
 				this.indent();
 				this.write(".of(");
@@ -2076,8 +2123,7 @@ else handle.prop(prop.id, propHandle.$type);
 				this.writeln(`)`);
 				this.unindent();
 				return;
-			}
-			case "object": {
+			case "object":
 				this.writeln(`$(${d("object")})`);
 				this.indent();
 				for (const [key, propDef] of Object.entries(def.props)) {
@@ -2104,7 +2150,6 @@ else handle.prop(prop.id, propHandle.$type);
 				}
 				this.unindent();
 				return;
-			}
 			default: return this.writeln(`$(${d()}).designType("any")`);
 		}
 	}
@@ -2146,21 +2191,21 @@ else handle.prop(prop.id, propHandle.$type);
 	defineMetadata(node) {
 		let annotations;
 		const nodeDef = node.getDefinition?.();
-		if (nodeDef && (0, __atscript_core.isRef)(nodeDef)) {
+		if (nodeDef && (0, _atscript_core.isRef)(nodeDef)) {
 			const refNode = nodeDef;
 			if (!refNode.hasChain) {
 				const resolved = this.doc.unwindType(refNode.id, refNode.chain)?.def;
-				if (resolved && !(0, __atscript_core.isPrimitive)(resolved)) annotations = node.annotations ?? [];
-else if (resolved && (0, __atscript_core.isPrimitive)(resolved)) {
+				if (resolved && !(0, _atscript_core.isPrimitive)(resolved)) annotations = node.annotations ?? [];
+				else if (resolved && (0, _atscript_core.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 (annotations === void 0) annotations = this.doc.evalAnnotationsForNode(node);
 		if (this._adHocAnnotations && this._propPath.length > 0) {
-			const path$4 = this._propPath.join(".");
-			const adHoc = this._adHocAnnotations.get(path$4);
+			const path = this._propPath.join(".");
+			const adHoc = this._adHocAnnotations.get(path);
 			if (adHoc) annotations = this.doc.mergeNodesAnnotations(annotations, adHoc);
 		}
 		annotations?.forEach((an) => {
@@ -2174,9 +2219,8 @@ else if (resolved && (0, __atscript_core.isPrimitive)(resolved)) {
 	*/ 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) => {
+		const targetAnnotations = targetDecl?.node ? targetDecl.doc.evalAnnotationsForNode(targetDecl.node) : void 0;
+		this.doc.mergeNodesAnnotations(targetAnnotations, annotateAnnotations).forEach((an) => {
 			this.resolveAnnotationValue(annotateNode, an);
 		});
 		return this;
@@ -2184,14 +2228,12 @@ else if (resolved && (0, __atscript_core.isPrimitive)(resolved)) {
 	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})`);
+		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)}" }`;
+		return `{ type: () => ${text.slice(0, dotIdx)}, field: "${escapeQuotes(text.slice(dotIdx + 1))}" }`;
 	}
 	emitArgValue(aSpec, argToken) {
 		if (aSpec.type === "ref") return this.emitRefValue(argToken.text);
@@ -2202,14 +2244,12 @@ else this.writeln(`.annotate("${escapeQuotes(an.name)}", ${value})`);
 		return this.emitQueryExpr(queryNode.expression);
 	}
 	emitQueryExpr(node) {
-		if ((0, __atscript_core.isQueryLogical)(node)) return this.emitQueryLogical(node);
+		if ((0, _atscript_core.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}] }`;
+		return `{ "${node.operator === "and" ? "$and" : "$or"}": [${node.operands.map((op) => this.emitQueryExpr(op)).join(", ")}] }`;
 	}
 	emitQueryComparison(node) {
 		const left = this.emitQueryFieldRef(node.left);
@@ -2217,12 +2257,12 @@ else this.writeln(`.annotate("${escapeQuotes(an.name)}", ${value})`);
 		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) {
+			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");
+		else if (node.operator === "not exists") parts.push("right: false");
 		return `{ ${parts.join(", ")} }`;
 	}
 	emitQueryFieldRef(node) {
@@ -2240,11 +2280,10 @@ else if (node.operator === "not exists") parts.push("right: false");
 				const match = /^\/(.*)\/[a-z]*$/.exec(token.text);
 				return `"${escapeQuotes(match ? match[1] : token.text)}"`;
 			}
-			case "identifier": {
+			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;
 		}
 	}
@@ -2265,8 +2304,7 @@ else if (node.operator === "not exists") parts.push("right: false");
 				targetValue += "}";
 			} else {
 				const aSpec = spec.arguments[0];
-				if (an.args[0]) targetValue = this.emitArgValue(aSpec, an.args[0]);
-else targetValue = "true";
+				targetValue = an.args[0] ? this.emitArgValue(aSpec, an.args[0]) : "true";
 			}
 		} else {
 			multiple = node.countAnnotations(an.name) > 1 || an.args.length > 1;
@@ -2294,7 +2332,7 @@ else targetValue = "true";
 				accessors
 			});
 		}
-		const cloneKeys = new Set();
+		const cloneKeys = /* @__PURE__ */ new Set();
 		for (const clone of allClones) {
 			const key = `${clone.parentPath}|${clone.propName}`;
 			if (!cloneKeys.has(key)) {
@@ -2308,7 +2346,7 @@ else targetValue = "true";
 		this.writeln();
 	}
 	emitMutatingAnnotations(node, annotations, accessor) {
-		const cleared = new Set();
+		const cleared = /* @__PURE__ */ new Set();
 		for (const an of annotations) {
 			const { value, multiple } = this.computeAnnotationValue(node, an);
 			if (multiple) {
@@ -2323,9 +2361,9 @@ else targetValue = "true";
 	}
 	resolveTargetDef(targetName) {
 		const unwound = this.doc.unwindType(targetName);
-		if (!unwound?.def) return undefined;
+		if (!unwound?.def) return;
 		let def = unwound.def;
-		if ((0, __atscript_core.isInterface)(def)) def = def.getDefinition() || def;
+		if ((0, _atscript_core.isInterface)(def)) def = def.getDefinition() || def;
 		return def;
 	}
 	/**
@@ -2344,7 +2382,7 @@ else targetValue = "true";
 			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 && (0, __atscript_core.isRef)(result.propDef)) clones.push({
+					if (result.propDef && (0, _atscript_core.isRef)(result.propDef)) clones.push({
 						parentPath: prefix,
 						propName: parts[i]
 					});
@@ -2356,11 +2394,11 @@ else targetValue = "true";
 					prefix: `${prefix}${result.path}?`,
 					def: result.propDef
 				});
-else {
+				else {
 					const suffix = `.props.get("${escapeQuotes(parts[i])}")${i < parts.length - 1 ? "?.type" : "?"}`;
 					nextAccessors.push({
 						prefix: `${prefix}${suffix}`,
-						def: undefined
+						def: void 0
 					});
 				}
 			}
@@ -2378,13 +2416,13 @@ else {
 	*/ buildPropPaths(def, propName) {
 		if (!def) return [];
 		def = this.doc.mergeIntersection(def);
-		if ((0, __atscript_core.isRef)(def)) {
+		if ((0, _atscript_core.isRef)(def)) {
 			const ref = def;
 			const unwound = this.doc.unwindType(ref.id, ref.chain)?.def;
 			return this.buildPropPaths(unwound, propName);
 		}
-		if ((0, __atscript_core.isInterface)(def)) return this.buildPropPaths(def.getDefinition(), propName);
-		if ((0, __atscript_core.isStructure)(def)) {
+		if ((0, _atscript_core.isInterface)(def)) return this.buildPropPaths(def.getDefinition(), propName);
+		if ((0, _atscript_core.isStructure)(def)) {
 			const prop = def.props.get(propName);
 			if (prop) return [{
 				path: `.props.get("${escapeQuotes(propName)}")`,
@@ -2392,9 +2430,8 @@ else {
 			}];
 			return [];
 		}
-		if ((0, __atscript_core.isGroup)(def)) {
-			const group = def;
-			const items = group.unwrap();
+		if ((0, _atscript_core.isGroup)(def)) {
+			const items = def.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}`,
@@ -2405,21 +2442,23 @@ else {
 		return [];
 	}
 	constructor(doc, opts) {
-		super(doc), _define_property$3(this, "opts", void 0), _define_property$3(this, "postAnnotate", void 0), _define_property$3(this, "_adHocAnnotations", void 0), _define_property$3(this, "_propPath", void 0), _define_property$3(this, "typeIds", void 0), _define_property$3(this, "_unusedJs", void 0), _define_property$3(this, "_extendsRefs", void 0), _define_property$3(this, "_refSynthInfo", void 0), _define_property$3(this, "_synthImports", void 0), _define_property$3(this, "_synthComputed", void 0), _define_property$3(this, "_ownerCache", void 0), this.opts = opts, this.postAnnotate = [], this._adHocAnnotations = null, this._propPath = [], this.typeIds = new Map(), this._refSynthInfo = new Map(), this._synthImports = new Map(), this._synthComputed = false, this._ownerCache = new Map();
+		super(doc), _define_property$3(this, "opts", void 0), _define_property$3(this, "postAnnotate", void 0), _define_property$3(this, "_adHocAnnotations", void 0), _define_property$3(this, "_propPath", void 0), _define_property$3(this, "typeIds", void 0), _define_property$3(this, "_unusedJs", void 0), _define_property$3(this, "_extendsRefs", void 0), _define_property$3(this, "_refSynthInfo", void 0), _define_property$3(this, "_synthImports", void 0), _define_property$3(this, "_synthComputed", void 0), _define_property$3(this, "_ownerCache", void 0), this.opts = opts, this.postAnnotate = [], this._adHocAnnotations = null, this._propPath = [], this.typeIds = /* @__PURE__ */ new Map(), this._refSynthInfo = /* @__PURE__ */ new Map(), this._synthImports = /* @__PURE__ */ new Map(), this._synthComputed = false, this._ownerCache = /* @__PURE__ */ new Map();
 	}
 };
 
 //#endregion
 //#region packages/typescript/src/plugin.ts
-function resolveJsonSchemaMode(opts) {
-	if (opts?.jsonSchema !== undefined) return opts.jsonSchema;
+/**
+* Resolves the effective JSON schema mode from plugin options.
+*/ function resolveJsonSchemaMode(opts) {
+	if (opts?.jsonSchema !== void 0) return opts.jsonSchema;
 	return false;
 }
 const tsPlugin = (opts) => {
 	return {
 		name: "typescript",
 		render(doc, format) {
-			if (format === "dts" || format === __atscript_core.DEFAULT_FORMAT) return [{
+			if (format === "dts" || format === _atscript_core.DEFAULT_FORMAT) return [{
 				fileName: `${doc.name}.d.ts`,
 				content: new TypeRenderer(doc, opts).render()
 			}];
@@ -2429,21 +2468,21 @@ const tsPlugin = (opts) => {
 			}];
 		},
 		async buildEnd(output, format, repo) {
-			if (format === "dts" || format === __atscript_core.DEFAULT_FORMAT) {
+			if (format === "dts" || format === _atscript_core.DEFAULT_FORMAT) {
 				const annotations = await repo.getUsedAnnotations();
-				const tags = await repo.getPrimitivesTags() || new Set();
+				const tags = await repo.getPrimitivesTags() || /* @__PURE__ */ 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;
+						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",
+					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.default.join(repo.root, "atscript.d.ts")
@@ -2460,25 +2499,44 @@ async function getConfig(configFile, logger) {
 	if (configFile) {
 		const c = path.default.join(root, configFile);
 		if (!(0, fs.existsSync)(c)) {
-			logger.error(`Config file ${"\x1B[4m"}${configFile}${"\x1B[24m"} not found`);
+			logger.error(`Config file ${configFile} not found`);
 			process.exit(1);
 		}
-		logger.log(`Using config file ${"\x1B[36m"}${configFile}${"\x1B[39m"}`);
-		return (0, __atscript_core.loadConfig)(c);
+		logger.log(`Using config file ${configFile}`);
+		return (0, _atscript_core.loadConfig)(c);
 	} else {
-		const resolved = await (0, __atscript_core.resolveConfigFile)(root);
+		const resolved = await (0, _atscript_core.resolveConfigFile)(root);
 		if (resolved) {
-			logger.log(`Using config file ${"\x1B[36m"}${resolved}${"\x1B[39m"}`);
-			return (0, __atscript_core.loadConfig)(resolved);
+			logger.log(`Using config file ${resolved}`);
+			return (0, _atscript_core.loadConfig)(resolved);
 		}
 		logger.log(`No atscript config file found`);
 		return {
-			format: __atscript_core.DEFAULT_FORMAT,
+			format: _atscript_core.DEFAULT_FORMAT,
 			plugins: [tsPlugin()]
 		};
 	}
 }
 
+//#endregion
+//#region packages/typescript/src/cli/emit-policy.ts
+/**
+* Printed when diagnostics found errors and the emit was suppressed, so the
+* user knows the previous outputs are still the last known-good ones.
+*/ const NOTHING_EMITTED_MESSAGE = "Nothing emitted — previous outputs were left untouched. Fix the errors above, or pass --skipDiag to emit anyway.";
+/**
+* Decides whether `asc` may write its outputs.
+*
+* A failing compile must never replace valid artifacts: half of the outputs
+* would be stale and aggregate manifests produced in `buildEnd` would be
+* regenerated from an incomplete document set. Errors therefore block the
+* write entirely — `--skipDiag` is the explicit opt-out.
+*/ function shouldEmit(input) {
+	if (input.noEmit) return false;
+	if (input.skipDiag) return true;
+	return input.errorCount === 0;
+}
+
 //#endregion
 //#region packages/typescript/src/cli/commands.controller.ts
 function _define_property$2(obj, key, value) {
@@ -2488,13 +2546,13 @@ function _define_property$2(obj, key, value) {
 		configurable: true,
 		writable: true
 	});
-else obj[key] = value;
+	else obj[key] = value;
 	return obj;
 }
 function _ts_decorate$1(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
 	return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 function _ts_metadata$1(k, v) {
@@ -2508,9 +2566,9 @@ function _ts_param$1(paramIndex, decorator) {
 var Commands = class {
 	async default(configFile, format, noEmit, skipDiag) {
 		const config = await getConfig(configFile, this.logger);
-		config.format = format || __atscript_core.DEFAULT_FORMAT;
-		this.logger.log(`Format: ${"\x1B[36m"}${config.format}${"\x1B[39m"}`);
-		const builder = await (0, __atscript_core.build)(config);
+		config.format = format || _atscript_core.DEFAULT_FORMAT;
+		this.logger.log(`Format: ${config.format}`);
+		const builder = await (0, _atscript_core.build)(config);
 		let errorCount = 0;
 		let warningCount = 0;
 		if (!skipDiag) {
@@ -2519,22 +2577,30 @@ var Commands = class {
 				const doc = builder.getDoc(docId);
 				for (const m of messages) {
 					if (m.severity === 1) errorCount++;
-else if (m.severity === 2) warningCount++;
+					else if (m.severity === 2) warningCount++;
 					if (doc) this.logger.log(doc.renderDiagMessage(m, true, true));
 				}
 			}
 		}
-		if (!noEmit) {
+		const emit = shouldEmit({
+			noEmit,
+			skipDiag,
+			errorCount
+		});
+		if (emit) {
 			const out = await builder.write(config);
-			for (const { target } of out) this.logger.log(`✅ created ${"\x1B[32m"}${target}${"\x1B[39m"}`);
+			for (const { target } of out) this.logger.log(`✅ created ${target}`);
 		}
 		if (errorCount > 0 || warningCount > 0) {
 			const parts = [];
-			if (errorCount > 0) parts.push(`${"\x1B[31m"}${errorCount} error${errorCount > 1 ? "s" : ""}${"\x1B[39m"}`);
-			if (warningCount > 0) parts.push(`${"\x1B[33m"}${warningCount} warning${warningCount > 1 ? "s" : ""}${"\x1B[39m"}`);
+			if (errorCount > 0) parts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
+			if (warningCount > 0) parts.push(`${warningCount} warning${warningCount > 1 ? "s" : ""}`);
 			this.logger.log(`\nFound ${parts.join(" and ")}`);
 		}
-		if (errorCount > 0) process.exit(1);
+		if (errorCount > 0) {
+			if (!emit && !noEmit) this.logger.log(`${NOTHING_EMITTED_MESSAGE}`);
+			process.exit(1);
+		}
 	}
 	constructor(logger) {
 		_define_property$2(this, "logger", void 0);
@@ -2542,22 +2608,22 @@ else if (m.severity === 2) warningCount++;
 	}
 };
 _ts_decorate$1([
-	(0, __moostjs_event_cli.Cli)(""),
+	(0, _moostjs_event_cli.Cli)(""),
 	(0, moost.Description)("Builds .as files using --config and --format"),
-	(0, __moostjs_event_cli.CliExample)("-c atscript.config.js", "Build .as files using atscript.config.js"),
-	(0, __moostjs_event_cli.CliExample)("-f dts", "Build \"d.ts\" files for \".as\" files"),
-	(0, __moostjs_event_cli.CliExample)("--noEmit", "Only check for errors, do not emit files"),
-	(0, __moostjs_event_cli.CliExample)("--skipDiag", "Emit files without running diagnostics"),
-	_ts_param$1(0, (0, __moostjs_event_cli.CliOption)("c", "config")),
+	(0, _moostjs_event_cli.CliExample)("-c atscript.config.js", "Build .as files using atscript.config.js"),
+	(0, _moostjs_event_cli.CliExample)("-f dts", "Build \"d.ts\" files for \".as\" files"),
+	(0, _moostjs_event_cli.CliExample)("--noEmit", "Only check for errors, do not emit files"),
+	(0, _moostjs_event_cli.CliExample)("--skipDiag", "Emit files without running diagnostics"),
+	_ts_param$1(0, (0, _moostjs_event_cli.CliOption)("c", "config")),
 	_ts_param$1(0, (0, moost.Optional)()),
 	_ts_param$1(0, (0, moost.Description)("Path to config file")),
-	_ts_param$1(1, (0, __moostjs_event_cli.CliOption)("f", "format")),
+	_ts_param$1(1, (0, _moostjs_event_cli.CliOption)("f", "format")),
 	_ts_param$1(1, (0, moost.Optional)()),
 	_ts_param$1(1, (0, moost.Description)("Output format (e.g. js, dts). Omit to run all plugins with their default output.")),
-	_ts_param$1(2, (0, __moostjs_event_cli.CliOption)("noEmit")),
+	_ts_param$1(2, (0, _moostjs_event_cli.CliOption)("noEmit")),
 	_ts_param$1(2, (0, moost.Optional)()),
 	_ts_param$1(2, (0, moost.Description)("Only run diagnostics without emitting files")),
-	_ts_param$1(3, (0, __moostjs_event_cli.CliOption)("skipDiag")),
+	_ts_param$1(3, (0, _moostjs_event_cli.CliOption)("skipDiag")),
 	_ts_param$1(3, (0, moost.Optional)()),
 	_ts_param$1(3, (0, moost.Description)("Skip diagnostics and always emit files")),
 	_ts_metadata$1("design:type", Function),
@@ -2576,6 +2642,188 @@ Commands = _ts_decorate$1([
 	_ts_metadata$1("design:paramtypes", [typeof TConsoleBase === "undefined" ? Object : TConsoleBase])
 ], Commands);
 
+//#endregion
+//#region packages/typescript/src/cli/db-sync-models.ts
+/** Depth cap for `config.models` — deep enough for nested arrays and namespaces. */ const MAX_MODELS_DEPTH = 6;
+/** Keeps two runs in the same process (and the same millisecond) apart. */ let runSeq = 0;
+/**
+* Compiles the project's `.as` files and loads every `@db.table` / `@db.view`
+* model, plus the models contributed by `config.models`.
+*
+* The result is only a complete inventory when `diagnostics.errors` is 0 and
+* both `failures` and `modelsError` are empty — a caller that plans a sync
+* from a partial inventory would propose dropping the tables it failed to see.
+*/ async function loadDbModels(options) {
+	const { config, cwd = process.cwd(), logger } = options;
+	const buildConfig = toBuildConfig(config);
+	logger?.log(`Compiling .as files...`);
+	const builder = await (0, _atscript_core.build)(buildConfig);
+	const diagnostics = await collectDiagnostics(builder);
+	if (diagnostics.errors > 0) return {
+		types: [],
+		failures: [],
+		diagnostics,
+		packaged: 0
+	};
+	const { types, failures } = await importGeneratedModules(await builder.generate(buildConfig), buildConfig.rootDir || cwd, cwd);
+	const result = {
+		types,
+		failures,
+		diagnostics,
+		packaged: 0
+	};
+	if (failures.length > 0 || !config.models) return result;
+	try {
+		const seen = new Set(types);
+		for (const model of flattenModels(await config.models())) if (!seen.has(model)) {
+			seen.add(model);
+			types.push(model);
+			result.packaged++;
+		}
+	} catch (error) {
+		result.modelsError = error;
+	}
+	return result;
+}
+/** Abort message printed when some generated modules could not be imported. */ function partialInventoryMessage(count) {
+	return `Could not load ${count} compiled model module(s); aborting before planning — a partial inventory would propose dropping tables.`;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Collects every `@db.table` / `@db.view` model out of whatever `config.models`
+* returned — an annotated type, an array, a module namespace object, or any
+* nesting of those. Deduplicated by identity.
+*/ function flattenModels(value) {
+	const out = [];
+	walkModels(value, out, /* @__PURE__ */ new Set(), 0);
+	return out;
+}
+/** Rewrites the emitted `.as` specifiers to the `.mjs` files we just wrote. */ function patchAsImports(content) {
+	return content.replace(/(from\s+["'][^"']+)\.as(["'])/g, "$1.as.mjs$2");
+}
+function toBuildConfig(config) {
+	const buildConfig = { ...config };
+	if (typeof config.db === "object" && "adapter" in config.db) {
+		const dbConfig = config.db;
+		if (dbConfig.include) buildConfig.include = dbConfig.include;
+		if (dbConfig.exclude) buildConfig.exclude = dbConfig.exclude;
+	}
+	buildConfig.format = "js";
+	return buildConfig;
+}
+async function collectDiagnostics(builder) {
+	const diagnostics = {
+		errors: 0,
+		warnings: 0,
+		messages: []
+	};
+	const diagMap = await builder.diagnostics();
+	for (const [docId, messages] of diagMap) {
+		const doc = builder.getDoc(docId);
+		for (const m of messages) {
+			if (m.severity === 1) diagnostics.errors++;
+			else if (m.severity === 2) diagnostics.warnings++;
+			if (doc) diagnostics.messages.push(doc.renderDiagMessage(m, true, true));
+		}
+	}
+	return diagnostics;
+}
+async function importGeneratedModules(outputs, rootDir, cwd) {
+	const jsOutputs = [];
+	for (const o of outputs) if (o.fileName.endsWith(".js") && o.source) jsOutputs.push({
+		fileName: o.fileName,
+		content: o.content,
+		source: o.source
+	});
+	const base = resolveLayoutBase(rootDir, jsOutputs.map((o) => path.default.dirname((0, _atscript_core.fileUriToPath)(o.source))));
+	const tmpDir = path.default.join(cwd, `.atscript-db-sync-${process.pid}-${Date.now()}-${runSeq++}`);
+	const cleanup = () => {
+		try {
+			(0, fs.rmSync)(tmpDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	};
+	process.on("exit", cleanup);
+	try {
+		const files = [];
+		for (const o of jsOutputs) {
+			const srcDir = path.default.dirname((0, _atscript_core.fileUriToPath)(o.source));
+			const rel = path.default.join(path.default.relative(base, srcDir), o.fileName.replace(/\.js$/, ".mjs"));
+			const abs = path.default.join(tmpDir, rel);
+			(0, fs.mkdirSync)(path.default.dirname(abs), { recursive: true });
+			(0, fs.writeFileSync)(abs, patchAsImports(o.content));
+			files.push({
+				abs,
+				rel
+			});
+		}
+		const types = [];
+		const failures = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const file of files) try {
+			collectFromModule(await import(
+				/* @vite-ignore */
+				(0, node_url.pathToFileURL)(file.abs).href
+), types, seen);
+		} catch (error) {
+			failures.push({
+				file: file.rel,
+				error
+			});
+		}
+		return {
+			types,
+			failures
+		};
+	} finally {
+		cleanup();
+		process.off("exit", cleanup);
+	}
+}
+function collectFromModule(mod, types, seen) {
+	for (const exp of Object.values(mod)) if (isDbModel(exp) && !seen.has(exp)) {
+		seen.add(exp);
+		types.push(exp);
+	}
+}
+/**
+* Directory the temp layout mirrors. Normally `rootDir`; when a source lives
+* outside it, the common ancestor of `rootDir` and every source, so that no
+* `..` segment ever escapes the temp directory.
+*/ function resolveLayoutBase(rootDir, sourceDirs) {
+	const root = path.default.resolve(rootDir);
+	return sourceDirs.some((dir) => {
+		const rel = path.default.relative(root, path.default.resolve(dir));
+		return rel === ".." || rel.startsWith(`..${path.default.sep}`);
+	}) ? commonAncestor([root, ...sourceDirs]) : root;
+}
+function commonAncestor(dirs) {
+	const parts = dirs.map((d) => path.default.resolve(d).split(path.default.sep));
+	const first = parts[0];
+	let i = 0;
+	while (i < first.length && parts.every((p) => p[i] === first[i])) i++;
+	return first.slice(0, i).join(path.default.sep) || path.default.sep;
+}
+function isDbModel(value) {
+	return isAnnotatedType(value) && Boolean(value.metadata?.has("db.table") || value.metadata?.has("db.view"));
+}
+function walkModels(value, out, seen, depth) {
+	if (!value || typeof value !== "object" && typeof value !== "function") return;
+	if (seen.has(value)) return;
+	seen.add(value);
+	if (isAnnotatedType(value)) {
+		if (isDbModel(value)) out.push(value);
+		return;
+	}
+	if (depth >= MAX_MODELS_DEPTH) return;
+	const items = Array.isArray(value) ? value : Object.values(value);
+	for (const item of items) walkModels(item, out, seen, depth + 1);
+}
+
 //#endregion
 //#region packages/typescript/src/cli/db-sync-printer.ts
 function _define_property$1(obj, key, value) {
@@ -2585,17 +2833,17 @@ function _define_property$1(obj, key, value) {
 		configurable: true,
 		writable: true
 	});
-else obj[key] = value;
+	else obj[key] = value;
 	return obj;
 }
 const DYE_COLORS = {
-	green: (s) => `${"\x1B[32m"}${s}${"\x1B[39m"}`,
-	red: (s) => `${"\x1B[31m"}${s}${"\x1B[39m"}`,
-	cyan: (s) => `${"\x1B[36m"}${s}${"\x1B[39m"}`,
-	yellow: (s) => `${"\x1B[33m"}${s}${"\x1B[39m"}`,
-	bold: (s) => `${"\x1B[1m"}${s}${"\x1B[22m"}`,
-	dim: (s) => `${"\x1B[2m"}${s}${"\x1B[22m"}`,
-	underline: (s) => `${"\x1B[4m"}${s}${"\x1B[24m"}`
+	green: (s) => `${s}`,
+	red: (s) => `${s}`,
+	cyan: (s) => `${s}`,
+	yellow: (s) => `${s}`,
+	bold: (s) => `${s}`,
+	dim: (s) => `${s}`,
+	underline: (s) => `${s}`
 };
 const BANNER = DYE_COLORS.cyan(`
 
@@ -2623,7 +2871,7 @@ const PLAN_HEADER = [
 	DYE_COLORS.bold("╚══════════════════════════════════════╝"),
 	""
 ];
-function planFlags(plan) {
+/** Plan-level aggregates over the per-entry SyncEntry getters. */ function planFlags(plan) {
 	return {
 		destructive: plan.entries.some((e) => e.destructive),
 		hasChanges: plan.entries.some((e) => e.hasChanges),
@@ -2690,7 +2938,7 @@ var DbSyncPrinter = class {
 				errors: e.errors
 			}))
 		};
-		return `${JSON.stringify(doc, undefined, 2)}\n`;
+		return `${JSON.stringify(doc, void 0, 2)}\n`;
 	}
 	/** Renders the plan as a Markdown document (e.g. for PR comments). */ renderMarkdown(plan) {
 		const { destructive } = planFlags(plan);
@@ -2739,13 +2987,13 @@ function _define_property(obj, key, value) {
 		configurable: true,
 		writable: true
 	});
-else obj[key] = value;
+	else obj[key] = value;
 	return obj;
 }
 function _ts_decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
 	return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 function _ts_metadata(k, v) {
@@ -2762,24 +3010,24 @@ var DbSyncController = class {
 	}
 	async dbSync(configFile, dryRun, yes, force, safe, check, format, out) {
 		if (format && format !== "json" && format !== "markdown") {
-			this.logger.error(`${"\x1B[31m"}Unknown --format "${format}". Use "json" or "markdown".${"\x1B[39m"}`);
+			this.logger.error(`Unknown --format "${format}". Use "json" or "markdown".`);
 			process.exit(1);
 		}
 		this.quiet = Boolean(format) && !out;
 		this.printer.muted = this.quiet;
-		const cfgLogger = this.quiet ? Object.create(this.logger, { log: { value: () => {} } }) : this.logger;
-		const config = await getConfig(configFile, cfgLogger);
+		const config = await getConfig(configFile, this.quiet ? Object.create(this.logger, { log: { value: () => {} } }) : this.logger);
 		if (!config.db) {
-			this.logger.error(`${"\x1B[31m"}No "db" field in atscript config. ` + `Add a db configuration to use schema sync.${"\x1B[39m"}`);
+			this.logger.error("\x1B[31mNo \"db\" field in atscript config. Add a db configuration to use schema sync.\x1B[39m");
 			process.exit(1);
 		}
-		const [dbSpace, dbTypes] = await Promise.all([this.resolveDbSpace(config.db), this.compileAndLoadTypes(config)]);
+		const dbTypes = await this.loadTypes(config);
 		if (dbTypes.length === 0) {
 			this.info(`No types with @db.table or @db.view found. Nothing to sync.`);
 			return;
 		}
 		this.printer.typeCount(dbTypes.length);
 		this.printer.banner();
+		const dbSpace = await this.resolveDbSpace(config.db);
 		const { SchemaSync } = await this.importFromCwd("@atscript/db/sync", true);
 		const sync = new SchemaSync(dbSpace);
 		const plan = await sync.plan(dbTypes, {
@@ -2795,7 +3043,7 @@ var DbSyncController = class {
 			} else process.stdout.write(doc);
 		}
 		if (plan.status === "up-to-date") this.printer.planUpToDate(plan);
-else {
+		else {
 			this.printer.plan(plan);
 			if (hasErrors) {
 				this.logger.error(`Schema has errors. Fix the issues above before syncing.`);
@@ -2823,8 +3071,7 @@ else {
 		}
 		if (hasDestructive) {
 			if (!yes) {
-				const confirmed = await this.confirm("Apply these changes? (includes destructive operations)");
-				if (!confirmed) {
+				if (!await this.confirm("Apply these changes? (includes destructive operations)")) {
 					this.logger.log("Aborted.");
 					return;
 				}
@@ -2836,46 +3083,33 @@ else {
 		});
 		this.printer.result(result);
 	}
-	async compileAndLoadTypes(config) {
-		const buildConfig = { ...config };
-		if (typeof config.db === "object" && "adapter" in config.db) {
-			const dbConfig = config.db;
-			if (dbConfig.include) buildConfig.include = dbConfig.include;
-			if (dbConfig.exclude) buildConfig.exclude = dbConfig.exclude;
-		}
-		buildConfig.format = "js";
-		this.info(`Compiling .as files...`);
-		const builder = await (0, __atscript_core.build)(buildConfig);
-		const outputs = await builder.generate(buildConfig);
-		const jsOutputs = outputs.filter((o) => o.fileName.endsWith(".js"));
-		const tmpDir = path.default.join(process.cwd(), `.atscript-db-sync-${Date.now()}`);
-		const writtenFiles = [];
-		for (const o of jsOutputs) {
-			const target = path.default.join(tmpDir, o.fileName.replace(/\.js$/, ".mjs"));
-			(0, fs.mkdirSync)(path.default.dirname(target), { recursive: true });
-			(0, fs.writeFileSync)(target, patchAsImports(o.content));
-			writtenFiles.push(target);
+	/**
+	* Loads the full model inventory or aborts. Diagnostics run first, every
+	* generated module is imported individually, and any failure exits 1 before
+	* a plan is computed.
+	*/ async loadTypes(config) {
+		const result = await loadDbModels({
+			config,
+			cwd: process.cwd(),
+			logger: { log: (message) => this.info(message) }
+		});
+		if (result.diagnostics.errors > 0) {
+			for (const message of result.diagnostics.messages) this.logger.error(message);
+			this.logger.error(`Fix the errors above before syncing.`);
+			process.exit(1);
 		}
-		const dbTypes = [];
-		try {
-			for (const file of writtenFiles) {
-				const mod = await import(
-					/* @vite-ignore */
-					(0, node_url.pathToFileURL)(file).href
-);
-				for (const exp of Object.values(mod)) if (isAnnotatedType(exp) && (exp.metadata?.has("db.table") || exp.metadata?.has("db.view"))) dbTypes.push(exp);
-			}
-		} catch (error) {
-			this.logger.warn?.(`Could not import compiled types: ${error}`);
-		} finally {
-			try {
-				(0, fs.rmSync)(tmpDir, {
-					recursive: true,
-					force: true
-				});
-			} catch {}
+		for (const message of result.diagnostics.messages) this.info(message);
+		if (result.failures.length > 0) {
+			for (const failure of result.failures) this.logger.error(`✖ ${failure.file}: ${errorMessage(failure.error)}`);
+			this.logger.error(`${partialInventoryMessage(result.failures.length)}`);
+			process.exit(1);
+		}
+		if (result.modelsError) {
+			this.logger.error(`config.models failed: ${errorMessage(result.modelsError)}`);
+			process.exit(1);
 		}
-		return dbTypes;
+		if (result.packaged > 0) this.info(`Loaded ${result.packaged} packaged model(s) from config.models`);
+		return result.types;
 	}
 	async resolveDbSpace(dbConfig) {
 		if (typeof dbConfig === "function") {
@@ -2883,24 +3117,23 @@ else {
 			return await dbConfig();
 		}
 		const { adapter, connection, options } = dbConfig;
-		this.info(`Using adapter: ${"\x1B[36m"}${adapter}${"\x1B[39m"}`);
+		this.info(`Using adapter: ${adapter}`);
 		let mod;
 		try {
 			mod = await this.importFromCwd(adapter);
 		} catch {
-			this.logger.error(`${"\x1B[31m"}Could not import adapter package "${adapter}". Is it installed?${"\x1B[39m"}`);
+			this.logger.error(`Could not import adapter package "${adapter}". Is it installed?`);
 			process.exit(1);
 		}
 		if (typeof mod.createAdapter !== "function") {
-			this.logger.error(`${"\x1B[31m"}Adapter package "${adapter}" does not export a createAdapter function.${"\x1B[39m"}`);
+			this.logger.error(`Adapter package "${adapter}" does not export a createAdapter function.`);
 			process.exit(1);
 		}
 		const resolvedConnection = typeof connection === "function" ? await connection() : connection;
 		return mod.createAdapter(resolvedConnection, options);
 	}
 	async importFromCwd(specifier, preferEsm = false) {
-		const require$1 = (0, node_module.createRequire)(path.default.join(process.cwd(), "__synthetic.cjs"));
-		let resolved = require$1.resolve(specifier);
+		let resolved = (0, node_module.createRequire)(path.default.join(process.cwd(), "__synthetic.cjs")).resolve(specifier);
 		if (preferEsm) {
 			const mjsPath = resolved.replace(/\.cjs$/, ".mjs");
 			if ((0, fs.existsSync)(mjsPath)) resolved = mjsPath;
@@ -2932,38 +3165,38 @@ else {
 	}
 };
 _ts_decorate([
-	(0, __moostjs_event_cli.Cli)("db sync"),
+	(0, _moostjs_event_cli.Cli)("db sync"),
 	(0, moost.Description)("Synchronize database schema with .as type definitions"),
-	(0, __moostjs_event_cli.CliExample)("db sync", "Interactive sync — shows plan, prompts, then applies"),
-	(0, __moostjs_event_cli.CliExample)("db sync --dry-run", "Show what would change without applying"),
-	(0, __moostjs_event_cli.CliExample)("db sync --yes", "Skip confirmation prompt (CI mode)"),
-	(0, __moostjs_event_cli.CliExample)("db sync --force", "Re-sync even if schema hash matches"),
-	(0, __moostjs_event_cli.CliExample)("db sync --safe", "Skip destructive operations (column/table drops)"),
-	(0, __moostjs_event_cli.CliExample)("db sync --check", "Exit 1 when changes are needed, 2 when destructive (CI gate)"),
-	(0, __moostjs_event_cli.CliExample)("db sync --format json", "Emit the plan as JSON to stdout, do not apply"),
-	(0, __moostjs_event_cli.CliExample)("db sync --format markdown --out plan.md", "Write the plan as Markdown to a file"),
-	_ts_param(0, (0, __moostjs_event_cli.CliOption)("c", "config")),
+	(0, _moostjs_event_cli.CliExample)("db sync", "Interactive sync — shows plan, prompts, then applies"),
+	(0, _moostjs_event_cli.CliExample)("db sync --dry-run", "Show what would change without applying"),
+	(0, _moostjs_event_cli.CliExample)("db sync --yes", "Skip confirmation prompt (CI mode)"),
+	(0, _moostjs_event_cli.CliExample)("db sync --force", "Re-sync even if schema hash matches"),
+	(0, _moostjs_event_cli.CliExample)("db sync --safe", "Skip destructive operations (column/table drops)"),
+	(0, _moostjs_event_cli.CliExample)("db sync --check", "Exit 1 when changes are needed, 2 when destructive (CI gate)"),
+	(0, _moostjs_event_cli.CliExample)("db sync --format json", "Emit the plan as JSON to stdout, do not apply"),
+	(0, _moostjs_event_cli.CliExample)("db sync --format markdown --out plan.md", "Write the plan as Markdown to a file"),
+	_ts_param(0, (0, _moostjs_event_cli.CliOption)("c", "config")),
 	_ts_param(0, (0, moost.Optional)()),
 	_ts_param(0, (0, moost.Description)("Path to config file")),
-	_ts_param(1, (0, __moostjs_event_cli.CliOption)("dry-run")),
+	_ts_param(1, (0, _moostjs_event_cli.CliOption)("dry-run")),
 	_ts_param(1, (0, moost.Optional)()),
 	_ts_param(1, (0, moost.Description)("Show plan only, do not apply changes")),
-	_ts_param(2, (0, __moostjs_event_cli.CliOption)("yes")),
+	_ts_param(2, (0, _moostjs_event_cli.CliOption)("yes")),
 	_ts_param(2, (0, moost.Optional)()),
 	_ts_param(2, (0, moost.Description)("Skip confirmation prompt (CI mode)")),
-	_ts_param(3, (0, __moostjs_event_cli.CliOption)("force")),
+	_ts_param(3, (0, _moostjs_event_cli.CliOption)("force")),
 	_ts_param(3, (0, moost.Optional)()),
 	_ts_param(3, (0, moost.Description)("Ignore schema hash, re-sync even if up-to-date")),
-	_ts_param(4, (0, __moostjs_event_cli.CliOption)("safe")),
+	_ts_param(4, (0, _moostjs_event_cli.CliOption)("safe")),
 	_ts_param(4, (0, moost.Optional)()),
 	_ts_param(4, (0, moost.Description)("Skip destructive operations (column/table drops)")),
-	_ts_param(5, (0, __moostjs_event_cli.CliOption)("check")),
+	_ts_param(5, (0, _moostjs_event_cli.CliOption)("check")),
 	_ts_param(5, (0, moost.Optional)()),
 	_ts_param(5, (0, moost.Description)("Plan only; exit 1 when changes are needed, 2 when destructive changes are present")),
-	_ts_param(6, (0, __moostjs_event_cli.CliOption)("f", "format")),
+	_ts_param(6, (0, _moostjs_event_cli.CliOption)("f", "format")),
 	_ts_param(6, (0, moost.Optional)()),
 	_ts_param(6, (0, moost.Description)("Emit the plan as \"json\" or \"markdown\" instead of applying (plan-only mode)")),
-	_ts_param(7, (0, __moostjs_event_cli.CliOption)("out")),
+	_ts_param(7, (0, _moostjs_event_cli.CliOption)("out")),
 	_ts_param(7, (0, moost.Optional)()),
 	_ts_param(7, (0, moost.Description)("Write --format output to a file instead of stdout")),
 	_ts_metadata("design:type", Function),
@@ -2985,13 +3218,10 @@ DbSyncController = _ts_decorate([
 	_ts_metadata("design:type", Function),
 	_ts_metadata("design:paramtypes", [typeof TConsoleBase === "undefined" ? Object : TConsoleBase])
 ], DbSyncController);
-function patchAsImports(content) {
-	return content.replace(/(from\s+["'][^"']+)\.as(["'])/g, "$1.as.mjs$2");
-}
 
 //#endregion
 //#region packages/typescript/src/cli/cli.ts
-new __moostjs_event_cli.CliApp().controllers(Commands, DbSyncController).useHelp({ name: "asc" }).useOptions([{
+new _moostjs_event_cli.CliApp().controllers(Commands, DbSyncController).useHelp({ name: "asc" }).useOptions([{
 	keys: ["help"],
 	description: "Display instructions for the command."
 }]).start();