@atscript/core 0.1.26 → 0.1.28

package/dist/index.mjs

@@ -409,60 +409,13 @@ else obj[key] = value;
 var SemanticPrimitiveNode = class SemanticPrimitiveNode extends SemanticNode {
 	applyAnnotations() {
 		this.annotations = [];
-		if (this.type === "string" || this.type === "array") {
-			if (typeof this.config.expect?.minLength === "number") this.annotations.push({
-				name: "expect.minLength",
-				token: dummyToken,
-				args: [num(this.config.expect.minLength)]
-			});
-			if (typeof this.config.expect?.maxLength === "number") this.annotations.push({
-				name: "expect.maxLength",
-				token: dummyToken,
-				args: [num(this.config.expect.maxLength)]
-			});
-		}
-		if (this.type === "string") {
-			if (this.config.expect?.required === true) this.annotations.push({
-				name: "meta.required",
-				token: dummyToken,
-				args: []
-			});
-			if (this.config.expect?.pattern !== undefined) {
-				const patterns = Array.isArray(this.config.expect.pattern) ? this.config.expect.pattern : [this.config.expect.pattern];
-				for (const p of patterns) {
-					const args = typeof p === "string" ? [text$1(p)] : [text$1(p.source), text$1(p.flags)];
-					if (this.config.expect.message) args[2] = text$1(this.config.expect.message);
-					this.annotations.push({
-						name: "expect.pattern",
-						token: dummyToken,
-						args
-					});
-				}
-			}
-		}
-		if (this.type === "number") {
-			if (typeof this.config.expect?.min === "number") this.annotations.push({
-				name: "expect.min",
-				token: dummyToken,
-				args: [num(this.config.expect.min)]
-			});
-			if (typeof this.config.expect?.max === "number") this.annotations.push({
-				name: "expect.max",
-				token: dummyToken,
-				args: [num(this.config.expect.max)]
-			});
-			if (this.config.expect?.int === true) this.annotations.push({
-				name: "expect.int",
-				token: dummyToken,
-				args: []
-			});
-		}
-		if (this.type === "boolean") {
-			if (this.config.expect?.required === true) this.annotations.push({
-				name: "meta.required",
-				token: dummyToken,
-				args: []
-			});
+		for (const [name, value] of Object.entries(this.config.annotations || {})) {
+			const spec = this.annotationTree ? resolveAnnotation(name, this.annotationTree) : undefined;
+			const isMultiple = spec?.config.multiple ?? false;
+			if (Array.isArray(value)) {
+				if (isMultiple) for (const item of value) this.annotations.push(toAnnotationTokens(name, item, spec));
+else if (value.length > 0) this.annotations.push(toAnnotationTokens(name, value[0], spec));
+			} else this.annotations.push(toAnnotationTokens(name, value, spec));
 		}
 	}
 	get key() {
@@ -491,8 +444,8 @@ var SemanticPrimitiveNode = class SemanticPrimitiveNode extends SemanticNode {
 		s += this.renderChildren();
 		return indent + s.split("\n").join(`\n${indent}`);
 	}
-	constructor(_id, config, parentKey = "") {
-		super("primitive"), _define_property$11(this, "_id", void 0), _define_property$11(this, "config", void 0), _define_property$11(this, "parentKey", void 0), _define_property$11(this, "type", void 0), _define_property$11(this, "props", void 0), _define_property$11(this, "tags", void 0), this._id = _id, this.config = config, this.parentKey = parentKey;
+	constructor(_id, config, parentKey = "", annotationTree) {
+		super("primitive"), _define_property$11(this, "_id", void 0), _define_property$11(this, "config", void 0), _define_property$11(this, "parentKey", void 0), _define_property$11(this, "annotationTree", void 0), _define_property$11(this, "type", void 0), _define_property$11(this, "props", void 0), _define_property$11(this, "tags", void 0), this._id = _id, this.config = config, this.parentKey = parentKey, this.annotationTree = annotationTree;
 		this.props = new Map();
 		this.tags = new Set([_id, ...config?.tags || []]);
 		for (const [ext, def] of Object.entries(config.extensions || {})) {
@@ -501,11 +454,11 @@ var SemanticPrimitiveNode = class SemanticPrimitiveNode extends SemanticNode {
 				documentation: def.documentation ?? config.documentation,
 				extensions: def.extensions,
 				tags: Array.from(new Set([...def.tags || [], ...Array.from(this.tags)])),
-				expect: {
-					...config.expect,
-					...def.expect
+				annotations: {
+					...config.annotations,
+					...def.annotations
 				}
-			}, this.key);
+			}, this.key, this.annotationTree);
 			this.props.set(ext, node);
 		}
 		if (typeof config.type === "object") this.type = config.type.kind === "final" ? config.type.value : config.type.kind;
@@ -513,6 +466,36 @@ else this.type = config.type;
 		this.applyAnnotations();
 	}
 };
+function toAnnotationTokens(name, value, spec) {
+	if (typeof value === "boolean") return {
+		name,
+		token: dummyToken,
+		args: []
+	};
+	if (typeof value === "string") return {
+		name,
+		token: dummyToken,
+		args: [text$1(value)]
+	};
+	if (typeof value === "number") return {
+		name,
+		token: dummyToken,
+		args: [num(value)]
+	};
+	const argNames = spec?.arguments.map((a) => a.name) ?? Object.keys(value);
+	const raw = argNames.map((argName) => {
+		const v = value[argName];
+		if (v === undefined) return undefined;
+		return typeof v === "number" ? num(v) : text$1(String(v));
+	});
+	while (raw.length > 0 && raw[raw.length - 1] === undefined) raw.pop();
+	const args = raw.map((t) => t ?? text$1(""));
+	return {
+		name,
+		token: dummyToken,
+		args
+	};
+}
 const dummyToken = new Token({
 	getRange: () => ({
 		end: {
@@ -3024,6 +3007,162 @@ const zeroRange = {
 	}
 };
 
+//#endregion
+//#region packages/core/src/defaults/db-annotations.ts
+const dbAnnotations = {
+	table: new AnnotationSpec({
+		description: "Marks an interface as a database-persisted entity (table in SQL, collection in MongoDB). If the name argument is omitted, the adapter derives the table name from the interface name.\n\n**Example:**\n```atscript\n@db.table \"users\"\nexport interface User { ... }\n```\n",
+		nodeType: ["interface"],
+		argument: {
+			optional: true,
+			name: "name",
+			type: "string",
+			description: "Table/collection name. If omitted, derived from interface name."
+		}
+	}),
+	schema: new AnnotationSpec({
+		description: "Assigns the entity to a database schema/namespace.\n\n**Example:**\n```atscript\n@db.table \"users\"\n@db.schema \"auth\"\nexport interface User { ... }\n```\n",
+		nodeType: ["interface"],
+		argument: {
+			name: "name",
+			type: "string",
+			description: "Schema/namespace name."
+		}
+	}),
+	index: {
+		plain: new AnnotationSpec({
+			description: "Standard (non-unique) index for query performance. Fields sharing the same index name form a composite index.\n\n**Example:**\n```atscript\n@db.index.plain \"idx_timeline\", \"desc\"\ncreatedAt: number.timestamp\n```\n",
+			nodeType: ["prop"],
+			multiple: true,
+			mergeStrategy: "append",
+			argument: [{
+				optional: true,
+				name: "name",
+				type: "string",
+				description: "Index name / composite group name."
+			}, {
+				optional: true,
+				name: "sort",
+				type: "string",
+				values: ["asc", "desc"],
+				description: "Sort direction. Defaults to \"asc\"."
+			}]
+		}),
+		unique: new AnnotationSpec({
+			description: "Unique index — ensures no two rows/documents have the same value(s). Fields sharing the same index name form a composite unique constraint.\n\n**Example:**\n```atscript\n@db.index.unique \"tenant_email\"\nemail: string.email\n```\n",
+			nodeType: ["prop"],
+			multiple: true,
+			mergeStrategy: "append",
+			argument: {
+				optional: true,
+				name: "name",
+				type: "string",
+				description: "Index name / composite group name."
+			}
+		}),
+		fulltext: new AnnotationSpec({
+			description: "Full-text search index. Fields sharing the same index name form a composite full-text index.\n\n**Example:**\n```atscript\n@db.index.fulltext \"ft_content\"\ntitle: string\n```\n",
+			nodeType: ["prop"],
+			multiple: true,
+			mergeStrategy: "append",
+			argument: {
+				optional: true,
+				name: "name",
+				type: "string",
+				description: "Index name / composite group name."
+			}
+		})
+	},
+	column: new AnnotationSpec({
+		description: "Overrides the physical column/document-field name in the database.\n\n**Example:**\n```atscript\n@db.column \"first_name\"\nfirstName: string\n```\n",
+		nodeType: ["prop"],
+		argument: {
+			name: "name",
+			type: "string",
+			description: "The actual column/field name in the DB."
+		}
+	}),
+	default: {
+		value: new AnnotationSpec({
+			description: "Sets a static DB-level default value (used in DDL DEFAULT clause). For string fields the value is used as-is; for other types it is parsed as JSON.\n\n**Example:**\n```atscript\n@db.default.value \"active\"\nstatus: string\n```\n",
+			nodeType: ["prop"],
+			argument: {
+				name: "value",
+				type: "string",
+				description: "Static default value. Strings used as-is; other types parsed via JSON.parse()."
+			}
+		}),
+		fn: new AnnotationSpec({
+			description: "Sets a DB-level generated default. The function name is portable — each adapter maps it to the appropriate DB mechanism.\n\n**Example:**\n```atscript\n@db.default.fn \"increment\"\nid: number\n```\n",
+			nodeType: ["prop"],
+			argument: {
+				name: "fn",
+				type: "string",
+				values: [
+					"increment",
+					"uuid",
+					"now"
+				],
+				description: "Generation function name: \"increment\", \"uuid\", or \"now\"."
+			},
+			validate(token, args, doc) {
+				const errors = [];
+				if (!args[0]) return errors;
+				const fnName = args[0].text;
+				const validFns = [
+					"increment",
+					"uuid",
+					"now"
+				];
+				if (!validFns.includes(fnName)) {
+					errors.push({
+						message: `Unknown @db.default.fn "${fnName}" — expected "increment", "uuid", or "now"`,
+						severity: 1,
+						range: args[0].range
+					});
+					return errors;
+				}
+				const field = token.parentNode;
+				const definition$1 = field.getDefinition();
+				if (!definition$1 || !isRef(definition$1)) return errors;
+				const unwound = doc.unwindType(definition$1.id, definition$1.chain);
+				if (!unwound || !isPrimitive(unwound.def)) return errors;
+				const baseType = unwound.def.config.type;
+				if (fnName === "increment" && baseType !== "number") errors.push({
+					message: `@db.default.fn "increment" is not compatible with type "${baseType}" — requires number`,
+					severity: 1,
+					range: token.range
+				});
+else if (fnName === "uuid" && baseType !== "string") errors.push({
+					message: `@db.default.fn "uuid" is not compatible with type "${baseType}" — requires string`,
+					severity: 1,
+					range: token.range
+				});
+else if (fnName === "now" && !["number", "string"].includes(baseType)) errors.push({
+					message: `@db.default.fn "now" is not compatible with type "${baseType}" — requires number or string`,
+					severity: 1,
+					range: token.range
+				});
+				return errors;
+			}
+		})
+	},
+	ignore: new AnnotationSpec({
+		description: "Excludes a field from the database schema. The field exists in the Atscript type but has no column in the DB.\n\n**Example:**\n```atscript\n@db.ignore\ndisplayName: string\n```\n",
+		nodeType: ["prop"],
+		validate(token, args, doc) {
+			const errors = [];
+			const field = token.parentNode;
+			if (field.countAnnotations("meta.id") > 0) errors.push({
+				message: `@db.ignore cannot coexist with @meta.id — a field cannot be both a primary key and excluded from the database`,
+				severity: 1,
+				range: token.range
+			});
+			return errors;
+		}
+	})
+};
+
 //#endregion
 //#region packages/core/src/defaults/emit-annotations.ts
 const emitAnnotations = { jsonSchema: new AnnotationSpec({
@@ -3200,7 +3339,35 @@ const expectAnnotations = {
 			}
 			return [];
 		}
-	})
+	}),
+	array: { key: new AnnotationSpec({
+		description: "Marks a **key field** inside an array. This annotation is used to identify unique fields within an array that can be used as **lookup keys**.\n\n\n\n**Example:**\n```atscript\nexport interface User {\n  id: string\n  profiles: {\n    @expect.array.key\n    profileId: string\n    name: string\n  }[]\n}\n```\n",
+		nodeType: ["prop", "type"],
+		multiple: false,
+		validate(token, args, doc) {
+			const field = token.parentNode;
+			const errors = [];
+			const isOptional = !!field.token("optional");
+			if (isOptional) errors.push({
+				message: `@expect.array.key can't be optional`,
+				severity: 1,
+				range: field.token("identifier").range
+			});
+			const definition$1 = field.getDefinition();
+			if (!definition$1) return errors;
+			let wrongType = false;
+			if (isRef(definition$1)) {
+				const def = doc.unwindType(definition$1.id, definition$1.chain)?.def;
+				if (isPrimitive(def) && !["string", "number"].includes(def.config.type)) wrongType = true;
+			} else wrongType = true;
+			if (wrongType) errors.push({
+				message: `@expect.array.key must be of type string or number`,
+				severity: 1,
+				range: token.range
+			});
+			return errors;
+		}
+	}) }
 };
 
 //#endregion
@@ -3215,13 +3382,8 @@ const metaAnnotations = {
 		}
 	}),
 	id: new AnnotationSpec({
-		description: "Marks a field as a unique identifier across multiple domains (DB, API, UI, logs).\n\n**Example:**```atscript@meta.id \"userId\"id: string```",
-		argument: {
-			optional: true,
-			name: "name",
-			type: "string",
-			description: "Custom identifier name (defaults to property name if omitted)."
-		}
+		description: "Marks a field as a unique identifier across multiple domains (DB, API, UI, logs). Multiple fields can be annotated with `@meta.id` to form a composite primary key.\n\n**Example:**```atscript@meta.idid: string```",
+		nodeType: ["prop"]
 	}),
 	description: new AnnotationSpec({
 		description: "Provides a **detailed description** of a field or entity, often used in documentation.\n\n**Example:**```atscript@meta.description \"Stores the user email address\"email: string```",
@@ -3240,15 +3402,6 @@ const metaAnnotations = {
 			description: "A line of documentation text. Multiple annotations can be used to form a full Markdown document."
 		}
 	}),
