@atscript/typescript 0.1.33 → 0.1.35

package/dist/cli.cjs

@@ -23,13 +23,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 const __moostjs_event_cli = __toESM(require("@moostjs/event-cli"));
-const fs = __toESM(require("fs"));
-const path = __toESM(require("path"));
 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"));
 
 //#region packages/typescript/src/codegen/code-printer.ts
-function _define_property$5(obj, key, value) {
+function _define_property$7(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -122,17 +125,17 @@ else this.write(closing);
 		return " ".repeat(this.indentLevel * this.indentSize);
 	}
 	constructor() {
-		_define_property$5(this, "lines", []);
-		_define_property$5(this, "currentLine", "");
-		_define_property$5(this, "indentLevel", 0);
-		_define_property$5(this, "indentSize", 2);
-		_define_property$5(this, "blockStack", []);
+		_define_property$7(this, "lines", []);
+		_define_property$7(this, "currentLine", "");
+		_define_property$7(this, "indentLevel", 0);
+		_define_property$7(this, "indentSize", 2);
+		_define_property$7(this, "blockStack", []);
 	}
 };
 
 //#endregion
 //#region packages/typescript/src/codegen/base-renderer.ts
-function _define_property$4(obj, key, value) {
+function _define_property$6(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -157,8 +160,8 @@ var BaseRenderer = class extends CodePrinter {
 	renderInterface(node) {}
 	renderType(node) {}
 	renderAnnotate(node) {}
-	transformFromPath(path$3) {
-		return `${path$3}.as`;
+	transformFromPath(path$4) {
+		return `${path$4}.as`;
 	}
 	renderImport(node) {
 		const def = node.getDefinition();
@@ -199,7 +202,7 @@ var BaseRenderer = class extends CodePrinter {
 		}
 	}
 	constructor(doc) {
-		super(), _define_property$4(this, "doc", void 0), _define_property$4(this, "_unused", void 0), this.doc = doc;
+		super(), _define_property$6(this, "doc", void 0), _define_property$6(this, "_unused", void 0), this.doc = doc;
 	}
 };
 
@@ -216,7 +219,7 @@ function escapeQuotes(str) {
 
 //#endregion
 //#region packages/typescript/src/codegen/type-renderer.ts
-function _define_property$3(obj, key, value) {
+function _define_property$5(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -341,8 +344,10 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 		this.writeln("static toJsonSchema: () => any");
 		if (!this.opts?.exampleData) this.writeln("/** @deprecated Example Data support is disabled. To enable, set `exampleData: true` in tsPlugin options. */");
 		this.writeln("static toExampleData?: () => any");
-		if (interfaceNode && this.hasDbTable(interfaceNode)) {
+		if (interfaceNode && this.hasDbEntity(interfaceNode)) {
 			this.renderFlat(interfaceNode);
+			this.renderOwnProps(interfaceNode);
+			this.renderNavProps(interfaceNode);
 			this.renderPk(interfaceNode);
 		}
 	}
@@ -433,14 +438,13 @@ else if ((0, __atscript_core.isPrimitive)(realDef)) typeDef = `TAtscriptTypeFina
 		this.popln();
 	}
 	/**
-	* Checks whether an interface has the `@db.table` annotation.
+	* Checks whether an interface is a DB entity (`@db.table` or `@db.view`).
 	*
-	* NOTE: Only `@db.table` interfaces get the `__flat` static property.
-	* This is intentionally hardcoded — `__flat` exists solely to improve
-	* type-safety for filter expressions and `$select`/`$sort` operations
-	* in the DB layer. Non-DB interfaces have no use for dot-notation path types.
-	*/ hasDbTable(node) {
-		return !!node.annotations?.some((a) => a.name === "db.table");
+	* Only DB entities get `__flat`, `__pk`, `__ownProps`, and `__navProps` static properties.
+	* These exist solely to improve type-safety for filter expressions, `$select`/`$sort`,
+	* and `$with` operations in the DB layer.
+	*/ hasDbEntity(node) {
+		return !!node.annotations?.some((a) => a.name === "db.table" || a.name === "db.view" || a.name === "db.view.for");
 	}
 	/**
 	* Renders the `static __flat` property — a map of all dot-notation paths
@@ -457,12 +461,30 @@ else if ((0, __atscript_core.isPrimitive)(realDef)) typeDef = `TAtscriptTypeFina
 	*   not individually queryable)
 	* - **Leaf fields** → their original TypeScript type
 	*/ renderFlat(node) {
-		const flatMap = (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 }), {
+			leadingNewline: true,
+			trailingNewline: true
+		});
+	}
+	/**
+	* Shared renderer for flat-map static properties (`__flat`, `__ownProps`).
+	*
+	* Special rendering rules:
+	* - **Intermediate paths** (structures, arrays of structures) → `never`
+	* - **`@db.json` fields** → `string` (stored as serialized JSON in DB)
+	* - **Leaf fields** → their original TypeScript type
+	*/ renderFlatMap(propName, flatMap, opts) {
 		if (flatMap.size === 0) return;
-		this.write("static __flat: ");
+		if (opts?.leadingNewline) this.writeln();
+		this.write(`static ${propName}: `);
 		this.blockln("{}");
-		for (const [path$3, descriptor] of flatMap) {
-			this.write(`"${escapeQuotes(path$3)}"`);
+		for (const [path$4, descriptor] of flatMap) {
+			this.write(`"${escapeQuotes(path$4)}"`);
 			if (descriptor.optional) this.write("?");
 			this.write(": ");
 			if (descriptor.intermediate) this.writeln("never");
@@ -474,19 +496,46 @@ else {
 				renderedDef.split("\n").forEach((l) => this.writeln(l));
 			}
 		}
-		this.pop();
+		if (opts?.trailingNewline) this.popln();
+else this.pop();
 	}
 	/**
-	* Renders the `static __pk` property — the primary key type for type-safe
-	* `deleteOne`/`findById` signatures on `AtscriptDbTable`.
+	* Renders the `static __navProps` property — a map of navigation property names
+	* to their declared TypeScript types.
 	*
-	* - **Single PK** (one `@meta.id`) → `static __pk: <scalar type>`
-	* - **Compound PK** (multiple `@meta.id`) → `static __pk: { field1: Type1; field2: Type2 }`
-	* - **No PK** → no `__pk` emitted (unless unique indexes exist)
-	* - **Unique indexes** (`@db.index.unique`) → appended as union members
-	* - **Mongo collection** → always includes `string` (ObjectId) in the union;
-	*   if no `@meta.id` fields, `__pk` is just `string`
-	*/ renderPk(node) {
+	* This enables type-safe `$with` in queries: `name` is constrained to known
+	* navigation property keys, and nested filter/controls are typed to the target entity.
+	*/ renderNavProps(node) {
+		let struct;
+		if (node.hasExtends) struct = this.doc.resolveInterfaceExtends(node);
+		if (!struct) struct = node.getDefinition();
+		if (!struct || !(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({
+				name,
+				prop
+			});
+		}
+		if (navProps.length === 0) return;
+		this.writeln();
+		this.write("static __navProps: ");
+		this.blockln("{}");
+		for (const { name, prop } of navProps) {
+			this.write(`"${escapeQuotes(name)}"`);
+			if (prop.token("optional")) this.write("?");
+			this.write(": ");
+			const propDef = prop.getDefinition();
+			if (propDef) {
+				const renderedDef = this.renderTypeDefString(propDef);
+				renderedDef.split("\n").forEach((l) => this.writeln(l));
+			} else this.writeln("unknown");
+		}
+		this.popln();
+	}
+	renderPk(node) {
 		const isMongoCollection = !!node.annotations?.some((a) => a.name === "db.mongo.collection");
 		let struct;
 		if (node.hasExtends) struct = this.doc.resolveInterfaceExtends(node);
@@ -586,7 +635,7 @@ else if (pkProps.length === 1) {
 		this.writeln(` */`);
 	}
 	constructor(doc, opts) {
-		super(doc), _define_property$3(this, "opts", void 0), this.opts = opts;
+		super(doc), _define_property$5(this, "opts", void 0), this.opts = opts;
 	}
 };
 function renderPrimitiveTypeDef(def) {
@@ -608,7 +657,7 @@ function renderPrimitiveTypeDef(def) {
 
 //#endregion
 //#region packages/typescript/src/validator.ts
-function _define_property$2(obj, key, value) {
+function _define_property$4(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -642,14 +691,14 @@ var Validator = class {
 	clear() {
 		this.stackErrors[this.stackErrors.length - 1] = null;
 	}
-	error(message, path$3, details) {
+	error(message, path$4, 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$3 || this.cachedPath,
+			path: path$4 || this.cachedPath,
 			message
 		};
 		if (details?.length) error.details = details;
@@ -687,7 +736,7 @@ var Validator = class {
 		if (this.isLimitExceeded()) return false;
 		if (!isAnnotatedType(def)) throw new Error("Can not validate not-annotated type");
 		if (typeof this.opts.replace === "function") def = this.opts.replace(def, this.cachedPath);
-		if (def.optional && value === undefined) return true;
+		if (def.optional && (value === undefined || value === null)) return true;
 		for (const plugin of this.opts.plugins) {
 			const result = plugin(this, def, value);
 			if (result === false || result === true) return result;
@@ -820,9 +869,9 @@ var Validator = class {
 		const typeKeys = new Set();
 		let skipList;
 		if (this.opts.skipList) {
-			const path$3 = this.stackPath.length > 1 ? `${this.cachedPath}.` : "";
-			for (const item of this.opts.skipList) if (item.startsWith(path$3)) {
-				const key = item.slice(path$3.length);
+			const path$4 = this.stackPath.length > 1 ? `${this.cachedPath}.` : "";
+			for (const item of this.opts.skipList) if (item.startsWith(path$4)) {
+				const key = item.slice(path$4.length);
 				if (!skipList) skipList = new Set();
 				skipList.add(key);
 				valueKeys.delete(key);
@@ -1014,13 +1063,13 @@ else {
 		return true;
 	}
 	constructor(def, opts) {
-		_define_property$2(this, "def", void 0);
-		_define_property$2(this, "opts", void 0);
-		/** Validation errors collected during the last {@link validate} call. */ _define_property$2(this, "errors", void 0);
-		_define_property$2(this, "stackErrors", void 0);
-		_define_property$2(this, "stackPath", void 0);
-		_define_property$2(this, "cachedPath", void 0);
-		_define_property$2(this, "context", void 0);
+		_define_property$4(this, "def", void 0);
+		_define_property$4(this, "opts", void 0);
+		/** Validation errors collected during the last {@link validate} call. */ _define_property$4(this, "errors", void 0);
+		_define_property$4(this, "stackErrors", void 0);
+		_define_property$4(this, "stackPath", void 0);
+		_define_property$4(this, "cachedPath", void 0);
+		_define_property$4(this, "context", void 0);
 		this.def = def;
 		this.errors = [];
 		this.stackErrors = [];
@@ -1037,7 +1086,7 @@ else {
 };
 var ValidatorError = class extends Error {
 	constructor(errors) {
-		super(`${errors[0].path ? errors[0].path + ": " : ""}${errors[0].message}`), _define_property$2(this, "errors", void 0), _define_property$2(this, "name", void 0), this.errors = errors, this.name = "Validation Error";
+		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";
 	}
 };
 
@@ -1058,7 +1107,8 @@ function createAnnotatedTypeNode(type, metadata, opts) {
 		metadata,
 		validator: validatorMethod,
 		id: opts?.id,
-		optional: opts?.optional
+		optional: opts?.optional,
+		ref: opts?.ref
 	};
 }
 function isAnnotatedType(type) {
@@ -1135,18 +1185,57 @@ function defineAnnotatedType(_kind, base) {
 			return this;
 		},
 		refTo(type$1, chain) {
-			if (!isAnnotatedType(type$1)) throw new Error(`${type$1} is not annotated type`);
-			let newBase = type$1;
-			const typeName = type$1.name || "Unknown";
-			if (chain) for (let i = 0; i < chain.length; i++) {
-				const c = chain[i];
-				if (newBase.type.kind === "object" && newBase.type.props.has(c)) newBase = newBase.type.props.get(c);
+			if (isAnnotatedType(type$1)) {
+				let newBase = type$1;
+				const typeName = type$1.name || "Unknown";
+				if (chain) for (let i = 0; i < chain.length; i++) {
+					const c = chain[i];
+					if (newBase.type.kind === "object" && newBase.type.props.has(c)) newBase = newBase.type.props.get(c);
 else {
-					const keys = chain.slice(0, i + 1).map((k) => `["${k}"]`).join("");
-					throw new Error(`Can't find prop ${typeName}${keys}`);
+						const keys = chain.slice(0, i + 1).map((k) => `["${k}"]`).join("");
+						throw new Error(`Can't find prop ${typeName}${keys}`);
+					}
 				}
-			}
-			this.$type = createAnnotatedTypeNode(newBase.type, metadata, { id: newBase.id });
+				this.$type = createAnnotatedTypeNode(newBase.type, metadata, {
+					id: newBase.id,
+					ref: chain && chain.length > 0 ? {
+						type: () => type$1,
+						field: chain.join(".")
+					} : undefined
+				});
+			} else if (typeof type$1 === "function") {
+				const lazyType = type$1;
+				this.$type = createAnnotatedTypeNode({ kind: "" }, metadata, { ref: {
+					type: lazyType,
+					field: chain ? chain.join(".") : ""
+				} });
+				const node = this.$type;
+				const placeholder = node.type;
+				Object.defineProperty(node, "type", {
+					get() {
+						const t = lazyType();
+						if (!isAnnotatedType(t)) {
+							Object.defineProperty(node, "type", {
+								value: placeholder,
+								writable: false,
+								configurable: true
+							});
+							return placeholder;
+						}
+						let target = t;
+						if (chain) for (const c of chain) if (target.type.kind === "object" && target.type.props.has(c)) target = target.type.props.get(c);
+else return t.type;
+						node.id = chain ? target.id : target.id || t.id;
+						Object.defineProperty(node, "type", {
+							value: target.type,
+							writable: false,
+							configurable: true
+						});
+						return target.type;
+					},
+					configurable: true
+				});
+			} else throw new TypeError(`${type$1} is not annotated type`);
 			return this;
 		},
 		annotate(key, value, asArray) {
@@ -1234,7 +1323,7 @@ function buildJsonSchema(type) {
 		const required = [];
 		for (const [key, val] of d.type.props.entries()) {
 			if (isPhantomType(val)) continue;
-			properties[key] = build$1(val);
+			properties[key] = build$2(val);
 			if (!val.optional) required.push(key);
 		}
 		const schema$1 = {
@@ -1244,7 +1333,7 @@ function buildJsonSchema(type) {
 		if (required.length > 0) schema$1.required = required;
 		return schema$1;
 	};
-	const build$1 = (def) => {
+	const build$2 = (def) => {
 		if (def.id && def.type.kind === "object" && def !== type) {
 			const name = def.id;
 			if (!defs[name]) {
@@ -1265,7 +1354,7 @@ function buildJsonSchema(type) {
 			array(d) {
 				const schema$1 = {
 					type: "array",
-					items: build$1(d.type.of)
+					items: build$2(d.type.of)
 				};
 				const minLength = meta.get("expect.minLength");
 				if (minLength) schema$1.minItems = typeof minLength === "number" ? minLength : minLength.length;
@@ -1276,7 +1365,7 @@ function buildJsonSchema(type) {
 			union(d) {
 				const disc = detectDiscriminator(d.type.items);
 				if (disc) {
-					const oneOf = d.type.items.map(build$1);
+					const oneOf = d.type.items.map(build$2);
 					const mapping = {};
 					for (const [val, idx] of Object.entries(disc.indexMapping)) {
 						const item = d.type.items[idx];
@@ -1290,15 +1379,15 @@ function buildJsonSchema(type) {
 						}
 					};
 				}
-				return { anyOf: d.type.items.map(build$1) };
+				return { anyOf: d.type.items.map(build$2) };
 			},
 			intersection(d) {
-				return { allOf: d.type.items.map(build$1) };
+				return { allOf: d.type.items.map(build$2) };
 			},
 			tuple(d) {
 				return {
 					type: "array",
-					items: d.type.items.map(build$1),
+					items: d.type.items.map(build$2),
 					additionalItems: false
 				};
 			},
@@ -1329,7 +1418,7 @@ else schema$1.allOf = (schema$1.allOf || []).concat(patterns.map((p) => ({ patte
 			}
 		});
 	};
-	const schema = build$1(type);
+	const schema = build$2(type);
 	if (hasDefs) return {
 		...schema,
 		$defs: defs
@@ -1339,7 +1428,7 @@ else schema$1.allOf = (schema$1.allOf || []).concat(patterns.map((p) => ({ patte
 
 //#endregion
 //#region packages/typescript/src/codegen/js-renderer.ts
-function _define_property$1(obj, key, value) {
+function _define_property$3(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -1349,6 +1438,19 @@ function _define_property$1(obj, key, value) {
 else obj[key] = value;
 	return obj;
 }
+const QUERY_OP_MAP = {
+	"=": "$eq",
+	"!=": "$ne",
+	">": "$gt",
+	">=": "$gte",
+	"<": "$lt",
+	"<=": "$lte",
+	"in": "$in",
+	"not in": "$nin",
+	"matches": "$regex",
+	"exists": "$exists",
+	"not exists": "$exists"
+};
 var JsRenderer = class extends BaseRenderer {
 	pre() {
 		this.writeln("// prettier-ignore-start");
@@ -1377,12 +1479,12 @@ else for (let i = 0; i < nodes.length; i++) this.typeIds.set(nodes[i], `${name}_
 	buildAdHocMap(annotateNodes) {
 		const map = new Map();
 		for (const annotateNode of annotateNodes) for (const entry of annotateNode.entries) {
-			const path$3 = entry.hasChain ? [entry.id, ...entry.chain.map((c) => c.text)].join(".") : entry.id;
+			const path$4 = 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$3);
+				const existing = map.get(path$4);
 				if (existing) existing.push(...anns);
-else map.set(path$3, [...anns]);
+else map.set(path$4, [...anns]);
 			}
 		}
 		return map.size > 0 ? map : null;
@@ -1631,8 +1733,8 @@ else handle.prop(prop.id, propHandle.$type);
 				const ref = node;
 				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
 				if ((0, __atscript_core.isPrimitive)(decl)) {
-					const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
-					if (!ownerDecl?.node || ownerDecl.node.entity !== "type" && ownerDecl.node.entity !== "interface") {
+					const ownerDecl$1 = this.doc.getDeclarationOwnerNode(ref.id);
+					if (!ownerDecl$1?.node || ownerDecl$1.node.entity !== "type" && ownerDecl$1.node.entity !== "interface") {
 						this.annotateType(decl, name);
 						return this;
 					}
@@ -1646,9 +1748,11 @@ else handle.prop(prop.id, propHandle.$type);
 					}
 				}
 				const chain = ref.hasChain ? `, [${ref.chain.map((c) => `"${escapeQuotes(c.text)}"`).join(", ")}]` : "";
-				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${ref.id}${chain})`);
+				const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
+				const isImported = ownerDecl ? ownerDecl.doc !== this.doc : false;
+				const refExpr = isImported ? `() => ${ref.id}` : ref.id;
+				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${refExpr}${chain})`);
 				if (!ref.hasChain) {
-					const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
 					if (ownerDecl?.node) {
 						const typeAnnotations = ownerDecl.doc.evalAnnotationsForNode(ownerDecl.node);
 						typeAnnotations?.forEach((an) => {
@@ -1815,8 +1919,8 @@ else if (resolved && (0, __atscript_core.isPrimitive)(resolved)) {
 		}
 		if (annotations === undefined) annotations = this.doc.evalAnnotationsForNode(node);
 		if (this._adHocAnnotations && this._propPath.length > 0) {
-			const path$3 = this._propPath.join(".");
-			const adHoc = this._adHocAnnotations.get(path$3);
+			const path$4 = this._propPath.join(".");
+			const adHoc = this._adHocAnnotations.get(path$4);
 			if (adHoc) annotations = this.doc.mergeNodesAnnotations(annotations, adHoc);
 		}
 		annotations?.forEach((an) => {
@@ -1842,6 +1946,68 @@ else if (resolved && (0, __atscript_core.isPrimitive)(resolved)) {
 		if (multiple) this.writeln(`.annotate("${escapeQuotes(an.name)}", ${value}, true)`);
 else this.writeln(`.annotate("${escapeQuotes(an.name)}", ${value})`);
 	}
+	emitRefValue(text) {
+		const dotIdx = text.indexOf(".");
+		if (dotIdx === -1) return `() => ${text}`;
+		const typeName = text.slice(0, dotIdx);
+		const field = text.slice(dotIdx + 1);
+		return `{ type: () => ${typeName}, field: "${escapeQuotes(field)}" }`;
+	}
+	emitArgValue(aSpec, argToken) {
+		if (aSpec.type === "ref") return this.emitRefValue(argToken.text);
+		if (aSpec.type === "query" && argToken.queryNode) return this.emitQueryTree(argToken.queryNode);
+		return aSpec.type === "string" ? `"${escapeQuotes(argToken.text)}"` : argToken.text;
+	}
+	emitQueryTree(queryNode) {
+		return this.emitQueryExpr(queryNode.expression);
+	}
+	emitQueryExpr(node) {
+		if ((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}] }`;
+	}
+	emitQueryComparison(node) {
+		const left = this.emitQueryFieldRef(node.left);
+		const mappedOp = QUERY_OP_MAP[node.operator] || node.operator;
+		const parts = [`left: ${left}`, `op: "${mappedOp}"`];
+		if (node.right) {
+			if ("fieldRef" in node.right && node.right.fieldRef) parts.push(`right: ${this.emitQueryFieldRef(node.right)}`);
+else if ("values" in node.right && node.right.values) {
+				const values = node.right.values.map((v) => this.emitQueryLiteral(v)).join(", ");
+				parts.push(`right: [${values}]`);
+			} else if ("valueToken" in node.right) parts.push(`right: ${this.emitQueryLiteral(node.right)}`);
+		} else if (node.operator === "exists") parts.push("right: true");
+else if (node.operator === "not exists") parts.push("right: false");
+		return `{ ${parts.join(", ")} }`;
+	}
+	emitQueryFieldRef(node) {
+		const parts = [];
+		if (node.typeRef) parts.push(`type: () => ${node.typeRef.text}`);
+		parts.push(`field: "${escapeQuotes(node.fieldRef.text)}"`);
+		return `{ ${parts.join(", ")} }`;
+	}
+	emitQueryLiteral(node) {
+		const token = node.valueToken;
+		switch (token.type) {
+			case "text": return `"${escapeQuotes(token.text)}"`;
+			case "number": return token.text;
+			case "regexp": {
+				const match = /^\/(.*)\/[a-z]*$/.exec(token.text);
+				return `"${escapeQuotes(match ? match[1] : token.text)}"`;
+			}
+			case "identifier": {
+				if (token.text === "true" || token.text === "false") return token.text;
+				if (token.text === "null" || token.text === "undefined") return "null";
+				return token.text;
+			}
+			default: return token.text;
+		}
+	}
 	computeAnnotationValue(node, an) {
 		const spec = this.doc.resolveAnnotation(an.name);
 		let targetValue = "true";
@@ -1853,13 +2019,13 @@ else this.writeln(`.annotate("${escapeQuotes(an.name)}", ${value})`);
 				targetValue = "{ ";
 				let i = 0;
 				for (const aSpec of spec.arguments) {
-					if (an.args[i]) targetValue += `${wrapProp(aSpec.name)}: ${aSpec.type === "string" ? `"${escapeQuotes(an.args[i]?.text)}"` : an.args[i]?.text}${i === length - 1 ? "" : ", "} `;
+					if (an.args[i]) targetValue += `${wrapProp(aSpec.name)}: ${this.emitArgValue(aSpec, an.args[i])}${i === length - 1 ? "" : ", "} `;
 					i++;
 				}
 				targetValue += "}";
 			} else {
 				const aSpec = spec.arguments[0];
-				if (an.args[0]) targetValue = aSpec.type === "string" ? `"${escapeQuotes(an.args[0]?.text)}"` : an.args[0]?.text;
+				if (an.args[0]) targetValue = this.emitArgValue(aSpec, an.args[0]);
 else targetValue = "true";
 			}
 		} else {
@@ -1999,7 +2165,7 @@ else {
 		return [];
 	}
 	constructor(doc, opts) {
-		super(doc), _define_property$1(this, "opts", void 0), _define_property$1(this, "postAnnotate", void 0), _define_property$1(this, "_adHocAnnotations", void 0), _define_property$1(this, "_propPath", void 0), _define_property$1(this, "typeIds", void 0), this.opts = opts, this.postAnnotate = [], this._adHocAnnotations = null, this._propPath = [], this.typeIds = 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), this.opts = opts, this.postAnnotate = [], this._adHocAnnotations = null, this._propPath = [], this.typeIds = new Map();
 	}
 };
 
@@ -2030,8 +2196,8 @@ const tsPlugin = (opts) => {
 				for (const [key, val] of Object.entries(annotations)) {
 					const multiple = val.multiple;
 					const typeLine = Array.from(val.types).map((t) => {
-						if (t.type === "object") return `{ ${Object.entries(t.props).map(([k, v]) => `${wrapProp(k)}${v.optional ? "?" : ""}: ${v.type}`).join(", ")} }`;
-else return t.optional ? `${t.type} | true` : t.type;
+						if (t.type === "object" && "props" in t) return `{ ${Object.entries(t.props).map(([k, v]) => `${wrapProp(k)}${v.optional ? "?" : ""}: ${v.type}`).join(", ")} }`;
+else return "optional" in t && t.optional ? `${t.type} | true` : t.type;
 					}).join(" | ");
 					rendered.push(`${wrapProp(key)}: ${multiple ? "(" : ""}${typeLine}${multiple ? ")[]" : ""}`);
 				}
@@ -2047,9 +2213,35 @@ else return t.optional ? `${t.type} | true` : t.type;
 	};
 };
 
+//#endregion
+//#region packages/typescript/src/cli/config.ts
+async function getConfig(configFile, logger) {
+	const root = process.cwd();
+	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`);
+			process.exit(1);
+		}
+		logger.log(`Using config file ${"\x1B[36m"}${configFile}${"\x1B[39m"}`);
+		return (0, __atscript_core.loadConfig)(c);
+	} else {
+		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(`No atscript config file found`);
+		return {
+			format: __atscript_core.DEFAULT_FORMAT,
+			plugins: [tsPlugin()]
+		};
+	}
+}
+
 //#endregion
 //#region packages/typescript/src/cli/commands.controller.ts
-function _define_property(obj, key, value) {
+function _define_property$2(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -2059,23 +2251,23 @@ function _define_property(obj, key, value) {
 else obj[key] = value;
 	return obj;
 }
-function _ts_decorate(decorators, target, key, desc) {
+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;
 	return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-function _ts_metadata(k, v) {
+function _ts_metadata$1(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-function _ts_param(paramIndex, decorator) {
+function _ts_param$1(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);
 	};
 }
 var Commands = class {
 	async default(configFile, format, noEmit, skipDiag) {
-		const config = await this.getConfig(configFile);
+		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);
@@ -2104,72 +2296,361 @@ else if (m.severity === 2) warningCount++;
 		}
 		if (errorCount > 0) process.exit(1);
 	}
-	async getConfig(configFile) {
-		const root = process.cwd();
-		if (configFile) {
-			const c = path.default.join(root, configFile);
-			if (!(0, fs.existsSync)(c)) {
-				this.logger.error(`Config file ${"\x1B[4m"}${configFile}${"\x1B[24m"} not found`);
-				process.exit(1);
-			}
-			this.logger.log(`Using config file ${"\x1B[36m"}${configFile}${"\x1B[39m"}`);
-			return (0, __atscript_core.loadConfig)(c);
-		} else {
-			const resolved = await (0, __atscript_core.resolveConfigFile)(root);
-			if (resolved) {
-				this.logger.log(`Using config file ${"\x1B[36m"}${resolved}${"\x1B[39m"}`);
-				return (0, __atscript_core.loadConfig)(resolved);
-			}
-			this.logger.log(`No atscript config file found`);
-			return {
-				format: __atscript_core.DEFAULT_FORMAT,
-				plugins: [tsPlugin()]
-			};
-		}
-	}
 	constructor(logger) {
-		_define_property(this, "logger", void 0);
+		_define_property$2(this, "logger", void 0);
 		this.logger = logger;
 	}
 };
-_ts_decorate([
+_ts_decorate$1([
 	(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")),
+	_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, 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, 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, moost.Optional)()),
+	_ts_param$1(3, (0, moost.Description)("Skip diagnostics and always emit files")),
+	_ts_metadata$1("design:type", Function),
+	_ts_metadata$1("design:paramtypes", [
+		String,
+		String,
+		Boolean,
+		Boolean
+	]),
+	_ts_metadata$1("design:returntype", Promise)
+], Commands.prototype, "default", null);
+Commands = _ts_decorate$1([
+	(0, moost.Controller)(),
+	_ts_param$1(0, (0, moost.InjectMoostLogger)("asc")),
+	_ts_metadata$1("design:type", Function),
+	_ts_metadata$1("design:paramtypes", [typeof TConsoleBase === "undefined" ? Object : TConsoleBase])
+], Commands);
+
+//#endregion
+//#region packages/typescript/src/cli/db-sync-printer.ts
+function _define_property$1(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+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"}`
+};
+const BANNER = DYE_COLORS.cyan(`
+
+     #############
+   #################
+    %#          #####
+                  ####
+     ##########   ####   #######
+   ############   #### ###########
+   ####    ####   #### ####    ###
+   ####    ####   #### ######
+   ####    ####   ####  #########
+   ####    ####   ####      ######
+   ####    ####   #### ###     ####
+   ############   #### ###########
+    ############  ####  #########
+            #########
+              #####
+
+`);
+const PLAN_HEADER = [
+	"",
+	DYE_COLORS.bold("╔══════════════════════════════════════╗"),
+	DYE_COLORS.bold("║        Schema Sync Plan              ║"),
+	DYE_COLORS.bold("╚══════════════════════════════════════╝"),
+	""
+];
+var DbSyncPrinter = class {
+	log(...args) {
+		console.log(...args);
+	}
+	banner() {
+		this.log(BANNER);
+	}
+	typeCount(count) {
+		this.log(`Found ${this.colors.cyan(String(count))} type(s)`);
+	}
+	planUpToDate(plan) {
+		this.log(`${this.colors.green(this.colors.bold("Schema is up to date."))}\n`);
+		this.printGrouped(plan.entries, "plan");
+		this.log("");
+	}
+	plan(plan) {
+		for (const line of PLAN_HEADER) this.log(line);
+		this.printGrouped(plan.entries, "plan");
+		this.log("");
+	}
+	result(result) {
+		this.log("");
+		this.log(`${this.colors.green(this.colors.bold("Schema synced successfully."))} Hash: ${result.schemaHash}`);
+		this.log("");
+		this.printGrouped(result.entries, "result");
+		this.log("");
+	}
+	printGrouped(entries, mode) {
+		const tables = entries.filter((e) => !e.viewType);
+		const views = entries.filter((e) => e.viewType);
+		if (tables.length > 0) {
+			this.log(this.colors.bold("Tables:"));
+			for (const e of tables) for (const line of e.print(mode, this.colors)) this.log(line);
+		}
+		if (views.length > 0) {
+			if (tables.length > 0) this.log("");
+			this.log(this.colors.bold("Views:"));
+			for (const e of views) for (const line of e.print(mode, this.colors)) this.log(line);
+		}
+	}
+	constructor() {
+		_define_property$1(this, "colors", DYE_COLORS);
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/cli/db-sync.controller.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+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;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+var DbSyncController = class {
+	async dbSync(configFile, dryRun, yes, force, safe) {
+		const config = await getConfig(configFile, 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"}`);
+			process.exit(1);
+		}
+		const [dbSpace, dbTypes] = await Promise.all([this.resolveDbSpace(config.db), this.compileAndLoadTypes(config)]);
+		if (dbTypes.length === 0) {
+			this.logger.log(`No types with @db.table or @db.view found. Nothing to sync.`);
+			return;
+		}
+		this.printer.typeCount(dbTypes.length);
+		this.printer.banner();
+		const { SchemaSync } = await this.importFromCwd("@atscript/utils-db/sync", true);
+		const sync = new SchemaSync(dbSpace);
+		const plan = await sync.plan(dbTypes, {
+			force,
+			safe
+		});
+		if (plan.status === "up-to-date") {
+			this.printer.planUpToDate(plan);
+			return;
+		}
+		const hasDestructive = plan.entries.some((e) => e.destructive);
+		const hasChanges = plan.entries.some((e) => e.hasChanges);
+		const hasErrors = plan.entries.some((e) => e.hasErrors);
+		this.printer.plan(plan);
+		if (hasErrors) {
+			this.logger.error(`Schema has errors. Fix the issues above before syncing.`);
+			process.exit(1);
+		}
+		if (!hasChanges) {
+			if (!dryRun) await sync.run(dbTypes, {
+				force: true,
+				safe
+			});
+			return;
+		}
+		if (dryRun) {
+			this.logger.log(`Dry run — no changes applied.`);
+			return;
+		}
+		if (hasDestructive) {
+			if (!yes) {
+				const confirmed = await this.confirm("Apply these changes? (includes destructive operations)");
+				if (!confirmed) {
+					this.logger.log("Aborted.");
+					return;
+				}
+			}
+		} else this.logger.log(`No destructive changes, proceeding to sync...`);
+		const result = await sync.run(dbTypes, {
+			force: true,
+			safe
+		});
+		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.logger.log(`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);
+		}
+		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 {}
+		}
+		return dbTypes;
+	}
+	async resolveDbSpace(dbConfig) {
+		if (typeof dbConfig === "function") {
+			this.logger.log(`Resolving database space from callback...`);
+			return await dbConfig();
+		}
+		const { adapter, connection, options } = dbConfig;
+		this.logger.log(`Using adapter: ${"\x1B[36m"}${adapter}${"\x1B[39m"}`);
+		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"}`);
+			process.exit(1);
+		}
+		if (typeof mod.createAdapter !== "function") {
+			this.logger.error(`${"\x1B[31m"}Adapter package "${adapter}" does not export a createAdapter function.${"\x1B[39m"}`);
+			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);
+		if (preferEsm) {
+			const mjsPath = resolved.replace(/\.cjs$/, ".mjs");
+			if ((0, fs.existsSync)(mjsPath)) resolved = mjsPath;
+		}
+		return import(
+			/* @vite-ignore */
+			(0, node_url.pathToFileURL)(resolved).href
+);
+	}
+	async confirm(message) {
+		const rl = (0, node_readline.createInterface)({
+			input: process.stdin,
+			output: process.stdout
+		});
+		return new Promise((resolve) => {
+			rl.question(`${message} [y/N] `, (answer) => {
+				rl.close();
+				resolve(answer.trim().toLowerCase() === "y");
+			});
+		});
+	}
+	constructor(logger) {
+		_define_property(this, "logger", void 0);
+		_define_property(this, "printer", void 0);
+		this.logger = logger;
+		this.printer = new DbSyncPrinter();
+	}
+};
+_ts_decorate([
+	(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)"),
 	_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)("f", "format")),
+	_ts_param(1, (0, __moostjs_event_cli.CliOption)("dry-run")),
 	_ts_param(1, (0, moost.Optional)()),
-	_ts_param(1, (0, moost.Description)("Output format (e.g. js, dts). Omit to run all plugins with their default output.")),
-	_ts_param(2, (0, __moostjs_event_cli.CliOption)("noEmit")),
+	_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, moost.Optional)()),
-	_ts_param(2, (0, moost.Description)("Only run diagnostics without emitting files")),
-	_ts_param(3, (0, __moostjs_event_cli.CliOption)("skipDiag")),
+	_ts_param(2, (0, moost.Description)("Skip confirmation prompt (CI mode)")),
+	_ts_param(3, (0, __moostjs_event_cli.CliOption)("force")),
 	_ts_param(3, (0, moost.Optional)()),
-	_ts_param(3, (0, moost.Description)("Skip diagnostics and always emit files")),
+	_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, moost.Optional)()),
+	_ts_param(4, (0, moost.Description)("Skip destructive operations (column/table drops)")),
 	_ts_metadata("design:type", Function),
 	_ts_metadata("design:paramtypes", [
 		String,
-		String,
+		Boolean,
+		Boolean,
 		Boolean,
 		Boolean
 	]),
 	_ts_metadata("design:returntype", Promise)
-], Commands.prototype, "default", null);
-Commands = _ts_decorate([
+], DbSyncController.prototype, "dbSync", null);
+DbSyncController = _ts_decorate([
 	(0, moost.Controller)(),
 	_ts_param(0, (0, moost.InjectMoostLogger)("asc")),
 	_ts_metadata("design:type", Function),
 	_ts_metadata("design:paramtypes", [typeof TConsoleBase === "undefined" ? Object : TConsoleBase])
-], Commands);
+], 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).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();