@metaobjectsdev/metadata 0.14.2 → 0.15.0

package/src/core/field/meta-field.ts

@@ -32,6 +32,8 @@ import {
   FIELD_SUBTYPE_OBJECT,
   FIELD_SUBTYPE_ENUM,
   FIELD_SUBTYPE_UUID,
+  FIELD_SUBTYPE_URI,
+  FIELD_SUBTYPE_INET,
   FIELD_ATTR_REQUIRED,
   FIELD_ATTR_UNIQUE,
   FIELD_ATTR_DEFAULT,
@@ -53,6 +55,10 @@ const FIELD_DATA_TYPE: Readonly<Record<string, DataType>> = {
   [FIELD_SUBTYPE_STRING]: DATA_TYPE_STRING,
   // field.uuid binds to TS `string` (no native UUID type) — DATA_TYPE_STRING.
   [FIELD_SUBTYPE_UUID]: DATA_TYPE_STRING,
+  // ADR-0036/0037 Wave 3: field.uri / field.inet bind to TS `string` (no native
+  // URI/IP type in TS). Other ports bind to their native URI/IP type.
+  [FIELD_SUBTYPE_URI]: DATA_TYPE_STRING,
+  [FIELD_SUBTYPE_INET]: DATA_TYPE_STRING,
   [FIELD_SUBTYPE_INT]: DATA_TYPE_INT,
   [FIELD_SUBTYPE_LONG]: DATA_TYPE_LONG,
   [FIELD_SUBTYPE_CURRENCY]: DATA_TYPE_LONG,
@@ -83,20 +89,23 @@ export class MetaField extends MetaData implements DataTypeAware {
     return convertToDataType(this.dataType, raw);
   }
 
-  /** The target object name for an object-typed field (the `@objectRef` attr). */
+  /** The target object name for an object-typed field (the `@objectRef` attr).
+   *  ADR-0039: resolving — a concrete field.object may inherit @objectRef via extends. */
   get objectRef(): string | undefined {
-    const v = this.ownAttr(FIELD_ATTR_OBJECT_REF);
+    const v = this.attr(FIELD_ATTR_OBJECT_REF);
     return typeof v === "string" ? v : undefined;
   }
 
-  /** Physical column name override (`@column` attr). */
+  /** Physical column name override (`@column` attr).
+   *  ADR-0039: resolving — inheritable via extends. */
   get column(): string | undefined {
-    const v = this.ownAttr(FIELD_ATTR_COLUMN);
+    const v = this.attr(FIELD_ATTR_COLUMN);
     return typeof v === "string" ? v : undefined;
   }
 
+  /** ADR-0039: resolving — a concrete field may inherit @default from an abstract base. */
   get default(): unknown {
-    return this.ownAttr(FIELD_ATTR_DEFAULT);
+    return this.attr(FIELD_ATTR_DEFAULT);
   }
 
   /**
@@ -113,30 +122,35 @@ export class MetaField extends MetaData implements DataTypeAware {
    */
   defaultValue(): AttrValue | undefined {
     return this.cached("defaultValue", () => {
-      const raw = this.ownAttr(FIELD_ATTR_DEFAULT);
+      // ADR-0039: resolving — inherit @default from an abstract base via extends.
+      const raw = this.attr(FIELD_ATTR_DEFAULT);
       if (raw === undefined) return undefined;
       return this.coerce(raw);
     });
   }
 
+  /** ADR-0039: resolving — a concrete field inherits @maxLength from an abstract base. */
   get maxLength(): number | undefined {
-    const v = this.ownAttr(FIELD_ATTR_MAX_LENGTH);
+    const v = this.attr(FIELD_ATTR_MAX_LENGTH);
     return typeof v === "number" ? v : undefined;
   }
 
+  /** ADR-0039: resolving — inheritable via extends (abstract decimal base). */
   get precision(): number | undefined {
-    const v = this.ownAttr(FIELD_ATTR_PRECISION);
+    const v = this.attr(FIELD_ATTR_PRECISION);
     return typeof v === "number" ? v : undefined;
   }
 
+  /** ADR-0039: resolving — inheritable via extends (abstract decimal base). */
   get scale(): number | undefined {
-    const v = this.ownAttr(FIELD_ATTR_SCALE);
+    const v = this.attr(FIELD_ATTR_SCALE);
     return typeof v === "number" ? v : undefined;
   }
 
-  /** True if `@unique: true` is set on the field itself (column-level unique). */
+  /** True if `@unique: true` is the effective value on the field (column-level unique).
+   *  ADR-0039: resolving — inheritable via extends. */
   get unique(): boolean {
-    return this.ownAttr(FIELD_ATTR_UNIQUE) === true;
+    return this.attr(FIELD_ATTR_UNIQUE) === true;
   }
 
   /**
@@ -144,9 +158,11 @@ export class MetaField extends MetaData implements DataTypeAware {
    *
    * Checks both `@required: true` attr and `validator.required` children —
    * matches the codegen-ts isRequired() semantics.
+   * ADR-0039: resolving — both the @required attr and the validator set are the
+   * effective (own + inherited) forms.
    */
   get isRequired(): boolean {
-    if (this.ownAttr(FIELD_ATTR_REQUIRED) === true) return true;
+    if (this.attr(FIELD_ATTR_REQUIRED) === true) return true;
     return this.validators().some((v) => v.subType === VALIDATOR_SUBTYPE_REQUIRED);
   }
 
@@ -160,6 +176,7 @@ export class MetaField extends MetaData implements DataTypeAware {
   /** Own validators only — excludes validators inherited via extends. Java parity: getChildren(Class, false). */
   ownValidators(): MetaValidator[] {
     return this.cached("ownValidators", () =>
+      // ADR-0039: own-accessor definition — the deliberate own-only API twin of validators().
       this.ownChildren().filter((c): c is MetaValidator => c.type === TYPE_VALIDATOR),
     );
   }
@@ -174,6 +191,7 @@ export class MetaField extends MetaData implements DataTypeAware {
   /** Own views only — excludes views inherited via extends. */
   ownViews(): MetaView[] {
     return this.cached("ownViews", () =>
+      // ADR-0039: own-accessor definition — the deliberate own-only API twin of views().
       this.ownChildren().filter((c): c is MetaView => c.type === TYPE_VIEW),
     );
   }

package/src/core/field/validate-field-readonly.ts

@@ -38,11 +38,15 @@ export function validateFieldReadOnly(root: MetaData): FieldReadOnlyValidationRe
   const errors: ParseError[] = [];
   const warnings: LoaderWarning[] = [];
 
-  for (const obj of root.ownChildren().filter((c) => c.type === TYPE_OBJECT)) {
+  // ADR-0039: root has no super; children()==ownChildren() but resolving is the default.
+  for (const obj of root.children().filter((c) => c.type === TYPE_OBJECT)) {
     const isValueObject = obj.subType === OBJECT_SUBTYPE_VALUE;
 
     // 1) WARN_READONLY_VALUE_OBJECT — any @readOnly field child of an object.value.
     if (isValueObject) {
+      // ADR-0039: own — warns on @readOnly DECLARED on this value's own fields
+      // (readOnlyFlag reads the explicit own flag; the FR-013 read-only checks
+      // are own-vs-super comparisons by design).
       for (const child of obj.ownChildren()) {
         if (child.type === TYPE_FIELD && readOnlyFlag(child) === true) {
           warnings.push({
@@ -60,6 +64,8 @@ export function validateFieldReadOnly(root: MetaData): FieldReadOnlyValidationRe
 
     // 2) ERR_READONLY_DOWNGRADE — read-only-ness can only be upgraded across
     //    extends. Compare own field vs. inherited field's effective @readOnly.
+    // ADR-0039: own — the downgrade check compares this object's OWN explicit
+    // @readOnly:false against the inherited effective value (own-vs-super by design).
     for (const ownField of obj.ownChildren().filter((c) => c.type === TYPE_FIELD)) {
       const ownVal = readOnlyFlag(ownField);
       if (ownVal !== false) continue; // only the explicit downgrade case matters
@@ -103,6 +109,9 @@ export function validateFieldReadOnly(root: MetaData): FieldReadOnlyValidationRe
 /** Read the explicit @readOnly value from a field's own attrs. Returns
  *  true / false when explicitly set, undefined when absent. */
 function readOnlyFlag(field: MetaData): boolean | undefined {
+  // ADR-0039: own — the FR-013 downgrade rule needs the EXPLICIT own @readOnly on
+  // THIS node (detecting an own :false against an inherited :true); resolving would
+  // mask the downgrade. Deliberate own-vs-super comparison.
   const v = field.ownAttr(FIELD_ATTR_READ_ONLY);
   if (typeof v === "boolean") return v;
   return undefined;
@@ -113,6 +122,8 @@ function readOnlyFlag(field: MetaData): boolean | undefined {
 function inheritedField(obj: MetaData, name: string): MetaData | undefined {
   let cursor = obj.superResolved;
   while (cursor !== undefined) {
+    // ADR-0039: own — super-chain walk reading each level's OWN fields to find the
+    // declaring node (the FR-013 comparison needs the declaring node's own flag).
     const f = cursor.ownChildren().find((c) => c.type === TYPE_FIELD && c.name === name);
     if (f !== undefined) return f;
     cursor = cursor.superResolved;
@@ -127,9 +138,10 @@ function primaryAssignedFieldNames(obj: MetaData): Set<string> {
   for (const id of obj.children()) {
     if (id.type !== TYPE_IDENTITY) continue;
     if (id.subType !== IDENTITY_SUBTYPE_PRIMARY) continue;
-    const gen = id.ownAttr(IDENTITY_ATTR_GENERATION);
+    // ADR-0039: resolving — an identity may inherit @generation / @fields via extends.
+    const gen = id.attr(IDENTITY_ATTR_GENERATION);
     if (gen !== GENERATION_ASSIGNED) continue;
-    const fields = id.ownAttr(IDENTITY_ATTR_FIELDS);
+    const fields = id.attr(IDENTITY_ATTR_FIELDS);
     if (Array.isArray(fields)) {
       for (const fName of fields) {
         if (typeof fName === "string") out.add(fName);

package/src/core/identity/meta-identity.ts

@@ -22,17 +22,19 @@ import type { MetaRoot } from "../../shared/meta-root.js";
 export type IdentityGeneration = "increment" | "uuid" | "assigned";
 
 export class MetaIdentity extends MetaData {
+  /** ADR-0039: resolving — @fields may be inherited via extends. */
   get fields(): string[] {
-    const f = this.ownAttr(IDENTITY_ATTR_FIELDS);
+    const f = this.attr(IDENTITY_ATTR_FIELDS);
     return Array.isArray(f) ? (f as string[]) : [];
   }
 
   /**
    * Whether the identity enforces uniqueness.
    * Defaults to true; explicit `@unique: false` makes it a non-unique index.
+   * ADR-0039: resolving.
    */
   get unique(): boolean {
-    return this.ownAttr(IDENTITY_ATTR_UNIQUE) !== false;
+    return this.attr(IDENTITY_ATTR_UNIQUE) !== false;
   }
 
   isPrimary(): boolean {
@@ -58,7 +60,8 @@ export class MetaIdentity extends MetaData {
  */
 export class MetaPrimaryIdentity extends MetaIdentity {
   get generation(): IdentityGeneration | undefined {
-    const v = this.ownAttr(IDENTITY_ATTR_GENERATION);
+    // ADR-0039: resolving — @generation may be inherited via extends.
+    const v = this.attr(IDENTITY_ATTR_GENERATION);
     return typeof v === "string" ? (v as IdentityGeneration) : undefined;
   }
 }
@@ -83,7 +86,8 @@ export class MetaSecondaryIdentity extends MetaIdentity {}
 export class MetaReferenceIdentity extends MetaIdentity {
   /** Raw `@references` attr value, unparsed. */
   get referencesRaw(): string | undefined {
-    const v = this.ownAttr(IDENTITY_REFERENCE_ATTR_REFERENCES);
+    // ADR-0039: resolving — @references may be inherited via extends.
+    const v = this.attr(IDENTITY_REFERENCE_ATTR_REFERENCES);
     return typeof v === "string" ? v : undefined;
   }
 
@@ -103,7 +107,8 @@ export class MetaReferenceIdentity extends MetaIdentity {
    * block and projection JOIN inference are unaffected.
    */
   get enforce(): boolean {
-    return this.ownAttr(IDENTITY_REFERENCE_ATTR_ENFORCE) !== false;
+    // ADR-0039: resolving — @enforce may be inherited via extends.
+    return this.attr(IDENTITY_REFERENCE_ATTR_ENFORCE) !== false;
   }
 
   /**
@@ -114,13 +119,15 @@ export class MetaReferenceIdentity extends MetaIdentity {
    * declared here too rather than only on a sibling relationship node.
    */
   get onDelete(): string | undefined {
-    const v = this.ownAttr(IDENTITY_REFERENCE_ATTR_ON_DELETE);
+    // ADR-0039: resolving — @onDelete may be inherited via extends.
+    const v = this.attr(IDENTITY_REFERENCE_ATTR_ON_DELETE);
     return typeof v === "string" && v !== "" ? v : undefined;
   }
 
   /** Referential action on key update, declared directly on the reference. Undefined when not set. */
   get onUpdate(): string | undefined {
-    const v = this.ownAttr(IDENTITY_REFERENCE_ATTR_ON_UPDATE);
+    // ADR-0039: resolving — @onUpdate may be inherited via extends.
+    const v = this.attr(IDENTITY_REFERENCE_ATTR_ON_UPDATE);
     return typeof v === "string" && v !== "" ? v : undefined;
   }
 
@@ -167,7 +174,8 @@ export class MetaReferenceIdentity extends MetaIdentity {
     if (!targetObj) return undefined;
 
     const primary = targetObj.primaryIdentity();
-    const fields = primary?.ownAttr(IDENTITY_ATTR_FIELDS) as string | string[] | undefined;
+    // ADR-0039: resolving — the target's @fields may be inherited via extends.
+    const fields = primary?.attr(IDENTITY_ATTR_FIELDS) as string | string[] | undefined;
     if (typeof fields === "string") return fields.split(",")[0]!.trim();
     if (Array.isArray(fields) && fields.length > 0) return String(fields[0]).trim();
     return "id";

package/src/core/identity/validate-identity-passthrough.ts

@@ -30,6 +30,9 @@ import { IDENTITY_ATTR_FIELDS } from "./identity-constants.js";
  * undefined when the identity declares no own @fields (the pass-through case).
  */
 export function identityOwnFields(identity: MetaData): string[] | undefined {
+  // ADR-0039: own — the OWN @fields is read deliberately (paired with
+  // identityEffectiveFields below) to detect an explicit author-declared @fields
+  // that disagrees with the computed pass-through key.
   return normalizeFields(identity.ownAttr(IDENTITY_ATTR_FIELDS));
 }
 
@@ -92,6 +95,8 @@ export function resolveIdentityPassthrough(
       continue;
     }
     const local = owner
+      // ADR-0039: own — a pass-through field must be LOCALLY declared on the
+      // projection (it carries the extends ref reaching the entity field).
       .ownChildren()
       .find((c) => c.type === TYPE_FIELD && extendsChainReaches(c, entityField));
     if (local === undefined) {
@@ -134,11 +139,14 @@ function arraysEqual(a: readonly string[], b: readonly string[]): boolean {
 export function validateIdentityPassthrough(root: MetaData): ParseError[] {
   const errors: ParseError[] = [];
 
+  // ADR-0039: root has no super; children()==ownChildren() but resolving is the default.
   for (const obj of root
-    .ownChildren()
+    .children()
     .filter(
       (c) => c.type === TYPE_OBJECT && c.subType === OBJECT_SUBTYPE_PROJECTION,
     )) {
+    // ADR-0039: own — validates the projection's OWN-declared identities (the
+    // pass-through subjects; an inherited identity was validated on its declarer).
     for (const identity of obj
       .ownChildren()
       .filter((c) => c.type === TYPE_IDENTITY)) {

package/src/core/object/meta-object.ts

@@ -71,6 +71,7 @@ export class MetaObject extends MetaData {
   /** Own fields only — excludes fields inherited via extends. Java parity: getMetaFields(false). */
   ownFields(): MetaField[] {
     return this.cached("ownFields", () =>
+      // ADR-0039: own-accessor definition — the deliberate own-only API twin of fields().
       this.ownChildren().filter((c): c is MetaField => c.type === TYPE_FIELD),
     );
   }
@@ -85,6 +86,7 @@ export class MetaObject extends MetaData {
   /** Own identities only — excludes inherited. */
   ownIdentities(): MetaIdentity[] {
     return this.cached("ownIdentities", () =>
+      // ADR-0039: own-accessor definition — the deliberate own-only API twin of identities().
       this.ownChildren().filter((c): c is MetaIdentity => c.type === TYPE_IDENTITY),
     );
   }
@@ -122,6 +124,7 @@ export class MetaObject extends MetaData {
   /** Own relationships only — excludes inherited. */
   ownRelationships(): MetaRelationship[] {
     return this.cached("ownRelationships", () =>
+      // ADR-0039: own-accessor definition — the deliberate own-only API twin of relationships().
       this.ownChildren().filter((c): c is MetaRelationship => c.type === TYPE_RELATIONSHIP),
     );
   }
@@ -136,6 +139,7 @@ export class MetaObject extends MetaData {
   /** Own validators only — excludes validators inherited via extends. Java parity: getChildren(Class, false). */
   ownValidators(): MetaValidator[] {
     return this.cached("ownValidators", () =>
+      // ADR-0039: own-accessor definition — the deliberate own-only API twin of validators().
       this.ownChildren().filter((c): c is MetaValidator => c.type === TYPE_VALIDATOR),
     );
   }
@@ -150,6 +154,7 @@ export class MetaObject extends MetaData {
   /** Own layouts only — excludes inherited. */
   ownLayouts(): MetaLayout[] {
     return this.cached("ownLayouts", () =>
+      // ADR-0039: own-accessor definition — the deliberate own-only API twin of layouts().
       this.ownChildren().filter((c): c is MetaLayout => c.type === TYPE_LAYOUT),
     );
   }

package/src/core/object/validate-discriminator.ts

@@ -40,12 +40,16 @@ const NUMERIC_DISCRIMINATOR_SUBTYPES = new Set<string>([
 export function validateDiscriminator(root: MetaData): ParseError[] {
   const errors: ParseError[] = [];
 
+  // ADR-0039: root has no super; children()==ownChildren() but resolving is the default.
   const entities = root
-    .ownChildren()
+    .children()
     .filter((c) => c.type === TYPE_OBJECT && c.subType === OBJECT_SUBTYPE_ENTITY);
 
   // Pass 1: @discriminator on bases — name resolution (own + inherited fields).
   for (const obj of entities) {
+    // ADR-0039: own — @discriminator is declared on the HIERARCHY ROOT only; reading
+    // it own distinguishes a root from a subtype (a subtype inherits it, but here we
+    // want the entity that DECLARES it). findDiscriminatorRoot walks up separately.
     const disc = obj.ownAttr(OBJECT_ATTR_DISCRIMINATOR);
     if (typeof disc !== "string" || disc === "") continue;
 
@@ -72,6 +76,8 @@ export function validateDiscriminator(root: MetaData): ParseError[] {
   const bindingsByRoot = new Map<MetaData, SubtypeBinding[]>();
 
   for (const obj of entities) {
+    // ADR-0039: own — @discriminatorValue is per-subtype; each concrete entity
+    // declares its OWN. Reading own detects THIS subtype's declared value.
     const value = obj.ownAttr(OBJECT_ATTR_DISCRIMINATOR_VALUE);
     if (typeof value !== "string" || value === "") continue;
 
@@ -83,7 +89,9 @@ export function validateDiscriminator(root: MetaData): ParseError[] {
 
     // Type-match check.
     if (field.subType === FIELD_SUBTYPE_ENUM) {
-      const enumValues = field.ownAttr(FIELD_ATTR_VALUES);
+      // ADR-0039: resolving — the discriminator field may inherit @values from an
+      // abstract enum via extends.
+      const enumValues = field.attr(FIELD_ATTR_VALUES);
       const list = Array.isArray(enumValues) ? enumValues.map(String) : [];
       if (!list.includes(value)) {
         errors.push(
@@ -140,6 +148,8 @@ export function validateDiscriminator(root: MetaData): ParseError[] {
   // entity that extends a @discriminator-bearing root must declare a value.
   for (const obj of entities) {
     if (obj.isAbstract === true) continue;
+    // ADR-0039: own — checks whether THIS entity declares its OWN value / its OWN
+    // @discriminator (a root). Resolving would inherit a parent's and mis-classify.
     if (typeof obj.ownAttr(OBJECT_ATTR_DISCRIMINATOR_VALUE) === "string") continue;
     if (typeof obj.ownAttr(OBJECT_ATTR_DISCRIMINATOR) === "string") continue; // a root, not a subtype
     const { root: discRoot } = findDiscriminatorRoot(obj);
@@ -160,11 +170,14 @@ export function validateDiscriminator(root: MetaData): ParseError[] {
 /** Find a field with the given name on `entity` — own first, then via the
  *  resolved extends chain. Returns the declaring field node (own attrs intact). */
 function findFieldOnEntity(entity: MetaData, name: string): MetaData | undefined {
+  // ADR-0039: own — extends-chain walk returning the DECLARING field node (own
+  // children at each level), so callers can read that node's own/effective attrs.
   for (const child of entity.ownChildren()) {
     if (child.type === TYPE_FIELD && child.name === name) return child;
   }
   let cursor = entity.superResolved;
   while (cursor !== undefined) {
+    // ADR-0039: own — super-chain walk reading each level's OWN fields.
     for (const child of cursor.ownChildren()) {
       if (child.type === TYPE_FIELD && child.name === name) return child;
     }
@@ -181,6 +194,8 @@ function findDiscriminatorRoot(
 ): { root: MetaData | undefined; fieldName: string | undefined } {
   let cursor: MetaData | undefined = entity;
   while (cursor !== undefined) {
+    // ADR-0039: own — walks up to find the ancestor that DECLARES @discriminator
+    // (the hierarchy root); must read own to locate the physical declaration site.
     const v = cursor.ownAttr(OBJECT_ATTR_DISCRIMINATOR);
     if (typeof v === "string" && v !== "") {
       return { root: cursor, fieldName: v };

package/src/core/query/query-constants.ts

@@ -1,4 +1,4 @@
-import { FIELD_SUBTYPE_UUID, FIELD_SUBTYPE_CURRENCY, FIELD_SUBTYPE_ENUM } from "../field/field-constants.js";
+import { FIELD_SUBTYPE_UUID, FIELD_SUBTYPE_CURRENCY, FIELD_SUBTYPE_ENUM, FIELD_SUBTYPE_URI, FIELD_SUBTYPE_INET } from "../field/field-constants.js";
 
 // Query concern constants — filter operators, sort order values.
 //
@@ -55,6 +55,12 @@ export const OPS_BY_SUBTYPE: Readonly<Record<string, readonly FilterOp[]>> = {
   // uuid: identity-comparison ops only — no `like` (not free-text) and no
   // ordering (`gt`/`lt` are meaningless on a UUID).
   [FIELD_SUBTYPE_UUID]: [FILTER_OP_EQ, FILTER_OP_NE, FILTER_OP_IN, FILTER_OP_IS_NULL],
+  // uri: a URI string — free-text-comparable. Same op band as string (prefix
+  // matching with `like` is meaningful for URLs).
+  [FIELD_SUBTYPE_URI]: [FILTER_OP_EQ, FILTER_OP_NE, FILTER_OP_IN, FILTER_OP_LIKE, FILTER_OP_IS_NULL],
+  // inet: an IP address — identity-comparison ops only (no `like`; ordering
+  // gt/lt is not exposed). Same op band as uuid.
+  [FIELD_SUBTYPE_INET]: [FILTER_OP_EQ, FILTER_OP_NE, FILTER_OP_IN, FILTER_OP_IS_NULL],
 } as const;
 
 export function opsForSubType(subType: string): readonly FilterOp[] {

package/src/core/relationship/meta-relationship.ts

@@ -13,44 +13,46 @@ import {
   RELATIONSHIP_ATTR_ON_UPDATE,
 } from "./relationship-constants.js";
 
+// ADR-0039: every getter below uses the RESOLVING attr() accessor — a relationship
+// attr may be inherited from an abstract base via extends.
 export class MetaRelationship extends MetaData {
   get cardinality(): string | undefined {
-    const v = this.ownAttr(RELATIONSHIP_ATTR_CARDINALITY);
+    const v = this.attr(RELATIONSHIP_ATTR_CARDINALITY);
     return typeof v === "string" ? v : undefined;
   }
 
   /** FQN of the target object (e.g., "acme::vehicle::Car"). */
   get objectRef(): string | undefined {
-    const v = this.ownAttr(RELATIONSHIP_ATTR_OBJECT_REF);
+    const v = this.attr(RELATIONSHIP_ATTR_OBJECT_REF);
     return typeof v === "string" ? v : undefined;
   }
 
   /** Junction (through) entity name for M:N relationships. */
   get through(): string | undefined {
-    const v = this.ownAttr(RELATIONSHIP_ATTR_THROUGH);
+    const v = this.attr(RELATIONSHIP_ATTR_THROUGH);
     return typeof v === "string" ? v : undefined;
   }
 
   /** Source-side FK field on the junction (directed self-join disambiguator). */
   get sourceRefField(): string | undefined {
-    const v = this.ownAttr(RELATIONSHIP_ATTR_SOURCE_REF_FIELD);
+    const v = this.attr(RELATIONSHIP_ATTR_SOURCE_REF_FIELD);
     return typeof v === "string" ? v : undefined;
   }
 
   /** Whether this M:N relationship is an undirected (symmetric) self-join. */
   get symmetric(): boolean {
-    return this.ownAttr(RELATIONSHIP_ATTR_SYMMETRIC) === true;
+    return this.attr(RELATIONSHIP_ATTR_SYMMETRIC) === true;
   }
 
   /** Referential action on parent delete. Undefined when not explicitly set (default derives from subtype). */
   get onDelete(): string | undefined {
-    const v = this.ownAttr(RELATIONSHIP_ATTR_ON_DELETE);
+    const v = this.attr(RELATIONSHIP_ATTR_ON_DELETE);
     return typeof v === "string" && v !== "" ? v : undefined;
   }
 
   /** Referential action on key update. Undefined when not explicitly set (default: cascade). */
   get onUpdate(): string | undefined {
-    const v = this.ownAttr(RELATIONSHIP_ATTR_ON_UPDATE);
+    const v = this.attr(RELATIONSHIP_ATTR_ON_UPDATE);
     return typeof v === "string" && v !== "" ? v : undefined;
   }
 }

package/src/core/validator/meta-validator.ts

@@ -19,12 +19,14 @@ export class MetaValidator extends MetaData {
    * (Pattern moves to MetaRegexValidator; required validators have no extra attrs.)
    */
   get min(): number | undefined {
-    const v = this.ownAttr(VALIDATOR_ATTR_MIN);
+    // ADR-0039: resolving — effective bound; a validator may inherit @min via extends.
+    const v = this.attr(VALIDATOR_ATTR_MIN);
     return typeof v === "number" ? v : undefined;
   }
 
   get max(): number | undefined {
-    const v = this.ownAttr(VALIDATOR_ATTR_MAX);
+    // ADR-0039: resolving — effective bound; a validator may inherit @max via extends.
+    const v = this.attr(VALIDATOR_ATTR_MAX);
     return typeof v === "number" ? v : undefined;
   }
 
@@ -50,7 +52,8 @@ export class MetaLengthValidator extends MetaValidator {}
 /** Regex validator: carries the pattern. */
 export class MetaRegexValidator extends MetaValidator {
   get pattern(): string | undefined {
-    const v = this.ownAttr(VALIDATOR_ATTR_PATTERN);
+    // ADR-0039: resolving — effective @pattern; a validator may inherit it via extends.
+    const v = this.attr(VALIDATOR_ATTR_PATTERN);
     return typeof v === "string" ? v : undefined;
   }
 }

package/src/core-types.ts

@@ -266,8 +266,8 @@ function registerCoreTypeDefs(registry: TypeRegistry): void {
   // childRules EMPTY. The named attrs still enforce strictly via attr-schema-
   // validate (ERR_UNKNOWN_ATTR); a misplaced STRUCTURAL child is now
   // ERR_CHILD_NOT_ALLOWED. Attr schemas: base + length/numeric/array read @min/@max
-  // via this.ownAttr(VALIDATOR_ATTR_MIN/MAX); regex also reads @pattern; required
-  // has no extra attrs.
+  // via this.attr(VALIDATOR_ATTR_MIN/MAX) (ADR-0039 resolving); regex also reads
+  // @pattern; required has no extra attrs.
   const VALIDATOR_FACTORIES: FactoryMap = Object.fromEntries(
     VALIDATOR_SUBTYPES.map((subType) => [
       `${TYPE_VALIDATOR}.${subType}`,

package/src/loader/meta-data-loader.ts

@@ -249,6 +249,8 @@ export class MetaDataLoader {
    */
   findByName(name: string): MetaData | undefined {
     this._checkStateForRead();
+    // ADR-0039: own — the tree root has no super chain (never `extends`),
+    // so its own children ARE its effective children.
     return this._root!.ownChildByName(name);
   }
 
@@ -258,6 +260,7 @@ export class MetaDataLoader {
    */
   findByTypeAndName(type: string, name: string): MetaData | undefined {
     this._checkStateForRead();
+    // ADR-0039: own — the tree root has no super chain (never `extends`).
     return this._root!.ownChildByTypeAndName(type, name);
   }
 
@@ -267,6 +270,7 @@ export class MetaDataLoader {
    */
   childrenOfType(type: string): MetaData[] {
     this._checkStateForRead();
+    // ADR-0039: own — the tree root has no super chain (never `extends`).
     return this._root!.ownChildrenOfType(type);
   }