-	placeholder: new AnnotationSpec({
-		description: "Defines a **default placeholder value** for UI input fields.\n\n**Example:**```atscript@meta.placeholder \"Enter your name\"name: string```",
-		nodeType: ["prop", "type"],
-		argument: {
-			name: "text",
-			type: "string",
-			description: "The placeholder text to display in UI forms."
-		}
-	}),
 	sensitive: new AnnotationSpec({
 		description: "Marks a field as **sensitive** (e.g., passwords, API keys), ensuring it is hidden in logs and UI.\n\n**Example:**```atscript@meta.sensitivepassword: string```",
 		nodeType: ["prop", "type"],
@@ -3286,34 +3439,6 @@ const metaAnnotations = {
 			type: "string",
 			description: "The example value. Strings are used as-is; other types are parsed as JSON."
 		}
-	}),
-	isKey: new AnnotationSpec({
-		description: "Marks a **key field** inside an array. This annotation is used to identify unique fields within an array that can be used as **lookup keys**.\n\n\n\n**Example:**\n```atscript\nexport interface User {\n  id: string\n  profiles: {\n    @meta.isKey\n    profileId: string\n    name: string\n  }[]\n}\n```\n",
-		nodeType: ["prop", "type"],
-		multiple: false,
-		validate(token, args, doc) {
-			const field = token.parentNode;
-			const errors = [];
-			const isOptional = !!field.token("optional");
-			if (isOptional) errors.push({
-				message: `@meta.isKey can't be optional`,
-				severity: 1,
-				range: field.token("identifier").range
-			});
-			const definition$1 = field.getDefinition();
-			if (!definition$1) return errors;
-			let wrongType = false;
-			if (isRef(definition$1)) {
-				const def = doc.unwindType(definition$1.id, definition$1.chain)?.def;
-				if (isPrimitive(def) && !["string", "number"].includes(def.config.type)) wrongType = true;
-			} else wrongType = true;
-			if (wrongType) errors.push({
-				message: `@meta.isKey must be of type string or number`,
-				severity: 1,
-				range: token.range
-			});
-			return errors;
-		}
 	})
 };
 
