@weave-kit/engine 0.4.0 → 0.6.0

package/dist/core/object/validate/field.js

@@ -1,6 +1,7 @@
 import { parseFormula } from '../../formula/index.js';
-import { DEFAULT_FIELD_TYPE_REGISTRY, FIELD_TYPE_NAME_PATTERN, fieldBase, } from '../../types/index.js';
-import { FIELD_TYPES, ROW_SCOPE_MARKERS } from '../../types/values.js';
+import { ATTR_KINDS, DEFAULT_FIELD_TYPE_REGISTRY, FIELD_TYPE_NAME_PATTERN, fieldBase, } from '../../types/index.js';
+import { FIELD_TYPES, IDENTITY_OBJECT_NAMES, ROW_SCOPE_MARKERS, SCOPE_SOURCES } from '../../types/values.js';
+import { isCurrencyCode, currencyMinorUnits } from '../../types/currency.js';
 import { validateLabels } from './labels.js';
 import { fail, isRecord, expectString, expectBoolean, expectNumber, expectPositiveInt, SNAKE_CASE, FIELD_TYPE_VALUES, ON_DELETE_ACTION_VALUES, SEQUENCE_PLACEHOLDER, SEQUENCE_TOKEN_VALUES, SEQUENCE_CYCLE_VALUES, } from './primitives.js';
 /** keys always allowed on any field */
