@carbonenginejs/runtime 0.1.0-alpha.3 → 0.1.0-alpha.4

package/dist/global/model/CjsModelState.js

@@ -9,15 +9,6 @@ import { RUNTIME_STATE_PROTOTYPE } from '../compose/runtimeState.js';
  *   pipeline is cooperative - anything mutating outside `SetValues`
  *   (direct writes, Object.assign, reader adapters) owes a `MarkDirty()`
  *   or an explicit `UpdateValues()` ("I made changes, apply please").
- * - `flags` holds lazy invalidations ("bounds is stale"). Written at
- *   mutation time from `@io.flag` field metadata or by class code; cleared
- *   ONLY by the getter that recomputes the derived value. Never
- *   auto-cleared - deferring until needed is their whole point.
- * - `rebuild` holds scheduled work requirements ("vertices need
- *   rebuilding"). Written at mutation time from `@io.rebuild` field
- *   metadata or by class code; cleared ONLY by the specific work method
- *   that succeeds (e.g. RebuildVertices), typically driven from Update /
- *   per-frame passes. Never auto-cleared.
  * - Future transient runtime state (lifecycle links, revision counters)
  *   lands here rather than growing new underscore properties.
  */
@@ -25,12 +16,6 @@ class CjsModelState {
   /** Something changed; the next settle applies it. @type {boolean} */
   dirty = false;
 
-  /** Lazy invalidations - consumers clear when they recompute. @type {Set<string>} */
-  flags = new Set();
-
-  /** Scheduled work requirements - work methods clear on success. @type {Set<string>} */
-  rebuild = new Set();
-
   /** Settle re-entrancy guard. @type {boolean} */
   updating = false;
 

package/dist/global/model/CjsModelState.js.map

@@ -1 +1 @@
-{"version":3,"file":"CjsModelState.js","sources":["../../../../src/global/model/CjsModelState.js"],"sourcesContent":["import { RUNTIME_STATE_PROTOTYPE } from \"../compose/runtimeState.js\";\r\n\r\n/**\r\n * Per-model runtime state. One instance per model at `__state`.\r\n *\r\n * Ownership and clearing rules (kb section 8):\r\n * - `dirty` is the only generically managed member: mutations mark it, and\r\n *   `UpdateValues` (the settle) is the only thing that clears it. The\r\n *   pipeline is cooperative - anything mutating outside `SetValues`\r\n *   (direct writes, Object.assign, reader adapters) owes a `MarkDirty()`\r\n *   or an explicit `UpdateValues()` (\"I made changes, apply please\").\r\n * - `flags` holds lazy invalidations (\"bounds is stale\"). Written at\r\n *   mutation time from `@io.flag` field metadata or by class code; cleared\r\n *   ONLY by the getter that recomputes the derived value. Never\r\n *   auto-cleared - deferring until needed is their whole point.\r\n * - `rebuild` holds scheduled work requirements (\"vertices need\r\n *   rebuilding\"). Written at mutation time from `@io.rebuild` field\r\n *   metadata or by class code; cleared ONLY by the specific work method\r\n *   that succeeds (e.g. RebuildVertices), typically driven from Update /\r\n *   per-frame passes. Never auto-cleared.\r\n * - Future transient runtime state (lifecycle links, revision counters)\r\n *   lands here rather than growing new underscore properties.\r\n */\r\nexport class CjsModelState\r\n{\r\n\r\n    /** Something changed; the next settle applies it. @type {boolean} */\r\n    dirty = false;\r\n\r\n    /** Lazy invalidations - consumers clear when they recompute. @type {Set<string>} */\r\n    flags = new Set();\r\n\r\n    /** Scheduled work requirements - work methods clear on success. @type {Set<string>} */\r\n    rebuild = new Set();\r\n\r\n    /** Settle re-entrancy guard. @type {boolean} */\r\n    updating = false;\r\n\r\n    /** Construction/teardown event gate (counted). @type {number} */\r\n    suppressEvents = 0;\r\n\r\n    /**\r\n     * Checks whether a settle is owed.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    IsDirty()\r\n    {\r\n        return this.dirty;\r\n    }\r\n\r\n    /**\r\n     * Marks the model as changed (\"apply at the next settle\").\r\n     *\r\n     * @returns {CjsModelState} This state.\r\n     */\r\n    MarkDirty()\r\n    {\r\n        this.dirty = true;\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Clears the dirty mark. The settle calls this; class code rarely should.\r\n     *\r\n     * @returns {CjsModelState} This state.\r\n     */\r\n    ClearDirty()\r\n    {\r\n        this.dirty = false;\r\n        return this;\r\n    }\r\n\r\n}\r\n\r\n\r\n// Models put a CjsModelState in the same __state slot a composed class fills\r\n// with a plain state object, so it answers the same questions - HasListener\r\n// first among them. Linking the prototypes rather than copying the method\r\n// means anything added to the shared state surface reaches models too.\r\nObject.setPrototypeOf(CjsModelState.prototype, RUNTIME_STATE_PROTOTYPE);\r\n"],"names":["CjsModelState","dirty","flags","Set","rebuild","updating","suppressEvents","IsDirty","MarkDirty","ClearDirty","Object","setPrototypeOf","prototype","RUNTIME_STATE_PROTOTYPE"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,aAAa,CAC1B;AAEI;AACAC,EAAAA,KAAK,GAAG,KAAK;;AAEb;AACAC,EAAAA,KAAK,GAAG,IAAIC,GAAG,EAAE;;AAEjB;AACAC,EAAAA,OAAO,GAAG,IAAID,GAAG,EAAE;;AAEnB;AACAE,EAAAA,QAAQ,GAAG,KAAK;;AAEhB;AACAC,EAAAA,cAAc,GAAG,CAAC;;AAElB;AACJ;AACA;AACA;AACA;AACIC,EAAAA,OAAOA,GACP;IACI,OAAO,IAAI,CAACN,KAAK;AACrB,EAAA;;AAEA;AACJ;AACA;AACA;AACA;AACIO,EAAAA,SAASA,GACT;IACI,IAAI,CAACP,KAAK,GAAG,IAAI;AACjB,IAAA,OAAO,IAAI;AACf,EAAA;;AAEA;AACJ;AACA;AACA;AACA;AACIQ,EAAAA,UAAUA,GACV;IACI,IAAI,CAACR,KAAK,GAAG,KAAK;AAClB,IAAA,OAAO,IAAI;AACf,EAAA;AAEJ;;AAGA;AACA;AACA;AACA;AACAS,MAAM,CAACC,cAAc,CAACX,aAAa,CAACY,SAAS,EAAEC,uBAAuB,CAAC;;;;"}
+{"version":3,"file":"CjsModelState.js","sources":["../../../../src/global/model/CjsModelState.js"],"sourcesContent":["import { RUNTIME_STATE_PROTOTYPE } from \"../compose/runtimeState.js\";\r\n\r\n/**\r\n * Per-model runtime state. One instance per model at `__state`.\r\n *\r\n * Ownership and clearing rules (kb section 8):\r\n * - `dirty` is the only generically managed member: mutations mark it, and\r\n *   `UpdateValues` (the settle) is the only thing that clears it. The\r\n *   pipeline is cooperative - anything mutating outside `SetValues`\r\n *   (direct writes, Object.assign, reader adapters) owes a `MarkDirty()`\r\n *   or an explicit `UpdateValues()` (\"I made changes, apply please\").\r\n * - Future transient runtime state (lifecycle links, revision counters)\r\n *   lands here rather than growing new underscore properties.\r\n */\r\nexport class CjsModelState\r\n{\r\n\r\n    /** Something changed; the next settle applies it. @type {boolean} */\r\n    dirty = false;\r\n\r\n    /** Settle re-entrancy guard. @type {boolean} */\r\n    updating = false;\r\n\r\n    /** Construction/teardown event gate (counted). @type {number} */\r\n    suppressEvents = 0;\r\n\r\n    /**\r\n     * Checks whether a settle is owed.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    IsDirty()\r\n    {\r\n        return this.dirty;\r\n    }\r\n\r\n    /**\r\n     * Marks the model as changed (\"apply at the next settle\").\r\n     *\r\n     * @returns {CjsModelState} This state.\r\n     */\r\n    MarkDirty()\r\n    {\r\n        this.dirty = true;\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Clears the dirty mark. The settle calls this; class code rarely should.\r\n     *\r\n     * @returns {CjsModelState} This state.\r\n     */\r\n    ClearDirty()\r\n    {\r\n        this.dirty = false;\r\n        return this;\r\n    }\r\n\r\n}\r\n\r\n\r\n// Models put a CjsModelState in the same __state slot a composed class fills\r\n// with a plain state object, so it answers the same questions - HasListener\r\n// first among them. Linking the prototypes rather than copying the method\r\n// means anything added to the shared state surface reaches models too.\r\nObject.setPrototypeOf(CjsModelState.prototype, RUNTIME_STATE_PROTOTYPE);\r\n"],"names":["CjsModelState","dirty","updating","suppressEvents","IsDirty","MarkDirty","ClearDirty","Object","setPrototypeOf","prototype","RUNTIME_STATE_PROTOTYPE"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,aAAa,CAC1B;AAEI;AACAC,EAAAA,KAAK,GAAG,KAAK;;AAEb;AACAC,EAAAA,QAAQ,GAAG,KAAK;;AAEhB;AACAC,EAAAA,cAAc,GAAG,CAAC;;AAElB;AACJ;AACA;AACA;AACA;AACIC,EAAAA,OAAOA,GACP;IACI,OAAO,IAAI,CAACH,KAAK;AACrB,EAAA;;AAEA;AACJ;AACA;AACA;AACA;AACII,EAAAA,SAASA,GACT;IACI,IAAI,CAACJ,KAAK,GAAG,IAAI;AACjB,IAAA,OAAO,IAAI;AACf,EAAA;;AAEA;AACJ;AACA;AACA;AACA;AACIK,EAAAA,UAAUA,GACV;IACI,IAAI,CAACL,KAAK,GAAG,KAAK;AAClB,IAAA,OAAO,IAAI;AACf,EAAA;AAEJ;;AAGA;AACA;AACA;AACA;AACAM,MAAM,CAACC,cAAc,CAACR,aAAa,CAACS,SAAS,EAAEC,uBAAuB,CAAC;;;;"}

package/dist/global/model/index.js

@@ -1,4 +1,4 @@
-export { CjsModel, carbon, exportSourceValue, impl, importSourceValue, io, isModelInstance, jessica, schema, type } from './CjsModel.js';
+export { CjsModel, carbon, edit, exportSourceValue, impl, importSourceValue, isModelInstance, jessica, lifecycle, schema, type } from './CjsModel.js';
 export { CjsModelState } from './CjsModelState.js';
 export { CjsEventEmitter } from './CjsEventEmitter.js';
 export { asArray, clonePlain, collectionValues, firstDefined, getField, objectFromMap } from './sourceRecordUtils.js';

package/dist/global/schema/CjsSchema.js

@@ -1,7 +1,9 @@
 import { defaultValueForCarbonField, coerceCarbonMathInto, coerceCarbonTypedArrayInto, exportCarbonValue, cloneCarbonValue, normalizeCarbonValue } from './types/carbonTypes.js';
+import { composeAbstractDecorator } from '../compose/abstract.js';
 import { composeNotifyDecorator } from '../compose/notify.js';
-import { cast, composeInterfaceDecorator } from '../compose/interface.js';
+import { cast, carbonMapInterfaceDecorator, carbonInheritDecorator } from '../compose/interface.js';
 import { createValuesTransport, composeValuesDecorator } from '../compose/values.js';
+import { blueEnums, CjsBlueEnumRegistry } from '../blue/enums/CjsBlueEnumRegistry.js';
 
 const CLASS_SCHEMA = new WeakMap();
 
@@ -14,8 +16,6 @@ const FIELD_INITIAL_DEFAULTS = new WeakMap();
 const FIELD_DECLARATION_METADATA = new WeakMap();
 let SCHEMA_GENERATION = 0;
 const CONSTRUCTOR_BY_NAME = new Map();
-const ENUM_SCHEMA_BY_NAME = new Map();
-const ENUM_SCHEMA_BY_OBJECT = new WeakMap();
 const STAGE3_FIELD_METADATA = Symbol("carbonenginejs.schema.stage3Fields");
 
 // Declared here rather than beside describeDecorator: the CjsSchema class body
@@ -140,7 +140,8 @@ class CjsSchema {
 
   /** Returns resolved schema metadata for a named field. */
   static getField(Constructor, fieldName) {
-    return getEffectiveFields(Constructor).find(field => field.name === fieldName) || null;
+    const field = getEffectiveFields(Constructor).find(field => field.name === fieldName);
+    return field ? enrichEnumField(field, Constructor) : null;
   }
 
   /**
@@ -452,13 +453,13 @@ class CjsSchema {
   /** Returns the stable registered name for an enum object. */
   static getEnumName(values) {
     if (typeof values === "string") return values;
-    return values && typeof values === "object" ? ENUM_SCHEMA_BY_OBJECT.get(values)?.name || values[CJS_ENUM_NAME] || values.Source?.name || values.name || null : null;
+    return values && typeof values === "object" ? blueEnums.GetEnumName(values) || blueEnums.GetEnumName(values.Type) || values[CJS_ENUM_NAME] || values.Source?.name || values.name || null : null;
   }
 
   /** Returns registered enum metadata by name or enum object. */
   static getEnum(values) {
     const name = CjsSchema.getEnumName(values);
-    return name ? ENUM_SCHEMA_BY_NAME.get(name) || null : null;
+    return name && blueEnums.HasEnum(name) ? blueEnums.GetEnumInfo(name) : null;
   }
 
   /**
@@ -650,59 +651,75 @@ class CjsSchema {
      */
     hideInherited: fieldNames => hiddenInheritedFieldsDecorator(normalizeHiddenInheritedFields(fieldNames))
   });
-  static io = Object.freeze({
-    always: fieldDecorator("io", {
-      always: true
-    }),
-    notify: fieldDecorator("io", {
-      notify: true
+
+  // Be::EDITFLAGS, exactly (`blueexposure/include/BlueTypes.h:282-311`).
+  // Every member below is one of Carbon's; nothing else belongs here. The
+  // namespace was called `io` until 2026-09-18, which named about a third of
+  // what it holds - only PERSIST and RPERSIST are I/O, NOTIFY is wiring,
+  // HIDDEN and FLAGS are editor hints, READ and WRITE are access control.
+  static edit = Object.freeze({
+    none: fieldDecorator("edit", {}),
+    // MODMASK 0x00F
+    read: fieldDecorator("edit", {
+      read: true
     }),
-    owned: fieldDecorator("io", {
-      ownership: "owned"
+    write: fieldDecorator("edit", {
+      write: true
     }),
-    persist: fieldDecorator("io", {
+    readwrite: fieldDecorator("edit", {
       read: true,
-      write: true,
-      persist: true
+      write: true
     }),
-    persistOnly: fieldDecorator("io", {
-      persist: true,
-      persistOnly: true
+    notify: fieldDecorator("edit", {
+      notify: true
     }),
-    read: fieldDecorator("io", {
-      read: true
+    hidden: fieldDecorator("edit", {
+      hidden: true
     }),
-    readwrite: fieldDecorator("io", {
-      read: true,
-      write: true
+    // SERMASK 0x0F0
+    persist: fieldDecorator("edit", {
+      persist: true
     }),
-    reference: fieldDecorator("io", {
-      ownership: "reference"
+    // RPERSIST 0x020 - "like PERSIST but only unserialize (read only)":
+    // the value loads from a document and is never written back out.
+    rpersist: fieldDecorator("edit", {
+      rpersist: true
     }),
-    // Declares the lazy-invalidation token(s) a change to this field
-    // implies ("bounds is stale"). Added to __state.flags at write time;
-    // cleared ONLY by the getter that recomputes the derived value.
-    flag: (...tokens) => fieldDecorator("io", {
-      flag: tokens.flat().map(String)
+    flags: fieldDecorator("edit", {
+      flags: true
     }),
-    // Declares the rebuild requirement token(s) a change to this field
-    // implies ("vertices need rebuilding"). Added to __state.rebuild at
-    // write time; cleared ONLY by the specific work method that succeeds
-    // (typically driven from Update / per-frame passes).
-    rebuild: (...tokens) => fieldDecorator("io", {
-      rebuild: tokens.flat().map(String)
+    enum: fieldDecorator("edit", {
+      enum: true
     }),
-    write: fieldDecorator("io", {
-      write: true
+    // PERSISTONLY = HIDDEN | PERSIST, for hidden attributes.
+    persistOnly: fieldDecorator("edit", {
+      persist: true,
+      persistOnly: true,
+      hidden: true
     })
   });
 
-  // Composition decorators: type/io/carbon/impl/jessica DESCRIBE, compose
+  // Not EDITFLAGS and not type: WHO runs a child's construction, and later
+  // its teardown. `owned` marks a donor BY-VALUE member, destroyed with its
+  // parent; `reference` marks a borrowed one. Today only construction reads
+  // it - `entry.owned` (built below) gates the `ownedOnly` walk that runs
+  // Initialize in CjsModel.from - so the flag is half installed rather than
+  // unused: there is no teardown traversal yet to honour the other half.
+  static lifecycle = Object.freeze({
+    owned: fieldDecorator("lifecycle", {
+      ownership: "owned"
+    }),
+    reference: fieldDecorator("lifecycle", {
+      ownership: "reference"
+    })
+  });
+
+  // Composition decorators: type/edit/carbon/impl/jessica DESCRIBE, compose
   // INSTALLS (design record, direction item 11). All three are live; the
   // migration of existing classes onto them is separate work.
   static compose = Object.freeze({
+    abstract: composeAbstractDecorator(Constructor => CjsSchema.getClassName(Constructor)),
     notify: composeNotifyDecorator,
-    interface: Contract => composeInterfaceDecorator(Contract, (Constructor, name) => CjsSchema.decorateMethod(Constructor, name, CjsSchema.impl.abstract)),
     values: composeValuesDecorator(CjsSchema.#statelessTransport)
   });
   static jessica = Object.freeze({
@@ -754,6 +771,11 @@ class CjsSchema {
       notSupported: true,
       status: "notSupported"
     }),
+    // Audit-only: names the state members invalidated by this field/method.
+    // The owning class retains all dirty-state, rebuild and timing behavior.
+    invalidates: (...members) => memberDecorator("impl", {
+      invalidates: members
+    }),
     note: text => memberDecorator("impl", {
       note: String(text)
     }),
@@ -761,7 +783,50 @@ class CjsSchema {
       reason: String(text)
     })
   });
+
+  /**
+   * What an installed interface member should be marked as on its consumer.
+   *
+   * CARBON'S INTERFACES ARE NOT UNIFORM, and that is the whole reason this
+   * exists. Some methods are pure virtual, and a consumer inheriting one
+   * without implementing it is genuinely unimplemented. Others are declared
+   * with an EMPTY BODY on purpose, so an implementer overrides only the half
+   * it cares about - `IBlueResManNotifications` has both callbacks empty in
+   * the donor. Marking that second kind `impl.abstract` on every consumer
+   * writes a divergence that does not exist, onto dozens of classes at once.
+   *
+   * So the interface's own declaration is carried across, and
+   * `impl.abstract` is only the fallback for a member the interface said
+   * nothing about. The chain is walked because `CollectMembers` does: a
+   * member may be declared on an ancestor of the contract named here.
+   *
+   * @param {Function} Contract The interface the member was installed from.
+   * @param {String} name The member.
+   * @returns {Array<Function>} Decorators for `decorateMethod`.
+   */
+  static #inheritedImplDecorators(Contract, name) {
+    let declared = null;
+    for (let base = Contract; typeof base === "function" && base.prototype && base !== Object; base = Object.getPrototypeOf(base)) {
+      declared = CjsSchema.getMethod(base, name)?.impl ?? null;
+      if (declared) break;
+    }
+    const status = declared?.status;
+    const decorator = status ? CjsSchema.impl[status] : null;
+    const decorators = [typeof decorator === "function" ? decorator : CjsSchema.impl.abstract];
+
+    // A reason the interface wrote belongs to the member wherever it lands;
+    // a consumer left holding the marking without it could not be reviewed.
+    if (declared?.reason) decorators.push(CjsSchema.impl.reason(declared.reason));
+    if (declared?.note) decorators.push(CjsSchema.impl.note(declared.note));
+    return decorators;
+  }
   static carbon = Object.freeze({
+    // Carbon's base list and Carbon's exposure table: two different facts,
+    // two decorators, both factual and so both here rather than in
+    // `compose`. See compose/interface.js for the black-reader branch that
+    // proves they cannot be collapsed into one.
+    inherit: (...Bases) => carbonInheritDecorator(Bases, (Constructor, name, Contract) => CjsSchema.decorateMethod(Constructor, name, ...CjsSchema.#inheritedImplDecorators(Contract, name))),
+    mapInterface: (...Interfaces) => carbonMapInterfaceDecorator(Interfaces),
     method: methodDecorator("carbon", {
       method: true
     }),
@@ -1150,13 +1215,43 @@ function hiddenInheritedFieldsDecorator(fieldNames) {
   };
 }
 const CONTEXT_FIRST_PARAMETER = /^\(?\s*_?(context|updateContext)\b/;
+
+/**
+ * Whether a function's source still carries the names it was written with.
+ *
+ * A minifier renames parameters to one or two characters, so `(context)`
+ * arrives as `(t)` and any assertion about the NAME becomes an assertion about
+ * the build. There is no way to tell a minified name from a wrongly chosen one
+ * by inspection, so the only sound thing is to stop asking once the names are
+ * gone - which a parameter list of nothing but short identifiers says plainly.
+ *
+ * @param {string} parameterList Source from the opening parenthesis.
+ * @returns {boolean} True when at least one parameter kept a real name.
+ */
+function hasReadableParameterNames(parameterList) {
+  const close = parameterList.indexOf(")");
+  const declared = close === -1 ? parameterList : parameterList.slice(0, close);
+  return /[A-Za-z_$][\w$]{2,}/u.test(declared);
+}
 function assertContextFirstMethod(fn, methodName) {
   if (typeof fn !== "function") {
     return;
   }
   const source = String(fn);
   const parameterList = source.slice(source.indexOf("("));
-  if (fn.length < 1 || !CONTEXT_FIRST_PARAMETER.test(parameterList)) {
+
+  // Arity is the contract and holds in any build: a contextual method that
+  // takes nothing cannot have been given a context.
+  if (fn.length < 1) {
+    throw new TypeError(`CjsSchema.carbon.contextual method "${String(methodName)}" must take a context as its first parameter.`);
+  }
+
+  // The NAME is an authoring convention, and it is only checkable while the
+  // names exist. Asserting it against a minified bundle threw on every
+  // contextual method in the shipped build and took the engine down at load
+  // - the failure is the assertion's, not the code's.
+  if (!hasReadableParameterNames(parameterList)) return;
+  if (!CONTEXT_FIRST_PARAMETER.test(parameterList)) {
     throw new TypeError(`CjsSchema.carbon.contextual method "${String(methodName)}" must be context-first ` + "(first parameter named context or updateContext).");
   }
 }
@@ -1324,6 +1419,15 @@ function getEffectiveFields(Constructor) {
       hidden.add(fieldName);
     }
   }
+
+  // Enum chooser metadata carries the same ENUM fact as Blue's flag.
+  // Keep it visible under edit for comparisons without duplicating annotations.
+  for (const field of ordered) {
+    if (field.enum) field.edit = {
+      ...field.edit,
+      enum: true
+    };
+  }
   return ordered.filter(field => !hidden.has(field.name));
 }
 function getHiddenInheritedFieldNames(Constructor) {
@@ -1457,7 +1561,7 @@ function addSchemaBuckets(schema) {
       resources.push(entry);
       continue;
     }
-    entry.owned = field.io?.ownership === "owned";
+    entry.owned = field.lifecycle?.ownership === "owned";
     children.push(entry);
   }
   schema.byName = byName;
@@ -1681,13 +1785,7 @@ function registerClassMetadata(Constructor, schema) {
 }
 function defineEnumMetadata(values, schema) {
   if (!values || typeof values !== "object" || !schema?.name) return;
-  ENUM_SCHEMA_BY_NAME.set(schema.name, schema);
-  ENUM_SCHEMA_BY_OBJECT.set(values, schema);
-  if (Object.isExtensible(values) && !Object.prototype.hasOwnProperty.call(values, CJS_ENUM_NAME)) {
-    Object.defineProperty(values, CJS_ENUM_NAME, {
-      value: schema.name
-    });
-  }
+  blueEnums.RegisterEnum(schema.name, schema.type, schema);
 }
 function normalizeEnumSchema(values, definition) {
   const type = values?.Type || values;
@@ -1702,6 +1800,10 @@ function normalizeEnumSchema(values, definition) {
   if (definition.source) result.source = definition.source;
   if (definition.family) result.family = definition.family;
   if (definition.line !== undefined && definition.line !== null) result.line = definition.line;
+  if (definition.exposure !== undefined) result.exposure = definition.exposure;
+  if (definition.exposedName !== undefined) result.exposedName = definition.exposedName;
+  if (definition.chooserSource !== undefined) result.chooserSource = definition.chooserSource;
+  if (definition.chooser !== undefined) result.chooser = definition.chooser;
   return result;
 }
 function normalizeEnumDefinition(values) {
@@ -1812,6 +1914,20 @@ function mergeNamespace(existing, value) {
 function enrichEnumField(exported, Constructor) {
   const enumType = exported?.enum?.enumType;
   if (!enumType) return exported;
+  if (enumType.includes(".")) {
+    const info = blueEnums.GetEnumInfo(enumType);
+    return {
+      ...exported,
+      enum: {
+        ...exported.enum,
+        identity: info.name,
+        members: info.type,
+        ...(info.chooser === undefined ? {} : {
+          chooser: info.chooser
+        })
+      }
+    };
+  }
   const members = Constructor?.[enumType];
   if (!members || typeof members !== "object") return exported;
   let owner = Constructor;
@@ -1865,5 +1981,15 @@ function describeValuesInput(value) {
   return name ? `an instance of ${name}` : "an object without Object.prototype";
 }
 
+// Install provenance here, after the schema exists. The registry core cannot
+// import schema: both Blue and schema need its storage during module loading.
+CjsSchema.define(CjsBlueEnumRegistry, {
+  className: "CjsBlueEnumRegistry",
+  modelledOn: "BlueRegistration",
+  family: "blue",
+  fields: {},
+  methods: Object.fromEntries(["RegisterEnum", "HasEnum", "GetEnum", "GetEnumInfo", "GetEnumName", "GetNameFromValue", "GetNameFromBitmask"].map(name => [name, [CjsSchema.impl.adapted, CjsSchema.impl.reason("Combines BlueRegistration enum storage, EnumRegistration/EnumTypeRegistration and PyBlueEnumObject exposure; JS module execution replaces static registrars, qualified names replace module tables, and JS errors replace Python exceptions.")]]))
+});
+
 export { CJS_CLASS_NAME, CJS_ENUM_NAME, CJS_MODEL_BRAND, CjsSchema };
 //# sourceMappingURL=CjsSchema.js.map