@@ -3321,11 +3446,11 @@ const metaAnnotations = {
 //#region packages/core/src/defaults/primitives.ts
 const positive = {
 	documentation: "Number that greater than or equal to zero.",
-	expect: { min: 0 }
+	annotations: { "expect.min": 0 }
 };
 const negative = {
 	documentation: "Number that less than or equal to zero.",
-	expect: { max: 0 }
+	annotations: { "expect.max": 0 }
 };
 const positiveOrNegative = {
 	positive,
@@ -3339,47 +3464,60 @@ const primitives = {
 		extensions: {
 			email: {
 				documentation: "Represents an email address.",
-				expect: {
-					pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+				annotations: { "expect.pattern": {
+					pattern: "^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$",
 					message: "Invalid email format."
-				}
+				} }
 			},
 			phone: {
 				documentation: "Represents an phone number.",
-				expect: {
-					pattern: /^\+?[0-9\s-]{10,15}$/,
+				annotations: { "expect.pattern": {
+					pattern: "^\\+?[0-9\\s-]{10,15}$",
 					message: "Invalid phone number format."
-				}
+				} }
 			},
 			date: {
 				documentation: "Represents a date string.",
-				expect: {
-					pattern: [
-						/^\d{4}-\d{2}-\d{2}$/,
-						/^\d{2}\/\d{2}\/\d{4}$/,
-						/^\d{2}-\d{2}-\d{4}$/,
-						/^\d{1,2} [A-Za-z]+ \d{4}$/
-					],
-					message: "Invalid date format."
-				}
+				annotations: { "expect.pattern": [
+					{
+						pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+						message: "Invalid date format."
+					},
+					{
+						pattern: "^\\d{2}/\\d{2}/\\d{4}$",
+						message: "Invalid date format."
+					},
+					{
+						pattern: "^\\d{2}-\\d{2}-\\d{4}$",
+						message: "Invalid date format."
+					},
+					{
+						pattern: "^\\d{1,2} [A-Za-z]+ \\d{4}$",
+						message: "Invalid date format."
+					}
+				] }
 			},
 			isoDate: {
 				documentation: "Represents a date string in ISO format.",
-				expect: {
-					pattern: [/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?([+-]\d{2}:\d{2})$/],
+				annotations: { "expect.pattern": [{
+					pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?Z$",
 					message: "Invalid ISO date format."
-				}
+				}, {
+					pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?([+-]\\d{2}:\\d{2})$",
+					message: "Invalid ISO date format."
+				}] }
 			},
 			uuid: {
 				documentation: "Represents a UUID.",
-				expect: {
-					pattern: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+				annotations: { "expect.pattern": {
+					pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
+					flags: "i",
 					message: "Invalid UUID format."
-				}
+				} }
 			},
 			required: {
 				documentation: "Non-empty string that contains at least one non-whitespace character.",
-				expect: { required: true }
+				annotations: { "meta.required": true }
 			}
 		}
 	},
@@ -3399,11 +3537,22 @@ const primitives = {
 			int: {
 				extensions: positiveOrNegative,
 				documentation: "Represents an integer number.",
-				expect: { int: true }
+				annotations: { "expect.int": true }
 			},
 			timestamp: {
 				documentation: "Represents a timestamp.",
-				expect: { int: true }
+				annotations: { "expect.int": true },
+				extensions: {
+					created: {
+						documentation: "Timestamp auto-set on creation. Auto-applies @db.default.fn \"now\".",
+						tags: ["created"],
+						annotations: { "db.default.fn": "now" }
+					},
+					updated: {
+						documentation: "Timestamp auto-updated on every write. DB adapters read the \"updated\" tag.",
+						tags: ["updated"]
+					}
+				}
 			}
 		}
 	},
@@ -3413,7 +3562,7 @@ const primitives = {
 		extensions: {
 			required: {
 				documentation: "Boolean that must be true. Useful for checkboxes like \"accept terms\".",
-				expect: { required: true }
+				annotations: { "meta.required": true }
 			},
 			true: { documentation: "Represents a true value." },
 			false: { documentation: "Represents a false value." }
@@ -3437,6 +3586,148 @@ const primitives = {
 	}
 };
 
+//#endregion
+//#region packages/core/src/defaults/ui-annotations.ts
+const uiAnnotations = {
+	placeholder: new AnnotationSpec({
+		description: "Defines **placeholder text** for UI input fields.\n\n**Example:**\n```atscript\n@ui.placeholder \"Enter your name\"\nname: string\n```\n",
+		nodeType: ["prop", "type"],
+		argument: {
+			name: "text",
+			type: "string",
+			description: "The placeholder text to display in UI input fields."
+		}
+	}),
+	component: new AnnotationSpec({
+		description: "Hints which **UI component** to use when rendering this field.\n\n**Example:**\n```atscript\n@ui.component \"select\"\ncountry: string\n```\n",
+		nodeType: ["prop", "type"],
+		argument: {
+			name: "name",
+			type: "string",
+			description: "The component name or type to use for rendering."
+		}
+	}),
+	hidden: new AnnotationSpec({
+		description: "Hides this field or entity from **UI forms and tables** entirely.\n\n**Example:**\n```atscript\n@ui.hidden\ninternalId: string\n```\n",
+		nodeType: [
+			"prop",
+			"type",
+			"interface"
+		]
+	}),
+	group: new AnnotationSpec({
+		description: "Groups fields into **form sections**. Fields sharing the same group name are rendered together.\n\n**Example:**\n```atscript\n@ui.group \"personal\"\nfirstName: string\n\n@ui.group \"personal\"\nlastName: string\n\n@ui.group \"contact\"\nemail: string.email\n```\n",
+		nodeType: ["prop"],
+		argument: {
+			name: "name",
+			type: "string",
+			description: "The section/group name to place this field in."
+		}
+	}),
+	order: new AnnotationSpec({
+		description: "Sets the **display order** of a field in auto-generated forms. Lower numbers appear first.\n\n**Example:**\n```atscript\n@ui.order 1\nname: string\n\n@ui.order 2\nemail: string.email\n```\n",
+		nodeType: ["prop"],
+		argument: {
+			name: "order",
+			type: "number",
+			description: "Display order number. Lower values appear first."
+		}
+	}),
+	width: new AnnotationSpec({
+		description: "Provides a **layout width hint** for the field in auto-generated forms.\n\n**Example:**\n```atscript\n@ui.width \"half\"\nfirstName: string\n```\n",
+		nodeType: ["prop", "type"],
+		argument: {
+			name: "width",
+			type: "string",
+			description: "Layout width hint (e.g., \"half\", \"full\", \"third\", \"quarter\")."
+		}
+	}),
+	icon: new AnnotationSpec({
+		description: "Provides an **icon hint** for the field or entity.\n\n**Example:**\n```atscript\n@ui.icon \"mail\"\nemail: string.email\n```\n",
+		nodeType: [
+			"prop",
+			"type",
+			"interface"
+		],
+		argument: {
+			name: "name",
+			type: "string",
+			description: "Icon name or identifier."
+		}
+	}),
+	hint: new AnnotationSpec({
+		description: "Provides **help text or tooltip** displayed near the field in UI forms.\n\n**Example:**\n```atscript\n@ui.hint \"Must be a valid business email\"\nemail: string.email\n```\n",
+		nodeType: ["prop", "type"],
+		argument: {
+			name: "text",
+			type: "string",
+			description: "Help text or tooltip content."
+		}
+	}),
+	disabled: new AnnotationSpec({
+		description: "Marks a field as **disabled** (rendered but non-interactive) in UI forms.\n\n**Example:**\n```atscript\n@ui.disabled\nreferralCode: string\n```\n",
+		nodeType: ["prop", "type"]
+	}),
+	type: new AnnotationSpec({
+		description: "Specifies the **input type** for the field in UI forms. Maps to HTML input types or framework-specific equivalents.\n\n**Example:**\n```atscript\n@ui.type \"textarea\"\nbio: string\n\n@ui.type \"password\"\nsecret: string\n```\n",
+		nodeType: ["prop", "type"],
+		argument: {
+			name: "type",
+			type: "string",
+			description: "Input type (e.g., \"text\", \"textarea\", \"password\", \"number\", \"date\", \"color\", \"range\")."
+		}
+	}),
+	attr: new AnnotationSpec({
+		description: "Passes an arbitrary **HTML/component attribute** to the rendered field. Multiple `@ui.attr` annotations can be used on the same field.\n\n**Example:**\n```atscript\n@ui.attr \"rows\", \"5\"\n@ui.attr \"autocomplete\", \"off\"\nbio: string\n```\n",
+		nodeType: [
+			"prop",
+			"type",
+			"interface"
+		],
+		multiple: true,
+		mergeStrategy: "append",
+		argument: [{
+			name: "key",
+			type: "string",
+			description: "Attribute name."
+		}, {
+			name: "value",
+			type: "string",
+			description: "Attribute value."
+		}]
+	}),
+	class: new AnnotationSpec({
+		description: "Adds **CSS class names** to the rendered field or entity. Multiple `@ui.class` annotations are appended.\n\n**Example:**\n```atscript\n@ui.class \"text-bold\"\n@ui.class \"mt-4\"\ntitle: string\n```\n",
+		nodeType: [
+			"prop",
+			"type",
+			"interface"
+		],
+		multiple: true,
+		mergeStrategy: "append",
+		argument: {
+			name: "names",
+			type: "string",
+			description: "One or more CSS class names (space-separated)."
+		}
+	}),
+	style: new AnnotationSpec({
+		description: "Adds **inline CSS styles** to the rendered field or entity. Multiple `@ui.style` annotations are appended.\n\n**Example:**\n```atscript\n@ui.style \"color: red\"\n@ui.style \"font-weight: bold\"\nwarning: string\n```\n",
+		nodeType: [
+			"prop",
+			"type",
+			"interface"
+		],
+		multiple: true,
+		mergeStrategy: "append",
+		argument: {
+			name: "css",
+			type: "string",
+			description: "CSS style declarations (semicolon-separated)."
+		}
+	})
+};
+
 //#endregion
 //#region packages/core/src/default-atscript-config.ts
 function getDefaultAtscriptConfig() {
@@ -3445,7 +3736,9 @@ function getDefaultAtscriptConfig() {
 		annotations: {
 			meta: { ...metaAnnotations },
 			expect: { ...expectAnnotations },
-			emit: { ...emitAnnotations }
+			emit: { ...emitAnnotations },
+			db: { ...dbAnnotations },
+			ui: { ...uiAnnotations }
 		}
 	};
 	return defaulTAtscriptConfig;
@@ -3473,7 +3766,7 @@ var PluginManager = class {
 			this._docConfig = {};
 			if (raw?.primitives) {
 				this._docConfig.primitives = this._docConfig.primitives || new Map();
-				for (const [key, value] of Object.entries(raw.primitives)) this._docConfig.primitives.set(key, new SemanticPrimitiveNode(key, value));
+				for (const [key, value] of Object.entries(raw.primitives)) this._docConfig.primitives.set(key, new SemanticPrimitiveNode(key, value, "", raw.annotations));
 			}
 			if (raw?.annotations) {
 				this._docConfig.annotations = this._docConfig.annotations || {};