@atscript/typescript 0.1.34 → 0.1.36

package/dist/index.cjs

@@ -23,11 +23,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
+const require_json_schema = require('./json-schema-S5-XAOrR.cjs');
 const path = __toESM(require("path"));
 const __atscript_core = __toESM(require("@atscript/core"));
 
 //#region packages/typescript/src/codegen/code-printer.ts
-function _define_property$4(obj, key, value) {
+function _define_property$3(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -120,17 +121,17 @@ else this.write(closing);
 		return " ".repeat(this.indentLevel * this.indentSize);
 	}
 	constructor() {
-		_define_property$4(this, "lines", []);
-		_define_property$4(this, "currentLine", "");
-		_define_property$4(this, "indentLevel", 0);
-		_define_property$4(this, "indentSize", 2);
-		_define_property$4(this, "blockStack", []);
+		_define_property$3(this, "lines", []);
+		_define_property$3(this, "currentLine", "");
+		_define_property$3(this, "indentLevel", 0);
+		_define_property$3(this, "indentSize", 2);
+		_define_property$3(this, "blockStack", []);
 	}
 };
 
 //#endregion
 //#region packages/typescript/src/codegen/base-renderer.ts
-function _define_property$3(obj, key, value) {
+function _define_property$2(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -197,7 +198,7 @@ var BaseRenderer = class extends CodePrinter {
 		}
 	}
 	constructor(doc) {
-		super(), _define_property$3(this, "doc", void 0), _define_property$3(this, "_unused", void 0), this.doc = doc;
+		super(), _define_property$2(this, "doc", void 0), _define_property$2(this, "_unused", void 0), this.doc = doc;
 	}
 };
 
@@ -214,7 +215,7 @@ function escapeQuotes(str) {
 
 //#endregion
 //#region packages/typescript/src/codegen/type-renderer.ts
-function _define_property$2(obj, key, value) {
+function _define_property$1(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -339,8 +340,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);
 		}
 	}
@@ -431,14 +434,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
@@ -455,9 +457,27 @@ 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$2, descriptor] of flatMap) {
 			this.write(`"${escapeQuotes(path$2)}"`);
@@ -472,19 +492,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);
@@ -584,7 +631,7 @@ else if (pkProps.length === 1) {
 		this.writeln(` */`);
 	}
 	constructor(doc, opts) {
-		super(doc), _define_property$2(this, "opts", void 0), this.opts = opts;
+		super(doc), _define_property$1(this, "opts", void 0), this.opts = opts;
 	}
 };
 function renderPrimitiveTypeDef(def) {
@@ -604,777 +651,6 @@ function renderPrimitiveTypeDef(def) {
 	}
 }
 
