fix(python): close attr-schema coverage gap — typed value_type for cross-port attrs

Python's field schema previously only registered @column, @storage, and
@objectref with a typed value_type, so the YAML desugar's D2 type-coercion
guard (ADR-0006) never fired for the other common field attrs. TS / C# /
Java already enforce these via their typed schemas — Python was the
outlier, silently accepting `maxLength: TRUE` etc.

Adds typed AttrSchema for every common field attr Python was missing:

  @required               boolean
  @unique                 boolean
  @default                None (polymorphic — value-type follows owning
                          field's subtype; guard skips when value_type is None)
  @maxlength              int
  @precision              int
  @scale                  int
  @filterable             boolean
  @Sortable               boolean
  @sortableDefaultOrder   string (allowed: asc, desc)
  @autoset                string (allowed: onCreate, onUpdate)

Mirrors server/typescript/.../core/field/field-schema.ts `commonFieldAttrs`
and server/csharp/.../Core/Field/FieldSchema.cs `CommonFieldAttrs`. The new
constants live in field_constants.py alongside their TS/C# peers (cross-
port parity). _FIELD_COMMON_ATTRS is now shared between field.* and
field.enum (was a separate hand-typed copy).

Also: AttrSchema.value_type is now Optional[str] to permit declaring a
"known but untyped" attr (e.g. @default), matching TS's `valueType?: string`
shape. The coercion guard already short-circuits when value_type is None.

Re-adds fixture error-yaml-coerced-bool-in-int that the YAML corpus
expansion (b2dc546) had to drop because Python's gap meant only 3/4 ports
fired. Now all four ports (TS, C#, Java, Python) emit
ERR_YAML_COERCION + ERR_BAD_ATTR_VALUE for `maxLength: TRUE`.

Verification:
  Python 506 passed (was 505 baseline + 1 new fixture)
  TS yaml-conformance     13/13
  C# YamlConformance      13/13
  Java YamlConformanceTest 13/13
  TS metadata full        1226/1226

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: dmealing

fixtures/yaml-conformance/error-yaml-coerced-bool-in-int/expected-errors.json

@@ -0,0 +1,25 @@
+{
+  "errors": [
+    {
+      "code": "ERR_YAML_COERCION",
+      "source": {
+        "format": "yaml",
+        "files": [
+          "input.yaml"
+        ],
+        "jsonPath": "$"
+      }
+    },
+    {
+      "code": "ERR_BAD_ATTR_VALUE",
+      "source": {
+        "format": "json",
+        "files": [
+          "input.yaml"
+        ],
+        "jsonPath": "$['metadata.root'].children[0]['object.entity'].children[0]['field.string']"
+      }
+    }
+  ],
+  "warnings": []
+}

fixtures/yaml-conformance/error-yaml-coerced-bool-in-int/input.yaml

@@ -0,0 +1,8 @@
+metadata:
+  children:
+    - object.entity:
+        name: Product
+        children:
+          - field.string:
+              name: sku
+              maxLength: TRUE

server/python/src/metaobjects/core_types.py

@@ -14,10 +14,23 @@
 )
 from .meta.core.field import field_constants as fc
 from .meta.core.field.field_constants import (
+    AUTO_SET_VALUES,
+    FIELD_ATTR_AUTO_SET,
+    FIELD_ATTR_COLUMN,
+    FIELD_ATTR_DEFAULT,
+    FIELD_ATTR_FILTERABLE,
+    FIELD_ATTR_MAX_LENGTH,
     FIELD_ATTR_OBJECT_REF,
+    FIELD_ATTR_PRECISION,
+    FIELD_ATTR_REQUIRED,
+    FIELD_ATTR_SCALE,
+    FIELD_ATTR_SORTABLE,
+    FIELD_ATTR_SORTABLE_DEFAULT_ORDER,
     FIELD_ATTR_STORAGE,
+    FIELD_ATTR_UNIQUE,
     FIELD_ATTR_VALUES,
     FIELD_SUBTYPE_ENUM,
+    SORT_ORDER_VALUES,
     STORAGE_VALUES,
 )
 from .meta.core.field.meta_field import MetaField
