@carbonenginejs/runtime-utils 0.1.0 → 0.1.2

package/src/schema/CjsSchema.js

@@ -1,8 +1,15 @@
-const CLASS_SCHEMA = new WeakMap();
-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");
+const CLASS_SCHEMA = new WeakMap();
+
+// Exported schemas, memoized per class. SCHEMA_GENERATION is bumped by every
+// metadata definition (see getOrCreateClassSchema), which is what makes a stale
+// memo detectable without tracking which subclasses a base class change reaches.
+const SCHEMA_EXPORTS = 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");
 
 export const CJS_ENUM_NAME = Symbol.for("carbonenginejs.enum.name");
 
@@ -56,32 +63,32 @@ export class CjsSchema
         return this;
     }
 
-    static defineMethod(Constructor, methodName, namespace, value)
-    {
-        defineMethodMetadata(Constructor, methodName, namespace, value);
-        return this;
-    }
-
-    static getField(Constructor, fieldName)
-    {
-        return getEffectiveFields(Constructor).find(field => field.name === fieldName) || null;
-    }
-
-    /**
-     * Excludes named inherited fields from the decorated class's schema surface.
-     */
-    static hideInherited(fieldNames)
-    {
-        return hiddenInheritedFieldsDecorator(normalizeHiddenInheritedFields(fieldNames));
-    }
-
-    /**
-     * Checks whether a field is hidden from a class by its inheritance chain.
-     */
-    static isFieldHidden(Constructor, fieldName)
-    {
-        return getHiddenInheritedFieldNames(Constructor).has(fieldName);
-    }
+    static defineMethod(Constructor, methodName, namespace, value)
+    {
+        defineMethodMetadata(Constructor, methodName, namespace, value);
+        return this;
+    }
+
+    static getField(Constructor, fieldName)
+    {
+        return getEffectiveFields(Constructor).find(field => field.name === fieldName) || null;
+    }
+
+    /**
+     * Excludes named inherited fields from the decorated class's schema surface.
+     */
+    static hideInherited(fieldNames)
+    {
+        return hiddenInheritedFieldsDecorator(normalizeHiddenInheritedFields(fieldNames));
+    }
+
+    /**
+     * Checks whether a field is hidden from a class by its inheritance chain.
+     */
+    static isFieldHidden(Constructor, fieldName)
+    {
+        return getHiddenInheritedFieldNames(Constructor).has(fieldName);
+    }
 
     static getMethod(Constructor, methodName)
     {
@@ -128,6 +135,9 @@ export class CjsSchema
         }
 
         CONSTRUCTOR_BY_NAME.set(name.trim(), Constructor);
+        // Buckets resolve class references by name, so a late registration
+        // changes how already-built schemas should have been bucketed.
+        SCHEMA_GENERATION += 1;
         return this;
     }
 
@@ -151,49 +161,40 @@ export class CjsSchema
         return name ? ENUM_SCHEMA_BY_NAME.get(name) || null : null;
     }
 