@@ -9,18 +10,30 @@ const BASE_KEYS = ['name', 'type', 'labels', 'description', 'primary', 'system',
 const FIELD_TYPE_NAME_RE = /^[a-z][a-zA-Z0-9_]*$/;
 /** registered-type name shape (namespace segment required) */
 const REGISTERED_FIELD_TYPE_RE = new RegExp(FIELD_TYPE_NAME_PATTERN);
+/** the pre-rename name for `timestamptz`; accepted as a deprecated schema alias (user types win) */
+const DEPRECATED_DATETIME_ALIAS = 'datetime';
 /** extra keys allowed per field type */
 const EXTRA_KEYS = {
-    string: ['minLength', 'maxLength', 'regex', 'required', 'unique', 'default', 'formula', ROW_SCOPE_MARKERS.OWNERSHIP, ROW_SCOPE_MARKERS.TEAM],
-    text: ['maxLength', 'required', 'unique', 'default', 'formula'],
+    string: ['minLength', 'maxLength', 'regex', 'required', 'unique', 'default', 'formula', ROW_SCOPE_MARKERS.OWNERSHIP, ROW_SCOPE_MARKERS.DEPARTMENT, 'ownershipSource', 'departmentSource'], text: ['maxLength', 'required', 'unique', 'default', 'formula'],
+    char: ['length', 'required', 'unique', 'default', 'formula'],
+    smallint: ['min', 'max', 'required', 'unique', 'default', 'formula'],
     integer: ['min', 'max', 'required', 'unique', 'default', 'formula'],
-    number: ['min', 'max', 'precision', 'required', 'unique', 'default', 'formula'],
-    currency: ['min', 'max', 'required', 'unique', 'default', 'formula'],
+    bigint: ['min', 'max', 'required', 'unique', 'default', 'formula'],
+    number: ['min', 'max', 'precision', 'scale', 'required', 'unique', 'default', 'formula'],
+    real: ['min', 'max', 'required', 'unique', 'default', 'formula'],
+    double: ['min', 'max', 'required', 'unique', 'default', 'formula'],
+    currency: ['min', 'max', 'currency', 'precision', 'required', 'unique', 'default', 'formula'],
     boolean: ['required', 'unique', 'default', 'formula'],
-    datetime: ['required', 'unique', 'default'],
     date: ['required', 'unique', 'default'],
+    time: ['required', 'unique', 'default'],
+    timetz: ['required', 'unique', 'default'],
+    timestamp: ['required', 'unique', 'default'],
+    timestamptz: ['required', 'unique', 'default'],
+    interval: ['required'],
+    uuid: ['required', 'unique', 'default'],
     json: ['required', 'default'],
-    enum: ['options', 'multiple', 'required', 'unique', 'default'],
+    jsonb: ['required', 'default'],
+    enum: ['options', 'multiple', 'enumType', 'required', 'unique', 'default'],
     relation: ['target', 'required', 'unique', 'onDelete'],
     details: ['target'],
     multiRelation: ['target', 'required'],
@@ -30,8 +43,8 @@ const EXTRA_KEYS = {
     email: ['minLength', 'maxLength', 'regex', 'required', 'unique', 'default', 'formula'],
     phone: ['minLength', 'maxLength', 'regex', 'required', 'unique', 'default', 'formula'],
     image: ['required', 'unique', 'multiple', 'default'],
-    person: ['target', 'required', 'unique', 'onDelete', 'department'],
-    department: ['target', 'required', 'unique', 'onDelete'],
+    user: ['required', 'unique', 'onDelete'],
+    department: ['required', 'unique', 'onDelete'],
 };
 /** reject any attribute not allowed for the given field type (typo protection) */
 function checkAllowedKeys(record, type, vc) {
@@ -48,10 +61,12 @@ function validateDefault(value, type, vc, options) {
     switch (type) {
         case FIELD_TYPES.STRING:
         case FIELD_TYPES.TEXT:
+        case FIELD_TYPES.CHAR:
         case FIELD_TYPES.FIRST_NAME:
         case FIELD_TYPES.LAST_NAME:
         case FIELD_TYPES.EMAIL:
         case FIELD_TYPES.PHONE:
+        case FIELD_TYPES.UUID:
             if (typeof value !== 'string')
                 fail(vc, 'field.default.string');
             break;
@@ -59,11 +74,29 @@ function validateDefault(value, type, vc, options) {
             if (typeof value !== 'string' && !Array.isArray(value))
                 fail(vc, 'field.default.string');
             break;
+        case FIELD_TYPES.SMALLINT:
         case FIELD_TYPES.INTEGER:
             if (typeof value !== 'number' || !Number.isInteger(value))
                 fail(vc, 'field.default.integer');
             break;
+        case FIELD_TYPES.BIGINT:
+            // a string default is allowed for values beyond Number.MAX_SAFE_INTEGER,
+            // but must be a plain integer (it is emitted verbatim as a numeric literal)
+            if (typeof value === 'number') {
+                if (!Number.isInteger(value))
+                    fail(vc, 'field.default.integer');
+            }
+            else if (typeof value === 'string') {
+                if (!/^[+-]?\d+$/.test(value))
+                    fail(vc, 'field.default.integer');
+            }
+            else {
+                fail(vc, 'field.default.integer');
+            }
+            break;
         case FIELD_TYPES.NUMBER:
+        case FIELD_TYPES.REAL:
+        case FIELD_TYPES.DOUBLE:
         case FIELD_TYPES.CURRENCY:
             if (typeof value !== 'number')
                 fail(vc, 'field.default.number');
@@ -72,7 +105,10 @@ function validateDefault(value, type, vc, options) {
             if (typeof value !== 'boolean')
                 fail(vc, 'field.default.boolean');
             break;
-        case FIELD_TYPES.DATETIME:
+        case FIELD_TYPES.TIMESTAMPTZ:
+        case FIELD_TYPES.TIMESTAMP:
+        case FIELD_TYPES.TIME:
+        case FIELD_TYPES.TIMETZ:
             if (typeof value !== 'string')
                 fail(vc, 'field.default.iso');
             break;
@@ -81,6 +117,7 @@ function validateDefault(value, type, vc, options) {
                 fail(vc, 'field.default.string');
             break;
         case FIELD_TYPES.JSON:
+        case FIELD_TYPES.JSONB:
             break;
         case FIELD_TYPES.ENUM:
             if (typeof value !== 'string')
@@ -89,11 +126,12 @@ function validateDefault(value, type, vc, options) {
                 fail(vc, 'field.default.inOptions', { value });
             break;
         case FIELD_TYPES.RELATION:
-        case FIELD_TYPES.PERSON:
+        case FIELD_TYPES.USER:
         case FIELD_TYPES.DEPARTMENT:
         case FIELD_TYPES.DETAILS:
         case FIELD_TYPES.MULTI_RELATION:
         case FIELD_TYPES.SEQ_NO:
+        case FIELD_TYPES.INTERVAL:
             fail(vc, 'field.default.notSupported', { type });
     }
 }
@@ -122,9 +160,16 @@ export function validateField(raw, vc, options = {}) {
         fail(vc, 'field.name.required');
     if (!SNAKE_CASE.test(name))
         fail(vc, 'field.name.snake', { name });
-    const rawType = raw.type;
-    if (typeof rawType !== 'string' || !FIELD_TYPE_NAME_RE.test(rawType)) {
-        fail(vc, 'field.type.invalid', { type: String(rawType) });
+    const rawTypeInput = raw.type;
+    if (typeof rawTypeInput !== 'string' || !FIELD_TYPE_NAME_RE.test(rawTypeInput)) {
+        fail(vc, 'field.type.invalid', { type: String(rawTypeInput) });
+    }
+    let rawType = rawTypeInput;
+    // deprecated alias: the field type `datetime` was renamed to `timestamptz`.
+    // Resolved here (not in the registry) so the bare name stays available for a
+    // user-registered type, which takes precedence.
+    if (rawType === DEPRECATED_DATETIME_ALIAS && registry.get(DEPRECATED_DATETIME_ALIAS) === undefined) {
+        rawType = FIELD_TYPES.TIMESTAMPTZ;
     }
     const isBuiltin = FIELD_TYPE_VALUES.includes(rawType);
     const descriptor = isBuiltin ? undefined : registry.get(rawType);
@@ -158,7 +203,9 @@ export function validateField(raw, vc, options = {}) {
             const maxLength = expectPositiveInt(raw, 'maxLength', vc);
             const regex = expectString(raw, 'regex', vc);
             const ownership = expectBoolean(raw, ROW_SCOPE_MARKERS.OWNERSHIP, vc);
-            const team = expectBoolean(raw, ROW_SCOPE_MARKERS.TEAM, vc);
+            const department = expectBoolean(raw, ROW_SCOPE_MARKERS.DEPARTMENT, vc);
+            const ownershipSource = expectScopeSource(raw, 'ownershipSource', vc);
+            const departmentSource = expectScopeSource(raw, 'departmentSource', vc);
             if (regex !== undefined) {
                 try {
                     new RegExp(regex);
@@ -182,7 +229,9 @@ export function validateField(raw, vc, options = {}) {
                 unique,
                 default: raw.default,
                 ownership,
-                team,
+                department,
+                ownershipSource,
+                departmentSource,
             };
         }
         case FIELD_TYPES.TEXT: {
@@ -198,6 +247,19 @@ export function validateField(raw, vc, options = {}) {
                 default: raw.default,
             };
         }
+        case FIELD_TYPES.CHAR: {
+            const length = expectPositiveInt(raw, 'length', vc);
+            validateDefault(raw.default, type, vc);
+            return {
+                ...base,
+                type: FIELD_TYPES.CHAR,
+                formula,
+                length,
+                required,
+                unique,
+                default: raw.default,
+            };
+        }
         case FIELD_TYPES.INTEGER: {
             const min = expectNumber(raw, 'min', vc);
             const max = expectNumber(raw, 'max', vc);
@@ -219,10 +281,53 @@ export function validateField(raw, vc, options = {}) {
                 default: raw.default,
             };
         }
+        case FIELD_TYPES.SMALLINT: {
+            const min = expectNumber(raw, 'min', vc);
+            const max = expectNumber(raw, 'max', vc);
+            if (min !== undefined && !Number.isInteger(min))
+                fail(vc, 'field.min.integer');
+            if (max !== undefined && !Number.isInteger(max))
+                fail(vc, 'field.max.integer');
+            if (min !== undefined && max !== undefined && min > max)
+                fail(vc, 'field.minGtMax');
+            validateDefault(raw.default, type, vc);
+            return {
+                ...base,
+                type: FIELD_TYPES.SMALLINT,
+                formula,
+                min,
+                max,
+                required,
+                unique,
+                default: raw.default,
+            };
+        }
+        case FIELD_TYPES.BIGINT: {
+            const min = expectNumber(raw, 'min', vc);
+            const max = expectNumber(raw, 'max', vc);
+            if (min !== undefined && !Number.isInteger(min))
+                fail(vc, 'field.min.integer');
+            if (max !== undefined && !Number.isInteger(max))
+                fail(vc, 'field.max.integer');
+            if (min !== undefined && max !== undefined && min > max)
+                fail(vc, 'field.minGtMax');
+            validateDefault(raw.default, type, vc);
+            return {
+                ...base,
+                type: FIELD_TYPES.BIGINT,
+                formula,
+                min,
+                max,
+                required,
+                unique,
+                default: raw.default,
+            };
+        }
         case FIELD_TYPES.NUMBER: {
             const min = expectNumber(raw, 'min', vc);
             const max = expectNumber(raw, 'max', vc);
             const precision = expectPositiveInt(raw, 'precision', vc);
+            const scale = expectPositiveInt(raw, 'scale', vc);
             if (min !== undefined && max !== undefined && min > max)
                 fail(vc, 'field.minGtMax');
             validateDefault(raw.default, type, vc);
@@ -233,6 +338,41 @@ export function validateField(raw, vc, options = {}) {
                 min,
                 max,
                 precision,
+                scale,
+                required,
+                unique,
+                default: raw.default,
+            };
+        }
+        case FIELD_TYPES.REAL: {
+            const min = expectNumber(raw, 'min', vc);
+            const max = expectNumber(raw, 'max', vc);
+            if (min !== undefined && max !== undefined && min > max)
+                fail(vc, 'field.minGtMax');
+            validateDefault(raw.default, type, vc);
+            return {
+                ...base,
+                type: FIELD_TYPES.REAL,
+                formula,
+                min,
+                max,
+                required,
+                unique,
+                default: raw.default,
+            };
+        }
+        case FIELD_TYPES.DOUBLE: {
+            const min = expectNumber(raw, 'min', vc);
+            const max = expectNumber(raw, 'max', vc);
+            if (min !== undefined && max !== undefined && min > max)
+                fail(vc, 'field.minGtMax');
+            validateDefault(raw.default, type, vc);
+            return {
+                ...base,
+                type: FIELD_TYPES.DOUBLE,
+                formula,
+                min,
+                max,
                 required,
                 unique,
                 default: raw.default,
@@ -243,6 +383,14 @@ export function validateField(raw, vc, options = {}) {
             const max = expectNumber(raw, 'max', vc);
             if (min !== undefined && max !== undefined && min > max)
                 fail(vc, 'field.minGtMax');
+            const currency = expectString(raw, 'currency', vc);
+            if (currency !== undefined && !isCurrencyCode(currency))
+                fail(vc, 'field.currency.invalid', { currency });
+            const precision = expectPositiveInt(raw, 'precision', vc);
+            const scale = currency === undefined ? 2 : currencyMinorUnits(currency);
+            if (precision !== undefined && precision <= scale) {
+                fail(vc, 'field.currency.precision', { precision, scale });
+            }
             validateDefault(raw.default, type, vc);
             return {
                 ...base,
@@ -253,6 +401,8 @@ export function validateField(raw, vc, options = {}) {
                 required,
                 unique,
                 default: raw.default,
+                currency,
+                precision,
             };
         }
         case FIELD_TYPES.BOOLEAN:
@@ -265,20 +415,59 @@ export function validateField(raw, vc, options = {}) {
                 unique,
                 default: raw.default,
             };
-        case FIELD_TYPES.DATETIME:
+        case FIELD_TYPES.DATE:
             validateDefault(raw.default, type, vc);
             return {
                 ...base,
-                type: FIELD_TYPES.DATETIME,
+                type: FIELD_TYPES.DATE,
                 required,
                 unique,
                 default: raw.default,
             };
-        case FIELD_TYPES.DATE:
+        case FIELD_TYPES.TIME:
             validateDefault(raw.default, type, vc);
             return {
                 ...base,
-                type: FIELD_TYPES.DATE,
+                type: FIELD_TYPES.TIME,
+                required,
+                unique,
+                default: raw.default,
+            };
+        case FIELD_TYPES.TIMETZ:
+            validateDefault(raw.default, type, vc);
+            return {
+                ...base,
+                type: FIELD_TYPES.TIMETZ,
+                required,
+                unique,
+                default: raw.default,
+            };
+        case FIELD_TYPES.TIMESTAMP:
+            validateDefault(raw.default, type, vc);
+            return {
+                ...base,
+                type: FIELD_TYPES.TIMESTAMP,
+                required,
+                unique,
+                default: raw.default,
+            };
+        case FIELD_TYPES.TIMESTAMPTZ:
+            validateDefault(raw.default, type, vc);
+            return {
+                ...base,
+                type: FIELD_TYPES.TIMESTAMPTZ,
+                required,
+                unique,
+                default: raw.default,
+            };
+        case FIELD_TYPES.INTERVAL:
+            validateDefault(raw.default, type, vc);
+            return { ...base, type: FIELD_TYPES.INTERVAL, required, unique };
+        case FIELD_TYPES.UUID:
+            validateDefault(raw.default, type, vc);
+            return {
+                ...base,
+                type: FIELD_TYPES.UUID,
                 required,
                 unique,
                 default: raw.default,
@@ -286,45 +475,81 @@ export function validateField(raw, vc, options = {}) {
         case FIELD_TYPES.JSON:
             validateDefault(raw.default, type, vc);
             return { ...base, type: FIELD_TYPES.JSON, required, default: raw.default };
+        case FIELD_TYPES.JSONB:
+            validateDefault(raw.default, type, vc);
+            return { ...base, type: FIELD_TYPES.JSONB, required, default: raw.default };
         case FIELD_TYPES.ENUM: {
-            const options = raw.options;
-            if (!Array.isArray(options) || options.length === 0)
-                fail(vc, 'field.enum.options.required');
-            if (!options.every((o) => typeof o === 'string'))
-                fail(vc, 'field.enum.options.strings');
-            const seen = new Set();
-            for (const o of options) {
-                if (seen.has(o))
-                    fail(vc, 'field.enum.options.duplicate', { value: o });
-                seen.add(o);
-            }
+            const rawOptions = raw.options;
             const multiple = expectBoolean(raw, 'multiple', vc);
+            const enumType = expectString(raw, 'enumType', vc);
+            // a native enum type name is interpolated into DDL — restrict it to the
+            // same identifier shape as object/field names (no quotes/spaces/semicolons)
+            if (enumType !== undefined && !SNAKE_CASE.test(enumType)) {
+                fail(vc, 'field.enum.enumType.invalid', { value: enumType });
+            }
             if (multiple === true && primary === true)
                 fail(vc, 'field.enum.multiple.primary');
             if (multiple === true && unique === true)
                 fail(vc, 'field.enum.multiple.unique');
-            if (multiple === true) {
-                if (raw.default !== undefined) {
-                    if (!Array.isArray(raw.default) || !raw.default.every((v) => typeof v === 'string')) {
-                        fail(vc, 'field.enum.multiple.default.array');
-                    }
-                    for (const v of raw.default) {
-                        if (!options.includes(v))
-                            fail(vc, 'field.enum.multiple.default.inOptions', { value: v });
+            // inline options: a non-empty, unique list of strings
+            if (Array.isArray(rawOptions)) {
+                if (rawOptions.length === 0)
+                    fail(vc, 'field.enum.options.required');
+                if (!rawOptions.every((o) => typeof o === 'string'))
+                    fail(vc, 'field.enum.options.strings');
+                const seen = new Set();
+                for (const o of rawOptions) {
+                    if (seen.has(o))
+                        fail(vc, 'field.enum.options.duplicate', { value: o });
+                    seen.add(o);
+                }
+                const options = rawOptions;
+                if (multiple === true) {
+                    if (raw.default !== undefined) {
+                        if (!Array.isArray(raw.default) || !raw.default.every((v) => typeof v === 'string')) {
+                            fail(vc, 'field.enum.multiple.default.array');
+                        }
+                        for (const v of raw.default) {
+                            if (!options.includes(v))
+                                fail(vc, 'field.enum.multiple.default.inOptions', { value: v });
+                        }
                     }
                 }
+                else {
+                    validateDefault(raw.default, type, vc, options);
+                }
+                return {
+                    ...base,
+                    type: FIELD_TYPES.ENUM,
+                    options,
+                    multiple,
+                    enumType,
+                    required,
+                    unique,
+                    default: multiple === true ? raw.default : raw.default,
+                };
             }
-            else {
-                validateDefault(raw.default, type, vc, options);
+            // data-driven options: { from: { object, column? } }
+            const fromRaw = isRecord(rawOptions) ? rawOptions.from : undefined;
+            if (!isRecord(fromRaw) || typeof fromRaw.object !== 'string' || !SNAKE_CASE.test(fromRaw.object)) {
+                fail(vc, 'field.enum.options.shape');
+            }
+            const fromObject = fromRaw.object;
+            const fromColumn = fromRaw.column;
+            if (fromColumn !== undefined && (typeof fromColumn !== 'string' || !SNAKE_CASE.test(fromColumn))) {
+                fail(vc, 'field.enum.options.shape');
             }
+            if (raw.default !== undefined)
+                fail(vc, 'field.default.optionsFrom');
             return {
                 ...base,
                 type: FIELD_TYPES.ENUM,
-                options: options,
+                options: {
+                    from: { object: fromObject, ...(fromColumn === undefined ? {} : { column: fromColumn }) },
+                },
                 multiple,
                 required,
                 unique,
-                default: multiple === true ? raw.default : raw.default,
             };
         }
         case FIELD_TYPES.RELATION: {
@@ -402,30 +627,21 @@ export function validateField(raw, vc, options = {}) {
                 default: multiple === true ? raw.default : raw.default,
             };
         }
-        case FIELD_TYPES.PERSON: {
-            const target = expectString(raw, 'target', vc);
-            if (target === undefined)
-                fail(vc, 'field.relation.target.required');
-            if (!SNAKE_CASE.test(target))
-                fail(vc, 'field.relation.target.snake', { target });
+        case FIELD_TYPES.USER: {
             const onDelete = expectString(raw, 'onDelete', vc);
             if (onDelete !== undefined && !ON_DELETE_ACTION_VALUES.includes(onDelete)) {
                 fail(vc, 'field.relation.onDelete.invalid', { actions: ON_DELETE_ACTION_VALUES.join('/') });
             }
-            const department = expectString(raw, 'department', vc);
-            return { ...base, type: FIELD_TYPES.PERSON, target, required, unique, onDelete, department };
+            // implicit target: the engine identity object (never declared in schema.json)
+            return { ...base, type: FIELD_TYPES.USER, target: IDENTITY_OBJECT_NAMES.USER, required, unique, onDelete };
         }
         case FIELD_TYPES.DEPARTMENT: {
-            const target = expectString(raw, 'target', vc);
-            if (target === undefined)
-                fail(vc, 'field.relation.target.required');
-            if (!SNAKE_CASE.test(target))
-                fail(vc, 'field.relation.target.snake', { target });
             const onDelete = expectString(raw, 'onDelete', vc);
             if (onDelete !== undefined && !ON_DELETE_ACTION_VALUES.includes(onDelete)) {
                 fail(vc, 'field.relation.onDelete.invalid', { actions: ON_DELETE_ACTION_VALUES.join('/') });
             }
-            return { ...base, type: FIELD_TYPES.DEPARTMENT, target, required, unique, onDelete };
+            // implicit target: the engine identity object (never declared in schema.json)
+            return { ...base, type: FIELD_TYPES.DEPARTMENT, target: IDENTITY_OBJECT_NAMES.DEPARTMENT, required, unique, onDelete };
         }
         case FIELD_TYPES.SEQ_NO: {
             const format = expectString(raw, 'format', vc);
@@ -448,10 +664,54 @@ export function validateField(raw, vc, options = {}) {
         }
     }
 }
+/** read an optional scope-source attr (`ownershipSource`/`departmentSource`) */
+function expectScopeSource(raw, key, vc) {
+    const value = expectString(raw, key, vc);
+    if (value === undefined)
+        return undefined;
+    if (value !== SCOPE_SOURCES.INTERNAL && value !== SCOPE_SOURCES.EXTERNAL) {
+        fail(vc, 'field.scopeSource.invalid', { attr: key });
+    }
+    return value;
+}
+/** engine-semantic attrs a registered type does NOT inherit from its base (computed/RBAC) */
+const SEMANTIC_ATTRS = new Set(['formula', ROW_SCOPE_MARKERS.OWNERSHIP, ROW_SCOPE_MARKERS.DEPARTMENT]);
+/** type-check one declared extra-attribute value against its AttrSpec */
+function checkAttrValue(value, attr, spec, vc) {
+    switch (spec.type) {
+        case ATTR_KINDS.STRING:
+            if (typeof value !== 'string')
+                fail(vc, 'field.attr.type', { attr, type: 'string' });
+            return;
+        case ATTR_KINDS.NUMBER:
+            if (typeof value !== 'number' || Number.isNaN(value))
+                fail(vc, 'field.attr.type', { attr, type: 'number' });
+            return;
+        case ATTR_KINDS.INTEGER:
+            if (typeof value !== 'number' || !Number.isInteger(value))
+                fail(vc, 'field.attr.type', { attr, type: 'integer' });
+            return;
+        case ATTR_KINDS.BOOLEAN:
+            if (typeof value !== 'boolean')
+                fail(vc, 'field.attr.type', { attr, type: 'boolean' });
+            return;
+        case ATTR_KINDS.JSON:
+            return;
+        case ATTR_KINDS.ENUM: {
+            const values = spec.values ?? [];
+            if (typeof value !== 'string' || !values.includes(value)) {
+                fail(vc, 'field.attr.enum', { attr, values: values.join('/') });
+            }
+            return;
+        }
+    }
+}
 /**
  * Validate a field whose type is a user/plugin registered type. Attributes are
- * checked against the registration's allow-list (plus the base's conveniences);
- * storage/TS/MCP/OpenAPI behaviour is inherited from `base` at consumption time.
+ * checked against the base primitive's attributes (minus engine-semantic ones)
+ * plus the registration's declared `attrs`; declared attr values are type-checked
+ * and preserved. Storage/TS/MCP/OpenAPI/write-validation behaviour is inherited
+ * from `base` at consumption time.
  */
 function validateRegisteredField(raw, name, type, descriptor, vc) {
     const base = descriptor.base;
@@ -459,13 +719,13 @@ function validateRegisteredField(raw, name, type, descriptor, vc) {
         fail(vc, 'field.type.invalid', { type });
     const resolvedBase = fieldBase(DEFAULT_FIELD_TYPE_REGISTRY, base);
     const relationLike = descriptor.relationLike === true || resolvedBase === FIELD_TYPES.RELATION;
-    const allowed = new Set([...BASE_KEYS, ...(descriptor.attrs ?? []), 'required', 'unique', 'default']);
+    const specs = descriptor.attrs ?? {};
+    const inherited = (EXTRA_KEYS[resolvedBase] ?? []).filter((k) => !SEMANTIC_ATTRS.has(k));
+    const allowed = new Set([...BASE_KEYS, ...inherited, ...Object.keys(specs)]);
     if (relationLike) {
         allowed.add('target');
         allowed.add('onDelete');
     }
-    if (resolvedBase === FIELD_TYPES.STRING || resolvedBase === FIELD_TYPES.TEXT)
-        allowed.add('multiple');
     for (const key of Object.keys(raw)) {
         if (!allowed.has(key))
             fail(vc, 'field.attr.notAllowed', { type, attr: key });
@@ -477,10 +737,12 @@ function validateRegisteredField(raw, name, type, descriptor, vc) {
     const sensitive = expectBoolean(raw, 'sensitive', vc);
     const required = expectBoolean(raw, 'required', vc);
     const unique = expectBoolean(raw, 'unique', vc);
-    const multiple = expectBoolean(raw, 'multiple', vc);
     const out = { name, type, labels, description, primary, system, sensitive, required, unique };
-    if (multiple !== undefined)
-        out.multiple = multiple;
+    // carry the base's own value constraints (min/max/minLength/maxLength/regex/precision)
+    for (const key of inherited) {
+        if (raw[key] !== undefined && out[key] === undefined)
+            out[key] = raw[key];
+    }
     if (relationLike) {
         const target = expectString(raw, 'target', vc);
         if (target === undefined)
@@ -497,6 +759,17 @@ function validateRegisteredField(raw, name, type, descriptor, vc) {
     }
     if (raw.default !== undefined)
         out.default = raw.default;
+    // declared extra attributes: required check + value validation + preserve
+    for (const [attr, spec] of Object.entries(specs)) {
+        const value = raw[attr];
+        if (value === undefined) {
+            if (spec.required === true)
+                fail(vc, 'field.attr.required', { type, attr });
+            continue;
+        }
+        checkAttrValue(value, attr, spec, vc);
+        out[attr] = value;
+    }
     return out;
 }
 //# sourceMappingURL=field.js.map