@@ -175,14 +188,20 @@ def _register_subtypes(
     ChildRule(TYPE_VIEW, "*"),
     ChildRule(TYPE_VALIDATOR, "*"),
 ]
-# Common field attrs declared by the core port. `@column` carries a declared
-# string valueType so the YAML desugar's D2 type-coercion guard (ADR-0006) can
-# detect a YAML 1.2 silently-coerced unquoted boolean/number value
-# (e.g. `column: TRUE` → boolean True instead of the string "TRUE"). The TS
-# port registers this through a dedicated dbProvider that extends field types;
-# Python keeps it on the core field defs until a full Python db-codegen port lands.
+# Common field attrs declared by the core port. Each attr carries a declared
+# `value_type` so the YAML desugar's D2 type-coercion guard (ADR-0006) can
+# detect a YAML 1.2 silently-coerced unquoted value (e.g. `maxLength: true`
+# coerced to boolean instead of the int it should be).
+#
+# Mirrors server/typescript/packages/metadata/src/core/field/field-schema.ts
+# `commonFieldAttrs` and server/csharp/MetaObjects/Core/Field/FieldSchema.cs
+# `CommonFieldAttrs` so Python's coercion coverage stays at parity.
+#
+# The TS port registers `@column` through a dedicated dbProvider that extends
+# field types; Python keeps it on the core field defs until a full Python
+# db-codegen port lands.
 _FIELD_COMMON_ATTRS = [
-    AttrSchema(name="column", value_type=ATTR_SUBTYPE_STRING, required=False),
+    AttrSchema(name=FIELD_ATTR_OBJECT_REF, value_type=ATTR_SUBTYPE_STRING, required=False),
     # @storage applies to field.object only (cross-port); validation_passes enforces
     # the shape rules + non-object-subtype guard. Declared at the common level so
     # the AttrSchema parser doesn't reject it on field.object before validation runs.
@@ -192,10 +211,31 @@ def _register_subtypes(
         required=False,
         allowed_values=STORAGE_VALUES,
     ),
-    # @objectRef is the cross-entity reference for field.object — declared on the
-    # common attrs so an inline @objectRef on any field subtype routes correctly
-    # (validation lives in validation_passes.py).
-    AttrSchema(name=FIELD_ATTR_OBJECT_REF, value_type=ATTR_SUBTYPE_STRING, required=False),
+    AttrSchema(name=FIELD_ATTR_REQUIRED, value_type=ATTR_SUBTYPE_BOOLEAN, required=False),
+    AttrSchema(name=FIELD_ATTR_UNIQUE, value_type=ATTR_SUBTYPE_BOOLEAN, required=False),
+    # @default is polymorphic: its value type follows the OWNING field's
+    # subtype. No single fixed valueType can capture that, so value_type is
+    # intentionally None (declared-but-untyped). The YAML coercion guard
+    # skips entries with value_type=None.
+    AttrSchema(name=FIELD_ATTR_DEFAULT, value_type=None, required=False),
+    AttrSchema(name=FIELD_ATTR_MAX_LENGTH, value_type=ATTR_SUBTYPE_INT, required=False),
+    AttrSchema(name=FIELD_ATTR_PRECISION, value_type=ATTR_SUBTYPE_INT, required=False),
+    AttrSchema(name=FIELD_ATTR_SCALE, value_type=ATTR_SUBTYPE_INT, required=False),
+    AttrSchema(name=FIELD_ATTR_FILTERABLE, value_type=ATTR_SUBTYPE_BOOLEAN, required=False),
+    AttrSchema(name=FIELD_ATTR_SORTABLE, value_type=ATTR_SUBTYPE_BOOLEAN, required=False),
+    AttrSchema(
+        name=FIELD_ATTR_SORTABLE_DEFAULT_ORDER,
+        value_type=ATTR_SUBTYPE_STRING,
+        required=False,
+        allowed_values=SORT_ORDER_VALUES,
+    ),
+    AttrSchema(
+        name=FIELD_ATTR_AUTO_SET,
+        value_type=ATTR_SUBTYPE_STRING,
+        required=False,
+        allowed_values=AUTO_SET_VALUES,
+    ),
+    AttrSchema(name=FIELD_ATTR_COLUMN, value_type=ATTR_SUBTYPE_STRING, required=False),
 ]
 _register_subtypes(
     core_provider,
@@ -206,21 +246,21 @@ def _register_subtypes(
     attrs=_FIELD_COMMON_ATTRS,
 )
 
-# field.enum — dedicated registration with required @values attr
+# field.enum — dedicated registration with required @values attr.
+# Inherits every common field attr (column / required / unique / default /
+# maxLength / filterable / sortable / etc.) so the D2 type-coercion guard
+# applies uniformly across all fields.
 core_provider.add(
     TypeDefinition(
         type=TYPE_FIELD,
         sub_type=FIELD_SUBTYPE_ENUM,
         factory=MetaField,
-        attrs=[
+        attrs=list(_FIELD_COMMON_ATTRS) + [
             AttrSchema(
                 name=FIELD_ATTR_VALUES,
                 value_type=ATTR_SUBTYPE_STRINGARRAY,
                 required=True,
             ),
-            # See _FIELD_COMMON_ATTRS above — `@column` is declared on enum too
-            # so the D2 type-coercion guard applies uniformly across all fields.
-            AttrSchema(name="column", value_type=ATTR_SUBTYPE_STRING, required=False),
         ],
         child_rules=_FIELD_CHILD_RULES,
     )

server/python/src/metaobjects/meta/core/field/field_constants.py

@@ -34,17 +34,35 @@
 )
 
 # Reserved field attribute names (read by codegen; open attrs at load time).
+# Mirrors server/typescript/packages/metadata/src/core/field/field-constants.ts.
 FIELD_ATTR_REQUIRED = "required"
+FIELD_ATTR_UNIQUE = "unique"
+FIELD_ATTR_DEFAULT = "default"
 FIELD_ATTR_MAX_LENGTH = "maxLength"
+FIELD_ATTR_PRECISION = "precision"
+FIELD_ATTR_SCALE = "scale"
+FIELD_ATTR_FILTERABLE = "filterable"
+FIELD_ATTR_SORTABLE = "sortable"
+FIELD_ATTR_SORTABLE_DEFAULT_ORDER = "sortableDefaultOrder"
+FIELD_ATTR_AUTO_SET = "autoSet"
 FIELD_ATTR_OBJECT_REF = "objectRef"
-FIELD_ATTR_DEFAULT = "default"
 FIELD_ATTR_VALUES = "values"
 # Persistence-side storage shape for owned field.object data. Cross-port values.
 FIELD_ATTR_STORAGE = "storage"
 STORAGE_VALUES = ("flattened", "jsonb", "subdocument")
 # Physical column name override (cross-port; renamed from @dbColumn).
 FIELD_ATTR_COLUMN = "column"
 
+# @autoSet allowed values (cross-port).
+AUTO_SET_ON_CREATE = "onCreate"
+AUTO_SET_ON_UPDATE = "onUpdate"
+AUTO_SET_VALUES = (AUTO_SET_ON_CREATE, AUTO_SET_ON_UPDATE)
+
+# @sortableDefaultOrder allowed values (cross-port).
+SORT_ORDER_ASC = "asc"
+SORT_ORDER_DESC = "desc"
+SORT_ORDER_VALUES = (SORT_ORDER_ASC, SORT_ORDER_DESC)
+
 # Regex pattern for enum member symbols — must be identifier-safe.
 # Cross-language contract: every port enforces this pattern.
 ENUM_MEMBER_PATTERN = r"^[A-Za-z_][A-Za-z0-9_]*$"

server/python/src/metaobjects/registry.py

@@ -8,7 +8,11 @@
 @dataclass(frozen=True)
 class AttrSchema:
     name: str
-    value_type: str  # an attr subtype name, e.g. "string", "boolean", "stringArray"
+    # An attr subtype name, e.g. "string", "boolean", "stringArray".
+    # Optional: a None value_type declares the attr as "known but untyped",
+    # which the YAML coercion guard skips. Used for polymorphic attrs like
+    # @default whose value type follows the OWNING field's subtype.
+    value_type: str | None
     required: bool = False
     allowed_values: tuple[str, ...] | None = None
     default: object | None = None