-    static getSchema(Constructor, options = {})
-    {
-        const schema = CLASS_SCHEMA.get(Constructor);
-        const namespaces = normalizeNamespaces(options.namespaces);
-        const fields = [];
-        const methods = [];
-
-        for (const field of getEffectiveFields(Constructor))
-        {
-            fields.push(enrichEnumField(exportField(field, namespaces), Constructor));
-        }
-
-        for (const method of schema?.methods || [])
-        {
-            methods.push(exportField(method, namespaces));
-        }
-
-        const result = {
-            className: CjsSchema.getClassName(Constructor),
-            fields: Object.freeze(fields)
-        };
-
-        const family = schema?.family || CjsSchema.getClassFamily(Constructor);
-        if (family)
-        {
-            result.family = family;
-        }
-
-        if (schema?.sourceClass && schema.sourceClass !== result.className)
-        {
-            result.sourceClass = schema.sourceClass;
-        }
-
-        if (schema?.aliases?.length)
-        {
-            result.aliases = Object.freeze([...schema.aliases]);
-        }
+    /**
+     * Return the exported schema for a class.
+     *
+     * The schema is the precomputed answer - collapsing the inheritance
+     * lineage and merging metadata - so building it per call would defeat its
+     * purpose. Callers traverse model graphs and ask once per node, so this is
+     * memoized per class and rebuilt only when class metadata is defined.
+     *
+     * Namespace-filtered exports are not memoized: they are a projection of the
+     * full schema requested by tooling, not the hot read path.
+     *
+     * The result is shared, not copied - treat it as read-only. It is not
+     * frozen: deep-cloning and freezing every field on the way out cost far
+     * more than the mistakes it guarded against.
+     *
+     * @param {Function} Constructor
+     * @param {object} [options={}]
+     * @param {string|Array<string>} [options.namespaces] Restricts exported metadata namespaces.
+     * @returns {object} Shared schema export.
+     */
+    static getSchema(Constructor, options = {})
+    {
+        const namespaces = normalizeNamespaces(options.namespaces);
+        if (namespaces) return buildSchema(Constructor, namespaces);
 
-        if (methods.length) result.methods = Object.freeze(methods);
+        const memo = SCHEMA_EXPORTS.get(Constructor);
+        if (memo && memo.generation === SCHEMA_GENERATION) return memo.schema;
 
-        return Object.freeze(result);
+        const schema = buildSchema(Constructor, null);
+        SCHEMA_EXPORTS.set(Constructor, { generation: SCHEMA_GENERATION, schema });
+        return schema;
     }
 
+
     static type = Object.freeze({
         array: itemType => fieldDecorator("type", { kind: "array", itemType }),
         boolean: fieldDecorator("type", { kind: "boolean" }),
@@ -338,17 +339,17 @@ function createComponentsNamespace()
     return Object.freeze(components);
 }
 
-function fieldDecorator(namespace, value)
-{
-    return function schemaFieldDecorator(targetOrValue, contextOrFieldName)
-    {
-        if (contextOrFieldName && typeof contextOrFieldName === "object")
-        {
-            const context = contextOrFieldName;
-            if (context.kind !== "field") throw new TypeError("CjsSchema decorators only support class fields.");
-            recordStage3FieldMetadata(context, namespace, value);
-
-            // Register field metadata on instance construction. addInitializer covers
+function fieldDecorator(namespace, value)
+{
+    return function schemaFieldDecorator(targetOrValue, contextOrFieldName)
+    {
+        if (contextOrFieldName && typeof contextOrFieldName === "object")
+        {
+            const context = contextOrFieldName;
+            if (context.kind !== "field") throw new TypeError("CjsSchema decorators only support class fields.");
+            recordStage3FieldMetadata(context, namespace, value);
+
+            // Register field metadata on instance construction. addInitializer covers
             // spec-compliant runtimes; the returned field initializer covers runtimes (e.g.
             // Deno/SWC) that do NOT fire field-decorator addInitializer. Both register the same
             // metadata (idempotent via mergeNamespace), so whichever the runtime honours, the
@@ -376,44 +377,44 @@ function fieldDecorator(namespace, value)
     };
 }
 
-function classDefinitionDecorator(definition)
-{
-    return function schemaClassDefinitionDecorator(value, context)
-    {
-        if (context && typeof context === "object")
-        {
-            if (context.kind !== "class") throw new TypeError("CjsSchema type.define only supports classes.");
-            registerStage3FieldMetadata(value, context.metadata);
-            defineClassMetadata(value, normalizeClassDefinition(value, definition));
-            return;
-        }
+function classDefinitionDecorator(definition)
+{
+    return function schemaClassDefinitionDecorator(value, context)
+    {
+        if (context && typeof context === "object")
+        {
+            if (context.kind !== "class") throw new TypeError("CjsSchema type.define only supports classes.");
+            registerStage3FieldMetadata(value, context.metadata);
+            defineClassMetadata(value, normalizeClassDefinition(value, definition));
+            return;
+        }
 
         if (typeof value !== "function")
         {
             throw new TypeError("CjsSchema type.define requires a class constructor.");
         }
 
-        defineClassMetadata(value, normalizeClassDefinition(value, definition));
-    };
-}
-
-function hiddenInheritedFieldsDecorator(fieldNames)
-{
-    return function schemaHiddenInheritedFieldsDecorator(value, context)
-    {
-        if (context && typeof context === "object")
-        {
-            if (context.kind !== "class") throw new TypeError("CjsSchema.hideInherited only supports classes.");
-            registerStage3FieldMetadata(value, context.metadata);
-        }
-        else if (typeof value !== "function")
-        {
-            throw new TypeError("CjsSchema.hideInherited requires a class constructor.");
-        }
-
-        defineHiddenInheritedFields(value, fieldNames);
-    };
-}
+        defineClassMetadata(value, normalizeClassDefinition(value, definition));
+    };
+}
+
+function hiddenInheritedFieldsDecorator(fieldNames)
+{
+    return function schemaHiddenInheritedFieldsDecorator(value, context)
+    {
+        if (context && typeof context === "object")
+        {
+            if (context.kind !== "class") throw new TypeError("CjsSchema.hideInherited only supports classes.");
+            registerStage3FieldMetadata(value, context.metadata);
+        }
+        else if (typeof value !== "function")
+        {
+            throw new TypeError("CjsSchema.hideInherited requires a class constructor.");
+        }
+
+        defineHiddenInheritedFields(value, fieldNames);
+    };
+}
 
 const CONTEXT_FIRST_PARAMETER = /^\(?\s*_?(context|updateContext)\b/;
 
@@ -523,10 +524,10 @@ function defineMethodMetadata(Constructor, methodName, namespace, value)
     defineMemberMetadata(Constructor, "methods", "methodsByName", methodName, namespace, value);
 }
 
-function defineMemberMetadata(Constructor, listKey, mapKey, name, namespace, value)
-{
-    const schema = getOrCreateClassSchema(Constructor);
-    let item = schema[mapKey].get(name);
+function defineMemberMetadata(Constructor, listKey, mapKey, name, namespace, value)
+{
+    const schema = getOrCreateClassSchema(Constructor);
+    let item = schema[mapKey].get(name);
 
     if (!item)
     {
@@ -534,188 +535,307 @@ function defineMemberMetadata(Constructor, listKey, mapKey, name, namespace, val
         schema[listKey].push(item);
         schema[mapKey].set(name, item);
     }
-
-    item[namespace] = mergeNamespace(item[namespace], value);
-}
-
-function defineHiddenInheritedFields(Constructor, fieldNames)
-{
-    if (typeof Constructor !== "function")
-    {
-        throw new TypeError("CjsSchema.hideInherited requires a class constructor.");
-    }
-
-    const Parent = Object.getPrototypeOf(Constructor);
-    const inheritedFields = new Set(getEffectiveFields(Parent).map(field => field.name));
-    const className = CLASS_SCHEMA.get(Constructor)?.className || Constructor.name || "<anonymous>";
-
-    for (const fieldName of fieldNames)
-    {
-        if (!inheritedFields.has(fieldName))
-        {
-            throw new TypeError(
-                `CjsSchema.hideInherited cannot hide "${fieldName}" on ${className}: ` +
-                "the parent schema does not expose that field."
-            );
-        }
-    }
-
-    const schema = getOrCreateClassSchema(Constructor);
-    for (const fieldName of fieldNames)
-    {
-        schema.hiddenInherited.add(fieldName);
-    }
-}
-
-function getEffectiveFields(Constructor)
-{
-    const ordered = [];
-    const byName = new Map();
-    const hidden = new Set();
-
-    for (const current of getSchemaLineage(Constructor))
-    {
-        const schema = CLASS_SCHEMA.get(current);
-        for (const field of schema?.fields || [])
-        {
-            const existing = byName.get(field.name);
-            if (existing)
-            {
-                mergeMemberMetadata(existing, field);
-            }
-            else
-            {
-                const merged = mergeMemberMetadata({ name: field.name }, field);
-                ordered.push(merged);
-                byName.set(field.name, merged);
-            }
-        }
-
-        for (const fieldName of schema?.hiddenInherited || [])
-        {
-            hidden.add(fieldName);
-        }
-    }
-
-    return ordered.filter(field => !hidden.has(field.name));
-}
-
-function getHiddenInheritedFieldNames(Constructor)
-{
-    const hidden = new Set();
-    for (const current of getSchemaLineage(Constructor))
-    {
-        for (const fieldName of CLASS_SCHEMA.get(current)?.hiddenInherited || [])
-        {
-            hidden.add(fieldName);
-        }
-    }
-    return hidden;
-}
-
-function getSchemaLineage(Constructor)
-{
-    const lineage = [];
-    let current = Constructor;
-    while (typeof current === "function")
-    {
-        if (CLASS_SCHEMA.has(current)) lineage.push(current);
-        current = Object.getPrototypeOf(current);
-    }
-    return lineage.reverse();
-}
-
-function mergeMemberMetadata(target, source)
-{
-    for (const [namespace, value] of Object.entries(source))
-    {
-        if (namespace === "name") continue;
-        target[namespace] = mergeNamespace(target[namespace], value);
-    }
-    return target;
-}
-
-function getOrCreateClassSchema(Constructor)
-{
-    let schema = CLASS_SCHEMA.get(Constructor);
-    if (!schema)
+
+    item[namespace] = mergeNamespace(item[namespace], value);
+}
+
+function defineHiddenInheritedFields(Constructor, fieldNames)
+{
+    if (typeof Constructor !== "function")
+    {
+        throw new TypeError("CjsSchema.hideInherited requires a class constructor.");
+    }
+
+    const Parent = Object.getPrototypeOf(Constructor);
+    const inheritedFields = new Set(getEffectiveFields(Parent).map(field => field.name));
+    // Declared name only: Constructor.name does not survive minification, and a
+    // mangled name in an error reads as a real one and sends you chasing it.
+    const className = CLASS_SCHEMA.get(Constructor)?.className || "<undeclared>";
+
+    for (const fieldName of fieldNames)
+    {
+        if (!inheritedFields.has(fieldName))
+        {
+            throw new TypeError(
+                `CjsSchema.hideInherited cannot hide "${fieldName}" on ${className}: ` +
+                "the parent schema does not expose that field."
+            );
+        }
+    }
+
+    const schema = getOrCreateClassSchema(Constructor);
+    for (const fieldName of fieldNames)
+    {
+        schema.hiddenInherited.add(fieldName);
+    }
+}
+
+function getEffectiveFields(Constructor)
+{
+    const ordered = [];
+    const byName = new Map();
+    const hidden = new Set();
+
+    for (const current of getSchemaLineage(Constructor))
+    {
+        const schema = CLASS_SCHEMA.get(current);
+        for (const field of schema?.fields || [])
+        {
+            const existing = byName.get(field.name);
+            if (existing)
+            {
+                mergeMemberMetadata(existing, field);
+            }
+            else
+            {
+                const merged = mergeMemberMetadata({ name: field.name }, field);
+                ordered.push(merged);
+                byName.set(field.name, merged);
+            }
+        }
+
+        for (const fieldName of schema?.hiddenInherited || [])
+        {
+            hidden.add(fieldName);
+        }
+    }
+
+    return ordered.filter(field => !hidden.has(field.name));
+}
+
+function getHiddenInheritedFieldNames(Constructor)
+{
+    const hidden = new Set();
+    for (const current of getSchemaLineage(Constructor))
+    {
+        for (const fieldName of CLASS_SCHEMA.get(current)?.hiddenInherited || [])
+        {
+            hidden.add(fieldName);
+        }
+    }
+    return hidden;
+}
+
+function getSchemaLineage(Constructor)
+{
+    const lineage = [];
+    let current = Constructor;
+    while (typeof current === "function")
+    {
+        if (CLASS_SCHEMA.has(current)) lineage.push(current);
+        current = Object.getPrototypeOf(current);
+    }
+    return lineage.reverse();
+}
+
+function mergeMemberMetadata(target, source)
+{
+    for (const [namespace, value] of Object.entries(source))
+    {
+        if (namespace === "name") continue;
+        target[namespace] = mergeNamespace(target[namespace], value);
+    }
+    return target;
+}
+
+function buildSchema(Constructor, namespaces)
+{
+    const schema = CLASS_SCHEMA.get(Constructor);
+    const fields = [];
+    const methods = [];
+
+    for (const field of getEffectiveFields(Constructor))
+    {
+        fields.push(enrichEnumField(exportField(field, namespaces), Constructor));
+    }
+
+    for (const method of schema?.methods || [])
+    {
+        methods.push(exportField(method, namespaces));
+    }
+
+    const result = {
+        className: CjsSchema.getClassName(Constructor),
+        fields
+    };
+
+    const family = schema?.family || CjsSchema.getClassFamily(Constructor);
+    if (family)
+    {
+        result.family = family;
+    }
+
+    if (schema?.sourceClass && schema.sourceClass !== result.className)
+    {
+        result.sourceClass = schema.sourceClass;
+    }
+
+    if (schema?.aliases?.length)
+    {
+        result.aliases = [ ...schema.aliases ];
+    }
+
+    if (methods.length) result.methods = methods;
+
+    addSchemaBuckets(result);
+    return result;
+}
+
+
+// Kinds that hold many values rather than one. `map` and `set` are included
+// because they are iterable collections of the referenced class, same as a list.
+const MANY_KINDS = new Set([ "list", "array", "set", "map" ]);
+
+// Kinds that can hold a child model. Bucketing on the KIND rather than on a
+// resolvable class reference keeps traversal conservative: `type.struct(Class)`
+// drops the reference during normalization, and a raw defineField may omit the
+// item type, so requiring a reference would silently stop visiting those.
+// Scalar and math kinds are excluded, which is where the saving comes from.
+const MODEL_KINDS = new Set([
+    "struct", "model", "rawStruct", "objectRef", "unknown",
+    "list", "array", "set", "map"
+]);
+
+
+/**
+ * Precompute the answers consumers would otherwise recompute per traversal.
+ *
+ * Graph walks ask the same two questions of every node - which fields hold
+ * child models, which hold resources - and answering them by scanning the field
+ * list and type-testing each value costs more than the walk itself. The class
+ * cannot change without rebuilding its schema, so this is solved once.
+ */
+function addSchemaBuckets(schema)
+{
+    const byName = new Map();
+    const children = [];
+    const resources = [];
+
+    for (const field of schema.fields)
+    {
+        byName.set(field.name, field);
+
+        const type = field.type;
+        // An undeclared field could hold anything, so it stays traversable.
+        const kind = type?.kind;
+        if (kind && !MODEL_KINDS.has(kind)) continue;
+
+        const entry = { name: field.name, many: MANY_KINDS.has(kind) };
+
+        if (type && resolveFieldClass(type)?.isResource === true)
+        {
+            resources.push(entry);
+            continue;
+        }
+
+        entry.owned = field.io?.ownership === "owned";
+        children.push(entry);
+    }
+
+    schema.byName = byName;
+    schema.children = children;
+    schema.resources = resources;
+}
+
+
+// Only string references survive normalization - type.struct(SomeClass) drops
+// the reference entirely - so a field can only be bucketed when it names a
+// class. The one field in the tree that named nothing was a missing
+// declaration, not a deliberate escape.
+function resolveFieldClass(type)
+{
+    const ref = type.className || type.itemType || type.valueType;
+    return typeof ref === "string" && ref ? CONSTRUCTOR_BY_NAME.get(ref) || null : null;
+}
+
+
+function getOrCreateClassSchema(Constructor)
+{
+    // The only route by which class metadata is mutated, and therefore the only
+    // place exported schemas can go stale. A single global counter rather than
+    // per-class invalidation because a base class change invalidates every
+    // subclass, and lineage is not tracked in reverse.
+    SCHEMA_GENERATION += 1;
+
+    let schema = CLASS_SCHEMA.get(Constructor);
+    if (!schema)
     {
         schema = {
             className: null,
             family: null,
             sourceClass: null,
-            aliases: null,
-            fields: [],
-            fieldsByName: new Map(),
-            hiddenInherited: new Set(),
-            methods: [],
-            methodsByName: new Map()
-        };
+            aliases: null,
+            fields: [],
+            fieldsByName: new Map(),
+            hiddenInherited: new Set(),
+            methods: [],
+            methodsByName: new Map()
+        };
         CLASS_SCHEMA.set(Constructor, schema);
     }
-    return schema;
-}
-
-function normalizeHiddenInheritedFields(fieldNames)
-{
-    if (!Array.isArray(fieldNames) || !fieldNames.length)
-    {
-        throw new TypeError("CjsSchema.hideInherited requires a non-empty array of field names.");
-    }
-
-    const normalized = fieldNames.map((fieldName, index) =>
-    {
-        if (typeof fieldName !== "string" || !fieldName.trim())
-        {
-            throw new TypeError(`CjsSchema.hideInherited fieldNames[${index}] must be a non-empty string.`);
-        }
-        return fieldName.trim();
-    });
-
-    return Object.freeze([...new Set(normalized)]);
-}
-
-function recordStage3FieldMetadata(context, namespace, value)
-{
-    const metadata = context?.metadata;
-    if (!metadata || typeof metadata !== "object") return;
-
-    let fields;
-    if (Object.prototype.hasOwnProperty.call(metadata, STAGE3_FIELD_METADATA))
-    {
-        fields = metadata[STAGE3_FIELD_METADATA];
-    }
-    else
-    {
-        fields = [];
-        Object.defineProperty(metadata, STAGE3_FIELD_METADATA, {
-            configurable: false,
-            enumerable: false,
-            value: fields,
-            writable: false
-        });
-    }
-
-    fields.push({
-        name: context.name,
-        namespace,
-        value
-    });
-}
-
-function registerStage3FieldMetadata(Constructor, metadata)
-{
-    if (!metadata || typeof metadata !== "object") return;
-    if (!Object.prototype.hasOwnProperty.call(metadata, STAGE3_FIELD_METADATA)) return;
-
-    for (const field of metadata[STAGE3_FIELD_METADATA])
-    {
-        defineFieldMetadata(Constructor, field.name, field.namespace, field.value);
-    }
-}
-
-function normalizeClassDefinition(Constructor, definition)
-{
+    return schema;
+}
+
+function normalizeHiddenInheritedFields(fieldNames)
+{
+    if (!Array.isArray(fieldNames) || !fieldNames.length)
+    {
+        throw new TypeError("CjsSchema.hideInherited requires a non-empty array of field names.");
+    }
+
+    const normalized = fieldNames.map((fieldName, index) =>
+    {
+        if (typeof fieldName !== "string" || !fieldName.trim())
+        {
+            throw new TypeError(`CjsSchema.hideInherited fieldNames[${index}] must be a non-empty string.`);
+        }
+        return fieldName.trim();
+    });
+
+    return Object.freeze([...new Set(normalized)]);
+}
+
+function recordStage3FieldMetadata(context, namespace, value)
+{
+    const metadata = context?.metadata;
+    if (!metadata || typeof metadata !== "object") return;
+
+    let fields;
+    if (Object.prototype.hasOwnProperty.call(metadata, STAGE3_FIELD_METADATA))
+    {
+        fields = metadata[STAGE3_FIELD_METADATA];
+    }
+    else
+    {
+        fields = [];
+        Object.defineProperty(metadata, STAGE3_FIELD_METADATA, {
+            configurable: false,
+            enumerable: false,
+            value: fields,
+            writable: false
+        });
+    }
+
+    fields.push({
+        name: context.name,
+        namespace,
+        value
+    });
+}
+
+function registerStage3FieldMetadata(Constructor, metadata)
+{
+    if (!metadata || typeof metadata !== "object") return;
+    if (!Object.prototype.hasOwnProperty.call(metadata, STAGE3_FIELD_METADATA)) return;
+
+    for (const field of metadata[STAGE3_FIELD_METADATA])
+    {
+        defineFieldMetadata(Constructor, field.name, field.namespace, field.value);
+    }
+}
+
+function normalizeClassDefinition(Constructor, definition)
+{
     if (typeof definition === "string")
     {
         definition = { className: definition };
@@ -937,9 +1057,8 @@ function componentIndex(char)
 
 function mergeNamespace(existing, value)
 {
-    if (!existing) return cloneSchemaValue(value);
-    if (isPlainObject(existing) && isPlainObject(value)) return Object.freeze({ ...existing, ...value });
-    return cloneSchemaValue(value);
+    if (isPlainObject(existing) && isPlainObject(value)) return { ...existing, ...value };
+    return value;
 }
 
 // Resolves @schema.enum("X") through the owning class's PascalCase static so
@@ -984,10 +1103,10 @@ function exportField(field, namespaces)
     {
         if (key === "name") continue;
         if (namespaces && !namespaces.has(key)) continue;
-        result[key] = cloneSchemaValue(value);
+        result[key] = value;
     }
 
-    return Object.freeze(result);
+    return result;
 }
 
 function normalizeNamespaces(namespaces)