-//#endregion
-//#region packages/typescript/src/validator.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 regexCache = new Map();
-var Validator = class {
-	isLimitExceeded() {
-		if (this.stackErrors.length > 0) {
-			const top = this.stackErrors[this.stackErrors.length - 1];
-			return top !== null && top.length >= this.opts.errorLimit;
-		}
-		return this.errors.length >= this.opts.errorLimit;
-	}
-	push(name) {
-		this.stackPath.push(name);
-		this.stackErrors.push(null);
-		this.cachedPath = this.stackPath.length <= 1 ? "" : this.stackPath[1] + (this.stackPath.length > 2 ? "." + this.stackPath.slice(2).join(".") : "");
-	}
-	pop(saveErrors) {
-		this.stackPath.pop();
-		const popped = this.stackErrors.pop();
-		if (saveErrors && popped !== null && popped !== undefined && popped.length > 0) for (const err of popped) this.error(err.message, err.path, err.details);
-		this.cachedPath = this.stackPath.length <= 1 ? "" : this.stackPath[1] + (this.stackPath.length > 2 ? "." + this.stackPath.slice(2).join(".") : "");
-		return popped;
-	}
-	clear() {
-		this.stackErrors[this.stackErrors.length - 1] = null;
-	}
-	error(message, path$2, 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$2 || this.cachedPath,
-			message
-		};
-		if (details?.length) error.details = details;
-		errors.push(error);
-	}
-	throw() {
-		throw new ValidatorError(this.errors);
-	}
-	/**
-	* Validates a value against the type definition.
-	*
-	* Acts as a TypeScript type guard — when it returns `true`, the value
-	* is narrowed to `DataType`.
-	*
-	* @param value - The value to validate.
-	* @param safe - If `true`, returns `false` on failure instead of throwing.
-	* @returns `true` if the value matches the type definition.
-	* @throws {ValidatorError} When validation fails and `safe` is not `true`.
-	*/ validate(value, safe, context) {
-		this.errors = [];
-		this.stackErrors = [];
-		this.stackPath = [""];
-		this.cachedPath = "";
-		this.context = context;
-		const passed = this.validateSafe(this.def, value);
-		this.pop(!passed);
-		this.context = undefined;
-		if (!passed) {
-			if (safe) return false;
-			this.throw();
-		}
-		return true;
-	}
-	validateSafe(def, value) {
-		if (this.isLimitExceeded()) return false;
-		if (!isAnnotatedType(def)) throw new Error("Can not validate not-annotated type");
-		if (typeof this.opts.replace === "function") def = this.opts.replace(def, this.cachedPath);
-		if (def.optional && value === undefined) return true;
-		for (const plugin of this.opts.plugins) {
-			const result = plugin(this, def, value);
-			if (result === false || result === true) return result;
-		}
-		return this.validateAnnotatedType(def, value);
-	}
-	get path() {
-		return this.cachedPath;
-	}
-	validateAnnotatedType(def, value) {
-		switch (def.type.kind) {
-			case "": {
-				if (def.type.designType === "phantom") return true;
-				return this.validatePrimitive(def, value);
-			}
-			case "object": return this.validateObject(def, value);
-			case "array": return this.validateArray(def, value);
-			case "union": return this.validateUnion(def, value);
-			case "intersection": return this.validateIntersection(def, value);
-			case "tuple": return this.validateTuple(def, value);
-			default: throw new Error(`Unknown type kind "${def.type.kind}"`);
-		}
-	}
-	validateUnion(def, value) {
-		let i = 0;
-		const popped = [];
-		for (const item of def.type.items) {
-			this.push(`[${item.type.kind || item.type.designType}(${i})]`);
-			if (this.validateSafe(item, value)) {
-				this.pop(false);
-				return true;
-			}
-			const errors = this.pop(false);
-			if (errors) popped.push(...errors);
-			i++;
-		}
-		this.clear();
-		const expected = def.type.items.map((item, i$1) => `[${item.type.kind || item.type.designType}(${i$1})]`).join(", ");
-		this.error(`Value does not match any of the allowed types: ${expected}`, undefined, popped);
-		return false;
-	}
-	validateIntersection(def, value) {
-		for (const item of def.type.items) if (!this.validateSafe(item, value)) return false;
-		return true;
-	}
-	validateTuple(def, value) {
-		if (!Array.isArray(value) || value.length !== def.type.items.length) {
-			this.error(`Expected array of length ${def.type.items.length}`);
-			return false;
-		}
-		let i = 0;
-		for (const item of def.type.items) {
-			this.push(String(i));
-			if (!this.validateSafe(item, value[i])) {
-				this.pop(true);
-				return false;
-			}
-			this.pop(false);
-			i++;
-		}
-		return true;
-	}
-	validateArray(def, value) {
-		if (!Array.isArray(value)) {
-			this.error("Expected array");
-			return false;
-		}
-		const minLength = def.metadata.get("expect.minLength");
-		if (minLength) {
-			const length = typeof minLength === "number" ? minLength : minLength.length;
-			if (value.length < length) {
-				const message = typeof minLength === "object" && minLength.message ? minLength.message : `Expected minimum length of ${length} items, got ${value.length} items`;
-				this.error(message);
-				return false;
-			}
-		}
-		const maxLength = def.metadata.get("expect.maxLength");
-		if (maxLength) {
-			const length = typeof maxLength === "number" ? maxLength : maxLength.length;
-			if (value.length > length) {
-				const message = typeof maxLength === "object" && maxLength.message ? maxLength.message : `Expected maximum length of ${length} items, got ${value.length} items`;
-				this.error(message);
-				return false;
-			}
-		}
-		const uniqueItems = def.metadata.get("expect.array.uniqueItems");
-		if (uniqueItems) {
-			const separator = "▼↩";
-			const seen = new Set();
-			const keyProps = new Set();
-			if (def.type.of.type.kind === "object") {
-				for (const [key, val] of def.type.of.type.props.entries()) if (val.metadata.get("expect.array.key")) keyProps.add(key);
-			}
-			for (let idx = 0; idx < value.length; idx++) {
-				const item = value[idx];
-				let key;
-				if (keyProps.size > 0) {
-					key = "";
-					for (const prop of keyProps) key += JSON.stringify(item[prop]) + separator;
-				} else key = JSON.stringify(item);
-				if (seen.has(key)) {
-					this.push(String(idx));
-					this.error(uniqueItems.message || "Duplicate items are not allowed");
-					this.pop(true);
-					return false;
-				}
-				seen.add(key);
-			}
-		}
-		let i = 0;
-		let passed = true;
-		for (const item of value) {
-			this.push(String(i));
-			if (!this.validateSafe(def.type.of, item)) {
-				passed = false;
-				this.pop(true);
-				if (this.isLimitExceeded()) return false;
-			} else this.pop(false);
-			i++;
-		}
-		return passed;
-	}
-	validateObject(def, value) {
-		if (typeof value !== "object" || value === null || Array.isArray(value)) {
-			this.error("Expected object");
-			return false;
-		}
-		let passed = true;
-		const valueKeys = new Set(Object.keys(value));
-		const typeKeys = new Set();
-		let skipList;
-		if (this.opts.skipList) {
-			const path$2 = this.stackPath.length > 1 ? `${this.cachedPath}.` : "";
-			for (const item of this.opts.skipList) if (item.startsWith(path$2)) {
-				const key = item.slice(path$2.length);
-				if (!skipList) skipList = new Set();
-				skipList.add(key);
-				valueKeys.delete(key);
-			}
-		}
-		let partialFunctionMatched = false;
-		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.cachedPath);
-		for (const [key, item] of def.type.props.entries()) {
-			if (skipList && skipList.has(key) || isPhantomType(item)) continue;
-			typeKeys.add(key);
-			if (value[key] === undefined) {
-				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
-			}
-			this.push(key);
-			if (this.validateSafe(item, value[key])) this.pop(false);
-else {
-				passed = false;
-				this.pop(true);
-				if (this.isLimitExceeded()) return false;
-			}
-		}
-		for (const key of valueKeys)
- /** matched patterns for unknown keys */ if (!typeKeys.has(key)) {
-			const matched = [];
-			for (const { pattern, def: propDef } of def.type.propsPatterns) if (pattern.test(key)) matched.push({
-				pattern,
-				def: propDef
-			});
-			if (matched.length > 0) {
-				this.push(key);
-				let keyPassed = false;
-				for (const { def: propDef } of matched) {
-					if (this.validateSafe(propDef, value[key])) {
-						keyPassed = true;
-						break;
-					}
-					this.clear();
-				}
-				if (!keyPassed) {
-					this.validateSafe(matched[0].def, value[key]);
-					this.pop(true);
-					passed = false;
-					if (this.isLimitExceeded()) return false;
-				} else this.pop(false);
-			} else if (this.opts.unknownProps !== "ignore") {
-				if (this.opts.unknownProps === "error") {
-					this.push(key);
-					this.error(`Unexpected property`);
-					this.pop(true);
-					if (this.isLimitExceeded()) return false;
-					passed = false;
-				} else if (this.opts.unknownProps === "strip") delete value[key];
-			}
-		}
-		return passed;
-	}
-	validatePrimitive(def, value) {
-		if (def.type.value !== undefined) {
-			if (value !== def.type.value) {
-				this.error(`Expected ${def.type.value}, got ${value}`);
-				return false;
-			}
-			return true;
-		}
-		const typeOfValue = Array.isArray(value) ? "array" : typeof value;
-		switch (def.type.designType) {
-			case "never": {
-				this.error(`This type is impossible, must be an internal problem`);
-				return false;
-			}
-			case "any": return true;
-			case "string": {
-				if (typeOfValue !== def.type.designType) {
-					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
-					return false;
-				}
-				return this.validateString(def, value);
-			}
-			case "number": {
-				if (typeOfValue !== def.type.designType) {
-					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
-					return false;
-				}
-				return this.validateNumber(def, value);
-			}
-			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) {
-					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
-					return false;
-				}
-				return true;
-			}
-			case "null": {
-				if (value !== null) {
-					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
-					return false;
-				}
-				return true;
-			}
-			default: throw new Error(`Unknown type "${def.type.designType}"`);
-		}
-	}
-	validateString(def, value) {
-		const filled = def.metadata.get("meta.required");
-		if (filled) {
-			if (value.trim().length === 0) {
-				const message = typeof filled === "object" && filled.message ? filled.message : `Must not be empty`;
-				this.error(message);
-				return false;
-			}
-		}
-		const minLength = def.metadata.get("expect.minLength");
-		if (minLength) {
-			const length = typeof minLength === "number" ? minLength : minLength.length;
-			if (value.length < length) {
-				const message = typeof minLength === "object" && minLength.message ? minLength.message : `Expected minimum length of ${length} characters, got ${value.length} characters`;
-				this.error(message);
-				return false;
-			}
-		}
-		const maxLength = def.metadata.get("expect.maxLength");
-		if (maxLength) {
-			const length = typeof maxLength === "number" ? maxLength : maxLength.length;
-			if (value.length > length) {
-				const message = typeof maxLength === "object" && maxLength.message ? maxLength.message : `Expected maximum length of ${length} characters, got ${value.length} characters`;
-				this.error(message);
-				return false;
-			}
-		}
-		const patterns = def.metadata.get("expect.pattern");
-		for (const { pattern, flags, message } of patterns || []) {
-			if (!pattern) continue;
-			const cacheKey = `${pattern}//${flags || ""}`;
-			let regex = regexCache.get(cacheKey);
-			if (!regex) {
-				regex = new RegExp(pattern, flags);
-				regexCache.set(cacheKey, regex);
-			}
-			if (!regex.test(value)) {
-				this.error(message || `Value is expected to match pattern "${pattern}"`);
-				return false;
-			}
-		}
-		return true;
-	}
-	validateNumber(def, value) {
-		const int = def.metadata.get("expect.int");
-		if (int && value % 1 !== 0) {
-			const message = typeof int === "object" && int.message ? int.message : `Expected integer, got ${value}`;
-			this.error(message);
-			return false;
-		}
-		const min = def.metadata.get("expect.min");
-		if (min) {
-			const minValue = typeof min === "number" ? min : min.minValue;
-			if (value < minValue) {
-				const message = typeof min === "object" && min.message ? min.message : `Expected minimum ${minValue}, got ${value}`;
-				this.error(message);
-				return false;
-			}
-		}
-		const max = def.metadata.get("expect.max");
-		if (max) {
-			const maxValue = typeof max === "number" ? max : max.maxValue;
-			if (value > maxValue) {
-				const message = typeof max === "object" && max.message ? max.message : `Expected maximum ${maxValue}, got ${value}`;
-				this.error(message);
-				return false;
-			}
-		}
-		return true;
-	}
-	validateBoolean(def, value) {
-		const filled = def.metadata.get("meta.required");
-		if (filled) {
-			if (value !== true) {
-				const message = typeof filled === "object" && filled.message ? filled.message : `Must be checked`;
-				this.error(message);
-				return false;
-			}
-		}
-		return true;
-	}
-	constructor(def, opts) {
-		_define_property$1(this, "def", void 0);
-		_define_property$1(this, "opts", void 0);
-		/** Validation errors collected during the last {@link validate} call. */ _define_property$1(this, "errors", void 0);
-		_define_property$1(this, "stackErrors", void 0);
-		_define_property$1(this, "stackPath", void 0);
-		_define_property$1(this, "cachedPath", void 0);
-		_define_property$1(this, "context", void 0);
-		this.def = def;
-		this.errors = [];
-		this.stackErrors = [];
-		this.stackPath = [];
-		this.cachedPath = "";
-		this.opts = {
-			partial: false,
-			unknownProps: "error",
-			errorLimit: 10,
-			...opts,
-			plugins: opts?.plugins || []
-		};
-	}
-};
-var ValidatorError = class extends Error {
-	constructor(errors) {
-		super(`${errors[0].path ? errors[0].path + ": " : ""}${errors[0].message}`), _define_property$1(this, "errors", void 0), _define_property$1(this, "name", void 0), this.errors = errors, this.name = "Validation Error";
-	}
-};
-
-//#endregion
-//#region packages/typescript/src/annotated-type.ts
-const COMPLEX_KINDS = new Set([
-	"union",
-	"intersection",
-	"tuple"
-]);
-/** Shared validator method reused by all annotated type nodes. */ function validatorMethod(opts) {
-	return new Validator(this, opts);
-}
-function createAnnotatedTypeNode(type, metadata, opts) {
-	return {
-		__is_atscript_annotated_type: true,
-		type,
-		metadata,
-		validator: validatorMethod,
-		id: opts?.id,
-		optional: opts?.optional,
-		ref: opts?.ref
-	};
-}
-function isAnnotatedType(type) {
-	return type && type.__is_atscript_annotated_type;
-}
-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, [value]);
-else metadata.set(key, value);
-}
-function defineAnnotatedType(_kind, base) {
-	const kind = _kind || "";
-	const type = base?.type || {};
-	type.kind = kind;
-	if (COMPLEX_KINDS.has(kind)) type.items = [];
-	if (kind === "object") {
-		type.props = new Map();
-		type.propsPatterns = [];
-	}
-	type.tags = new Set();
-	const metadata = base?.metadata || new Map();
-	const payload = {
-		__is_atscript_annotated_type: true,
-		metadata,
-		type,
-		validator: validatorMethod
-	};
-	base = base ? Object.assign(base, payload) : payload;
-	const handle = {
-		$type: base,
-		$def: type,
-		$metadata: metadata,
-		tags(...tags) {
-			for (const tag of tags) this.$def.tags.add(tag);
-			return this;
-		},
-		designType(value) {
-			this.$def.designType = value;
-			return this;
-		},
-		value(value) {
-			this.$def.value = value;
-			return this;
-		},
-		of(value) {
-			this.$def.of = value;
-			return this;
-		},
-		item(value) {
-			this.$def.items.push(value);
-			return this;
-		},
-		prop(name, value) {
-			this.$def.props.set(name, value);
-			return this;
-		},
-		propPattern(pattern, def) {
-			this.$def.propsPatterns.push({
-				pattern,
-				def
-			});
-			return this;
-		},
-		optional(value = true) {
-			this.$type.optional = value;
-			return this;
-		},
-		copyMetadata(fromMetadata, ignore) {
-			for (const [key, value] of fromMetadata.entries()) if (!ignore || !ignore.has(key)) this.$metadata.set(key, value);
-			return this;
-		},
-		refTo(type$1, chain) {
-			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}`);
-					}
-				}
-				this.$type = createAnnotatedTypeNode(newBase.type, metadata, {
-					id: newBase.id,
-					ref: chain && chain.length > 0 ? {
-						type: () => type$1,
-						field: chain.join(".")
-					} : undefined
-				});
-			} else if (typeof type$1 === "function") {
-				const lazyType = type$1;
-				this.$type = createAnnotatedTypeNode({ kind: "" }, metadata, { ref: {
-					type: lazyType,
-					field: chain ? chain.join(".") : ""
-				} });
-				const node = this.$type;
-				const placeholder = node.type;
-				Object.defineProperty(node, "type", {
-					get() {
-						const t = lazyType();
-						if (!isAnnotatedType(t)) {
-							Object.defineProperty(node, "type", {
-								value: placeholder,
-								writable: false,
-								configurable: true
-							});
-							return placeholder;
-						}
-						let target = t;
-						if (chain) for (const c of chain) if (target.type.kind === "object" && target.type.props.has(c)) target = target.type.props.get(c);
-else return t.type;
-						node.id = target.id || t.id;
-						Object.defineProperty(node, "type", {
-							value: target.type,
-							writable: false,
-							configurable: true
-						});
-						return target.type;
-					},
-					configurable: true
-				});
-			} else throw new Error(`${type$1} is not annotated type`);
-			return this;
-		},
-		annotate(key, value, asArray) {
-			annotate(this.$metadata, key, value, asArray);
-			return this;
-		},
-		id(value) {
-			this.$type.id = value;
-			return this;
-		}
-	};
-	return handle;
-}
-function isPhantomType(def) {
-	return def.type.kind === "" && def.type.designType === "phantom";
-}
-
-//#endregion
-//#region packages/typescript/src/traverse.ts
-function forAnnotatedType(def, handlers) {
-	switch (def.type.kind) {
-		case "": {
-			const typed = def;
-			if (handlers.phantom && typed.type.designType === "phantom") return handlers.phantom(typed);
-			return handlers.final(typed);
-		}
-		case "object": return handlers.object(def);
-		case "array": return handlers.array(def);
-		case "union": return handlers.union(def);
-		case "intersection": return handlers.intersection(def);
-		case "tuple": return handlers.tuple(def);
-		default: throw new Error(`Unknown type kind "${def.type.kind}"`);
-	}
-}
-
-//#endregion
-//#region packages/typescript/src/json-schema.ts
-/**
-* 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.
-*/ 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);
-	let result = null;
-	for (const candidate of candidates) {
-		const values = 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) {
-				valid = false;
-				break;
-			}
-			const val = prop.type.value;
-			if (values.has(val)) {
-				valid = false;
-				break;
-			}
-			values.add(val);
-			indexMapping[String(val)] = i;
-		}
-		if (valid) {
-			if (result) return null;
-			result = {
-				propertyName: candidate,
-				indexMapping
-			};
-		}
-	}
-	return result;
-}
-function buildJsonSchema(type) {
-	const defs = {};
-	let hasDefs = false;
-	const buildObject = (d) => {
-		const properties = {};
-		const required = [];
-		for (const [key, val] of d.type.props.entries()) {
-			if (isPhantomType(val)) continue;
-			properties[key] = build(val);
-			if (!val.optional) required.push(key);
-		}
-		const schema$1 = {
-			type: "object",
-			properties
-		};
-		if (required.length > 0) schema$1.required = required;
-		return schema$1;
-	};
-	const build = (def) => {
-		if (def.id && def.type.kind === "object" && def !== type) {
-			const name = def.id;
-			if (!defs[name]) {
-				hasDefs = true;
-				defs[name] = {};
-				defs[name] = buildObject(def);
-			}
-			return { $ref: `#/$defs/${name}` };
-		}
-		const meta = def.metadata;
-		return forAnnotatedType(def, {
-			phantom() {
-				return {};
-			},
-			object(d) {
-				return buildObject(d);
-			},
-			array(d) {
-				const schema$1 = {
-					type: "array",
-					items: build(d.type.of)
-				};
-				const minLength = meta.get("expect.minLength");
-				if (minLength) schema$1.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;
-			},
-			union(d) {
-				const disc = detectDiscriminator(d.type.items);
-				if (disc) {
-					const oneOf = d.type.items.map(build);
-					const mapping = {};
-					for (const [val, idx] of Object.entries(disc.indexMapping)) {
-						const item = d.type.items[idx];
-						mapping[val] = item.id && defs[item.id] ? `#/$defs/${item.id}` : `#/oneOf/${idx}`;
-					}
-					return {
-						oneOf,
-						discriminator: {
-							propertyName: disc.propertyName,
-							mapping
-						}
-					};
-				}
-				return { anyOf: d.type.items.map(build) };
-			},
-			intersection(d) {
-				return { allOf: d.type.items.map(build) };
-			},
-			tuple(d) {
-				return {
-					type: "array",
-					items: d.type.items.map(build),
-					additionalItems: false
-				};
-			},
-			final(d) {
-				const schema$1 = {};
-				if (d.type.value !== undefined) schema$1.const = d.type.value;
-				if (d.type.designType && d.type.designType !== "any") {
-					schema$1.type = d.type.designType === "undefined" ? "null" : d.type.designType;
-					if (schema$1.type === "number" && meta.get("expect.int")) schema$1.type = "integer";
-				}
-				if (schema$1.type === "string") {
-					if (meta.get("meta.required")) schema$1.minLength = 1;
-					const minLength = meta.get("expect.minLength");
-					if (minLength) schema$1.minLength = typeof minLength === "number" ? minLength : minLength.length;
-					const maxLength = meta.get("expect.maxLength");
-					if (maxLength) schema$1.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 (schema$1.type === "number" || schema$1.type === "integer") {
-					const min = meta.get("expect.min");
-					if (min) schema$1.minimum = typeof min === "number" ? min : min.minValue;
-					const max = meta.get("expect.max");
-					if (max) schema$1.maximum = typeof max === "number" ? max : max.maxValue;
-				}
-				return schema$1;
-			}
-		});
-	};
-	const schema = build(type);
-	if (hasDefs) return {
-		...schema,
-		$defs: defs
-	};
-	return schema;
-}
-
 //#endregion
 //#region packages/typescript/src/codegen/js-renderer.ts
 function _define_property(obj, key, value) {
@@ -1387,6 +663,19 @@ function _define_property(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");
@@ -1507,7 +796,7 @@ else def = def.getDefinition() || def;
 		const mode = resolveJsonSchemaMode(this.opts);
 		const hasAnnotation = node.countAnnotations("emit.jsonSchema") > 0;
 		if (hasAnnotation || mode === "bundle") {
-			const schema = JSON.stringify(buildJsonSchema(this.toAnnotatedType(node)));
+			const schema = JSON.stringify(require_json_schema.buildJsonSchema(this.toAnnotatedType(node)));
 			this.writeln("static toJsonSchema() {");
 			this.indent().writeln(`return ${schema}`).unindent();
 			this.writeln("}");
@@ -1532,7 +821,7 @@ else def = def.getDefinition() || def;
 		return this.toAnnotatedHandle(node).$type;
 	}
 	toAnnotatedHandle(node, skipAnnotations = false) {
-		if (!node) return defineAnnotatedType();
+		if (!node) return require_json_schema.defineAnnotatedType();
 		switch (node.entity) {
 			case "interface":
 			case "type": {
@@ -1564,14 +853,14 @@ else def = def.getDefinition() || def;
 			}
 			case "primitive": {
 				const prim = node;
-				const handle = defineAnnotatedType();
+				const handle = require_json_schema.defineAnnotatedType();
 				handle.designType(prim.id === "never" ? "never" : prim.config.type);
 				if (!skipAnnotations) this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
 				return handle;
 			}
 			case "const": {
 				const c = node;
-				const handle = defineAnnotatedType();
+				const handle = require_json_schema.defineAnnotatedType();
 				const t = c.token("identifier")?.type;
 				handle.designType(t === "number" ? "number" : "string");
 				handle.value(t === "number" ? Number(c.id) : c.id);
@@ -1579,7 +868,7 @@ else def = def.getDefinition() || def;
 			}
 			case "structure": {
 				const struct = node;
-				const handle = defineAnnotatedType("object");
+				const handle = require_json_schema.defineAnnotatedType("object");
 				for (const prop of Array.from(struct.props.values())) {
 					const propHandle = this.toAnnotatedHandle(prop);
 					const pattern = prop.token("identifier")?.pattern;
@@ -1591,24 +880,24 @@ else handle.prop(prop.id, propHandle.$type);
 			case "group": {
 				const group = node;
 				const kind = group.op === "|" ? "union" : "intersection";
-				const handle = defineAnnotatedType(kind);
+				const handle = require_json_schema.defineAnnotatedType(kind);
 				for (const item of group.unwrap()) handle.item(this.toAnnotatedHandle(item).$type);
 				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
 			}
 			case "tuple": {
 				const group = node;
-				const handle = defineAnnotatedType("tuple");
+				const handle = require_json_schema.defineAnnotatedType("tuple");
 				for (const item of group.unwrap()) handle.item(this.toAnnotatedHandle(item).$type);
 				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
 			}
 			case "array": {
 				const arr = node;
-				const handle = defineAnnotatedType("array");
+				const handle = require_json_schema.defineAnnotatedType("array");
 				handle.of(this.toAnnotatedHandle(arr.getDefinition()).$type);
 				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
 			}
 			default: {
-				const handle = defineAnnotatedType();
+				const handle = require_json_schema.defineAnnotatedType();
 				return skipAnnotations ? handle : this.applyExpectAnnotations(handle, this.doc.evalAnnotationsForNode(node));
 			}
 		}
@@ -1882,6 +1171,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";
@@ -1893,13 +1244,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 {
@@ -2070,8 +1421,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 ? ")[]" : ""}`);
 				}