@decaf-ts/decoration 0.0.16 → 0.0.17

package/lib/esm/metadata/Metadata.js

@@ -229,10 +229,18 @@ export class Metadata {
     static get(model, key) {
         if (key === DecorationKeys.CONSTRUCTOR)
             return this.constr(model);
-        if (key !== DecorationKeys.CONSTRUCTOR)
-            model = this.constr(model) || model;
-        const symbol = Symbol.for(model.toString());
-        return this.innerGet(symbol, key);
+        const resolvedModel = this.constr(model) || model;
+        const constructors = this.collectConstructorChain(resolvedModel);
+        if (constructors.length === 0) {
+            const fallbackSymbol = Symbol.for(resolvedModel.toString());
+            return this.innerGet(fallbackSymbol, key);
+        }
+        const collectedValues = constructors
+            .map((ctor) => this.innerGet(Symbol.for(ctor.toString()), key))
+            .filter((value) => value !== undefined);
+        if (collectedValues.length === 0)
+            return undefined;
+        return this.mergeMetadataChain(collectedValues);
     }
     /**
      * @description Retrieves metadata stored under a symbol key.
@@ -250,6 +258,96 @@ export class Metadata {
             return getValueBySplitter(this._metadata[symbol], key, this.splitter);
         return this._metadata[symbol][key];
     }
+    /**
+     * @description Builds the inheritance chain for a constructor, ordered from base to most-specific class.
+     * @summary Walks the prototype chain starting from the provided constructor until reaching Function/Object and returns the collected constructors.
+     * @param {Constructor} model Constructor whose chain should be collected.
+     * @return {Constructor[]} Array of constructors ordered from base to leaf.
+     */
+    static collectConstructorChain(model) {
+        const chain = [];
+        let current = model;
+        while (typeof current === "function" && current !== Function) {
+            chain.push(current);
+            const parent = Object.getPrototypeOf(current);
+            if (!parent || parent === Function || parent === Object)
+                break;
+            current = parent;
+        }
+        return chain.reverse();
+    }
+    /**
+     * @description Merges metadata values collected across the inheritance chain.
+     * @summary Performs a deep merge for plain objects while letting non-object values override earlier ones to preserve child metadata precedence.
+     * @param {any[]} values Metadata values gathered from base to child.
+     * @return {any} Aggregated metadata value respecting inheritance precedence.
+     */
+    static mergeMetadataChain(values) {
+        let acc = undefined;
+        for (const value of values) {
+            if (acc === undefined) {
+                acc = this.cloneMetadataValue(value);
+                continue;
+            }
+            if (this.isPlainObject(acc) && this.isPlainObject(value)) {
+                acc = this.mergePlainObjects(acc, value);
+                continue;
+            }
+            acc = this.cloneMetadataValue(value);
+        }
+        return acc;
+    }
+    /**
+     * @description Produces a deep clone of a metadata value when necessary.
+     * @summary Arrays are shallow-cloned, plain objects are deep-cloned, and primitive/function values are returned as-is.
+     * @param {any} value Metadata value to clone.
+     * @return {any} Cloned metadata value preventing mutation of the backing store.
+     */
+    static cloneMetadataValue(value) {
+        if (Array.isArray(value))
+            return [...value];
+        if (this.isPlainObject(value))
+            return this.mergePlainObjects({}, value);
+        return value;
+    }
+    /**
+     * @description Deeply merges two plain metadata objects.
+     * @summary Recursively merges nested plain objects while cloning arrays; values from `source` override those from `target` when conflicts occur.
+     * @param {Record<string, any>} target Base object to merge into.
+     * @param {Record<string, any>} source Object providing overriding metadata.
+     * @return {Record<string, any>} Newly merged metadata object.
+     */
+    static mergePlainObjects(target, source) {
+        const result = { ...target };
+        for (const key of Object.keys(source)) {
+            const sourceValue = source[key];
+            const targetValue = result[key];
+            if (this.isPlainObject(sourceValue)) {
+                result[key] = this.isPlainObject(targetValue)
+                    ? this.mergePlainObjects(targetValue, sourceValue)
+                    : this.mergePlainObjects({}, sourceValue);
+                continue;
+            }
+            if (Array.isArray(sourceValue)) {
+                result[key] = [...sourceValue];
+                continue;
+            }
+            result[key] = sourceValue;
+        }
+        return result;
+    }
+    /**
+     * @description Checks if a value is a plain object suitable for deep merging.
+     * @summary Ensures arrays and null are excluded while accepting objects created via literal/class syntax.
+     * @param {any} value Value to inspect.
+     * @return {boolean} True when the value is a plain object.
+     */
+    static isPlainObject(value) {
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            return false;
+        const proto = Object.getPrototypeOf(value);
+        return proto === Object.prototype || proto === null;
+    }
     /**
      * @description Writes metadata under a symbol key.
      * @summary Internal helper that ensures the metadata bucket exists for the provided symbol and persists the given value, drilling into nested structures when the key is a string path.
@@ -333,4 +431,4 @@ export class Metadata {
         return strs.join(this.splitter);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Metadata.js","sourceRoot":"","sources":["../../../src/metadata/Metadata.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,0BAAqB;AACjE,OAAO,kBAAkB,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,kBAAkB,CAChC,GAAwB,EACxB,IAAY,EACZ,WAAmB,iBAAiB;IAEpC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAClC,IAAI,OAAO,GAAG,GAAG,CAAC;IAElB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IACE,OAAO,KAAK,IAAI;YAChB,OAAO,KAAK,SAAS;YACrB,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC;YAEnD,OAAO,SAAS,CAAC;QACnB,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,kBAAkB,CAChC,GAAwB,EACxB,IAAY,EACZ,KAAU,EACV,QAAQ,GAAG,iBAAiB;IAE5B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC9D,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAE9B,IAAI,OAAO,GAAqB,GAAG,CAAC;IAEpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,IACE,OAAO,CAAC,GAAG,CAAC,KAAK,SAAS;YAC1B,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI;YACrB,OAAO,OAAO,CAAC,GAAG,CAAC,KAAK,QAAQ,EAChC,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;QACpB,CAAC;QACD,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAED,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACtC,OAAO,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,QAAQ;IACnB;;;OAGG;aACY,cAAS,GAAwB,EAAE,CAAC;IAEnD;;;OAGG;aACI,aAAQ,GAAG,iBAAiB,CAAC;IACpC;;;OAGG;aACI,YAAO,GAAG,cAAc,CAAC,OAAO,CAAC;IACxC;;;OAGG;aACI,WAAM,GAAY,IAAI,CAAC;IAE9B,gBAAuB,CAAC;IAExB;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,KAAkB;QAClC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC7B,IAAI,CAAC,IAAI;YAAE,OAAO,SAAS,CAAC;QAC5B,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACtC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAAC,KAAkB;QAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;QACrD,IAAI,CAAC,IAAI;YAAE,OAAO,SAAS,CAAC;QAC5B,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,WAAW,CAChB,KAAqB,EACrB,IAAc;QAEd,OAAO,IAAI,CAAC,GAAG,CACb,KAAK,EACL,CAAC,cAAc,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,IAAI,CACnE,IAAI,CAAC,QAAQ,CACd,CACF,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,CAAI,KAAqB,EAAE,IAAY;QAClD,OAAO,IAAI,CAAC,GAAG,CACb,KAAK,EACL,CAAC,cAAc,CAAC,OAAO,EAAE,IAAI,EAAE,cAAc,CAAC,aAAa,CAAC,CAAC,IAAI,CAC/D,IAAI,CAAC,QAAQ,CACd,CACF,CAAC;IACJ,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,KAAK,CACV,KAAqB,EACrB,IAAY,EACZ,KAAa;QAEb,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACxC,IAAI,CAAC,MAAM;YAAE,OAAO,SAAS,CAAC;QAC9B,IAAI,KAAK,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC;YAC3B,MAAM,IAAI,KAAK,CACb,mBAAmB,KAAK,qBAAqB,MAAM,CAAC,IAAI,CAAC,EAAE,CAC5D,CAAC;QACJ,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,CAAI,KAAqB,EAAE,IAAY;QAClD,OAAO,IAAI,CAAC,GAAG,CACb,KAAK,EACL,CAAC,cAAc,CAAC,OAAO,EAAE,IAAI,EAAE,cAAc,CAAC,aAAa,CAAC,CAAC,IAAI,CAC/D,IAAI,CAAC,QAAQ,CACd,CACF,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CAAC,KAAkB,EAAE,IAAY;QAC1C,OAAO,IAAI,CAAC,GAAG,CACb,KAAK,EACL,CAAC,cAAc,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CACtD,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CAAI,KAAqB;QACpC,OAAO,KAAK,CAAC,cAAc,CAAC,WAAiC,CAEhD,CAAC;IAChB,CAAC;IAuBD;;;;;;;;OAQG;IACH,MAAM,CAAC,GAAG,CAAC,KAAkB,EAAE,GAAY;QACzC,IAAI,GAAG,KAAK,cAAc,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAClE,IAAI,GAAG,KAAK,cAAc,CAAC,WAAW;YAAE,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC;QAC5E,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC5C,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;OAMG;IACK,MAAM,CAAC,QAAQ,CAAC,MAAc,EAAE,GAAqB;QAC3D,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;YAAE,OAAO,SAAS,CAAC;QAC9C,IAAI,CAAC,GAAG;YAAE,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACxC,IAAI,OAAO,GAAG,KAAK,QAAQ;YACzB,OAAO,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACxE,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;;OAOG;IACK,MAAM,CAAC,QAAQ,CAAC,MAAc,EAAE,GAAoB,EAAE,KAAU;QACtE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;YAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAS,CAAC;QAChE,IAAI,OAAO,GAAG,KAAK,QAAQ;YACzB,OAAO,kBAAkB,CACvB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EACtB,GAAG,EACH,KAAK,EACL,IAAI,CAAC,QAAQ,CACd,CAAC;QACJ,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IACtC,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,GAAG,CAAC,KAA2B,EAAE,GAAW,EAAE,KAAU;QAC7D,IAAI,GAAG,KAAK,cAAc,CAAC,WAAW,EAAE,CAAC;YACvC,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,cAAc,CAAC,WAAW,EAAE;gBACvD,UAAU,EAAE,KAAK;gBACjB,YAAY,EAAE,KAAK;gBACnB,QAAQ,EAAE,KAAK;gBACf,KAAK,EAAE,KAAK;aACb,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QACD,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC;QACnE,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC5C,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;QAClC,IACE,OAAO,KAAK,KAAK,QAAQ;YACzB,QAAQ,CAAC,MAAM;YACf,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,EAC1D,CAAC;YACD,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE;gBACzC,UAAU,EAAE,KAAK;gBACjB,YAAY,EAAE,KAAK;gBACnB,QAAQ,EAAE,KAAK;gBACf,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;aAC9B,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,eAAe,CAAC,OAAe,EAAE,OAAe;QACrD,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QACpD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC3C,IAAI,GAAG;YACL,MAAM,IAAI,KAAK,CACb,mBAAmB,OAAO,4BAA4B,OAAO,EAAE,CAChE,CAAC;QACJ,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,SAAS;QACd,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACrC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,GAAG,CAAC,GAAG,IAAc;QAC1B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC","sourcesContent":["import { BasicMetadata, Constructor } from \"./types\";\nimport { DecorationKeys, ObjectKeySplitter } from \"../constants\";\nimport \"reflect-metadata\";\n\n/**\n * @description Retrieves a nested value from an object given a path.\n * @summary Walks an object structure using a splitter-delimited path and returns the value at that location or `undefined` if any key is missing.\n * @param {Record<string, any>} obj Object to traverse for the lookup.\n * @param {string} path Splitter-delimited path to the desired value (e.g., \"a.b.c\").\n * @param {string} [splitter=ObjectKeySplitter] Delimiter used to separate the path segments.\n * @return {any|undefined} Value resolved at the given path or `undefined` when not found.\n * @function getValueBySplitter\n * @mermaid\n * sequenceDiagram\n *   participant C as Caller\n *   participant F as getValueBySplitter\n *   participant O as Object\n *   C->>F: (obj, path, splitter)\n *   F->>F: split path into keys\n *   loop for each key\n *     F->>O: access current[key]\n *     alt missing or nullish\n *       F-->>C: return undefined\n *     end\n *   end\n *   F-->>C: return final value\n * @memberOf module:decoration\n */\nexport function getValueBySplitter(\n  obj: Record<string, any>,\n  path: string,\n  splitter: string = ObjectKeySplitter\n): any {\n  const keys = path.split(splitter);\n  let current = obj;\n\n  for (const key of keys) {\n    if (\n      current === null ||\n      current === undefined ||\n      !Object.prototype.hasOwnProperty.call(current, key)\n    )\n      return undefined;\n    current = current[key];\n  }\n\n  return current;\n}\n\n/**\n * @description Sets a nested value on an object given a path.\n * @summary Traverses or creates intermediate objects following a splitter-delimited path and assigns the provided value at the destination key.\n * @param {Record<string, any>} obj Object to mutate while drilling into nested keys.\n * @param {string} path Splitter-delimited destination path (e.g., \"a.b.c\").\n * @param {any} value Value to set at the destination node.\n * @param {string} [splitter=ObjectKeySplitter] Delimiter used to separate the path segments.\n * @return {void}\n * @function setValueBySplitter\n * @mermaid\n * sequenceDiagram\n *   participant C as Caller\n *   participant F as setValueBySplitter\n *   participant O as Object\n *   C->>F: (obj, path, value, splitter)\n *   F->>F: split path into keys\n *   loop for each key\n *     alt key missing\n *       F->>O: create intermediate object\n *     else key exists\n *       F->>O: descend into existing object\n *     end\n *   end\n *   F-->>C: void\n * @memberOf module:decoration\n */\nexport function setValueBySplitter(\n  obj: Record<string, any>,\n  path: string,\n  value: any,\n  splitter = ObjectKeySplitter\n): void {\n  const keys = path.split(splitter).filter((k) => k.length > 0);\n  if (keys.length === 0) return;\n\n  let current: Record<any, any> = obj;\n\n  for (let i = 0; i < keys.length - 1; i++) {\n    const key = keys[i];\n    if (\n      current[key] === undefined ||\n      current[key] === null ||\n      typeof current[key] !== \"object\"\n    ) {\n      current[key] = {};\n    }\n    current = current[key];\n  }\n\n  const lastKey = keys[keys.length - 1];\n  current[lastKey] = value;\n}\n\n/**\n * @description Centralized runtime metadata store bound to constructors.\n * @summary Provides utilities to read and write structured metadata for classes and their members, with optional mirroring onto the constructor via a well-known symbol key. Supports nested key paths using a configurable splitter and offers both instance and static APIs.\n * @template M The model type the metadata belongs to.\n * @template META Extends BasicMetadata<M> representing the metadata structure.\n * @param {string} [flavour=DefaultFlavour] Optional flavour identifier applied when instantiating helper builders.\n * @class\n * @example\n * // Define and read metadata for a class\n * class User { name!: string }\n * Metadata.set(User, \"description.class\", \"A user model\");\n * Metadata.set(User, \"properties.name\", String);\n * const desc = Metadata.get(User, \"description.class\"); // \"A user model\"\n * const type = Metadata.type(User, \"name\"); // String\n * @mermaid\n * sequenceDiagram\n *   participant C as Constructor\n *   participant S as Metadata (static)\n *   C->>S: set(User, \"properties.name\", String)\n *   C->>S: get(User, \"properties.name\")\n *   S-->>C: String\n */\nexport class Metadata {\n  /**\n   * @description In-memory storage of metadata by constructor symbol\n   * @summary Maps a Symbol derived from the constructor to its metadata object, enabling efficient lookup.\n   */\n  private static _metadata: Record<symbol, any> = {};\n\n  /**\n   * @description Path delimiter for nested metadata keys\n   * @summary Used by get/set operations to navigate nested structures, defaults to ObjectKeySplitter.\n   */\n  static splitter = ObjectKeySplitter;\n  /**\n   * @description Symbol key used to mirror metadata on the constructor\n   * @summary When mirroring is enabled, the metadata object is defined on the constructor under this non-enumerable key.\n   */\n  static baseKey = DecorationKeys.REFLECT;\n  /**\n   * @description Controls whether metadata is mirrored onto the constructor\n   * @summary When true, the metadata object is defined on the constructor under the non-enumerable baseKey.\n   */\n  static mirror: boolean = true;\n\n  private constructor() {}\n\n  /**\n   * @description Lists known property keys for a model.\n   * @summary Reads the metadata entry and returns the names of properties that have recorded type information.\n   * @param {Constructor} model Target constructor whose property metadata should be inspected.\n   * @return {string[]|undefined} Array of property names or `undefined` if no metadata exists.\n   */\n  static properties(model: Constructor): string[] | undefined {\n    const meta = this.get(model);\n    if (!meta) return undefined;\n    return Object.keys(meta.properties);\n  }\n\n  /**\n   * @description Lists known methods for a model.\n   * @summary Reads the metadata entry and returns the method names that have recorded signature metadata for the provided constructor.\n   * @param {Constructor} model Target constructor whose method metadata should be inspected.\n   * @return {string[]|undefined} Array of method names or `undefined` if no metadata exists.\n   */\n  static methods(model: Constructor): string[] | undefined {\n    const meta = this.get(model, DecorationKeys.METHODS);\n    if (!meta) return undefined;\n    return Object.keys(meta);\n  }\n\n  /**\n   * @description Retrieves a human-readable description for a class or a property.\n   * @summary Looks up the description stored under the metadata \"description\" map. If a property key is provided, returns the property's description; otherwise returns the class description.\n   * @template M\n   * @param {Constructor<M>} model Target constructor whose description is being retrieved.\n   * @param {string} [prop] Optional property key (typed as `keyof M`) for which to fetch the description.\n   * @return {string|undefined} Description text if present, otherwise `undefined`.\n   */\n  static description<M>(\n    model: Constructor<M>,\n    prop?: keyof M\n  ): string | undefined {\n    return this.get(\n      model,\n      [DecorationKeys.DESCRIPTION, prop ? prop : DecorationKeys.CLASS].join(\n        this.splitter\n      )\n    );\n  }\n\n  /**\n   * @description Retrieves the recorded params for a method.\n   * @summary Reads the metadata entry under `methods.<prop>.design:paramtypes` to return the parameter constructors for the given method.\n   * @template M\n   * @param {Constructor<M>} model Target constructor owning the method metadata.\n   * @param {string} prop Method name whose parameters should be fetched.\n   * @return {any[]|undefined} Array of constructor references describing each parameter or `undefined` when not available.\n   */\n  static params<M>(model: Constructor<M>, prop: string): any[] | undefined {\n    return this.get(\n      model,\n      [DecorationKeys.METHODS, prop, DecorationKeys.DESIGN_PARAMS].join(\n        this.splitter\n      )\n    );\n  }\n\n  /**\n   * @description Retrieves a single recorded parameter type for a method.\n   * @summary Looks up the parameter metadata for the provided index, enforcing bounds and returning the constructor reference for that argument.\n   * @template M\n   * @param {Constructor<M>} model Target constructor owning the method metadata.\n   * @param {string} prop Method name whose parameter should be returned.\n   * @param {number} index Zero-based index of the desired parameter metadata.\n   * @return {any|undefined} Constructor reference for the parameter or `undefined` if not recorded.\n   */\n  static param<M>(\n    model: Constructor<M>,\n    prop: string,\n    index: number\n  ): any | undefined {\n    const params = this.params(model, prop);\n    if (!params) return undefined;\n    if (index > params.length - 1)\n      throw new Error(\n        `Parameter index ${index} out of range for ${String(prop)}`\n      );\n    return params[index];\n  }\n\n  /**\n   * @description Retrieves the recorded return type for a method.\n   * @summary Reads the metadata entry under `methods.<prop>.design:returntype` to return the return type for the given method.\n   * @template M\n   * @param {Constructor<M>} model Target constructor whose method metadata should be inspected.\n   * @param {string} prop Method name whose return type should be fetched.\n   * @return {any|undefined} Constructor reference for the return type or `undefined` when not available.\n   */\n  static return<M>(model: Constructor<M>, prop: string): any | undefined {\n    return this.get(\n      model,\n      [DecorationKeys.METHODS, prop, DecorationKeys.DESIGN_RETURN].join(\n        this.splitter\n      )\n    );\n  }\n\n  /**\n   * @description Retrieves the recorded design type for a property.\n   * @summary Reads the metadata entry under `properties.<prop>` to return the constructor recorded for the given property name.\n   * @param {Constructor} model Target constructor whose property metadata should be inspected.\n   * @param {string} prop Property name whose type metadata should be returned.\n   * @return {Constructor|undefined} Constructor reference for the property type or `undefined` if not available.\n   */\n  static type(model: Constructor, prop: string) {\n    return this.get(\n      model,\n      [DecorationKeys.PROPERTIES, prop].join(this.splitter)\n    );\n  }\n\n  /**\n   * @description Resolves the canonical constructor associated with the provided model handle.\n   * @summary Returns the stored constructor reference when the provided model is a proxy or reduced value. Falls back to the original model when no constructor metadata has been recorded yet.\n   * @template M\n   * @param {Constructor<M>} model Model used when recording metadata.\n   * @return {Constructor<M>|undefined} Canonical constructor if stored, otherwise `undefined`.\n   */\n  static constr<M>(model: Constructor<M>) {\n    return model[DecorationKeys.CONSTRUCTOR as keyof typeof model] as\n      | Constructor<M>\n      | undefined;\n  }\n\n  /**\n   * @description Retrieves metadata for a model or a specific key within it.\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model Target constructor used to locate the metadata record.\n   * @return {META|undefined} Metadata object, the value at the key path, or `undefined` if nothing exists.\n   */\n  static get<M, META extends BasicMetadata<M> = BasicMetadata<M>>(\n    model: Constructor<M>\n  ): META | undefined;\n  /**\n   * @description Retrieves metadata for a model or a specific key within it.\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model Target constructor used to locate the metadata record.\n   * @param {string} key Nested key path to fetch a specific value.\n   * @return {META|*|undefined} Metadata object, the value at the key path, or `undefined` if nothing exists.\n   */\n  static get(model: Constructor, key: string): any;\n  /**\n   * @description Retrieves metadata for a model or a specific key within it.\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>|string} model Target constructor used to locate the metadata record or a pre-resolved symbol identifier.\n   * @param {string} [key] Optional nested key path to fetch a specific value.\n   * @return {META|*|undefined} Metadata object, the value at the key path, or `undefined` if nothing exists.\n   */\n  static get(model: Constructor, key?: string) {\n    if (key === DecorationKeys.CONSTRUCTOR) return this.constr(model);\n    if (key !== DecorationKeys.CONSTRUCTOR) model = this.constr(model) || model;\n    const symbol = Symbol.for(model.toString());\n    return this.innerGet(symbol, key);\n  }\n\n  /**\n   * @description Retrieves metadata stored under a symbol key.\n   * @summary Internal helper that resolves and optionally drills into the in-memory metadata map for the provided symbol and key path.\n   * @param {symbol} symbol Symbol representing the metadata bucket.\n   * @param {string|symbol} [key] Optional nested key referencing a specific metadata entry.\n   * @return {any} Stored metadata object or value for the provided key, or `undefined` when absent.\n   */\n  private static innerGet(symbol: symbol, key?: string | symbol) {\n    if (!this._metadata[symbol]) return undefined;\n    if (!key) return this._metadata[symbol];\n    if (typeof key === \"string\")\n      return getValueBySplitter(this._metadata[symbol], key, this.splitter);\n    return this._metadata[symbol][key];\n  }\n\n  /**\n   * @description Writes metadata under a symbol key.\n   * @summary Internal helper that ensures the metadata bucket exists for the provided symbol and persists the given value, drilling into nested structures when the key is a string path.\n   * @param {symbol} symbol Symbol representing the metadata bucket.\n   * @param {string|symbol} key Nested key path or direct symbol under which to store the metadata value.\n   * @param {any} value Value persisted in the metadata store.\n   * @return {void}\n   */\n  private static innerSet(symbol: symbol, key: string | symbol, value: any) {\n    if (!this._metadata[symbol]) this._metadata[symbol] = {} as any;\n    if (typeof key === \"string\")\n      return setValueBySplitter(\n        this._metadata[symbol],\n        key,\n        value,\n        this.splitter\n      );\n    this._metadata[symbol][key] = value;\n  }\n\n  /**\n   * @description Writes a metadata value at a given nested key path.\n   * @summary Ensures the metadata record exists for the constructor, mirrors it on the constructor when enabled, and sets the provided value on the nested key path using the configured splitter.\n   * @template M\n   * @param {Constructor<M>|string} model Target constructor to which the metadata belongs or a direct identifier string.\n   * @param {string} key Nested key path at which to store the value.\n   * @param {any} value Value to store in the metadata.\n   * @return {void}\n   */\n  static set(model: Constructor | string, key: string, value: any): void {\n    if (key === DecorationKeys.CONSTRUCTOR) {\n      Object.defineProperty(model, DecorationKeys.CONSTRUCTOR, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: value,\n      });\n      return;\n    }\n    if (typeof model !== \"string\") model = this.constr(model) || model;\n    const symbol = Symbol.for(model.toString());\n    this.innerSet(symbol, key, value);\n    if (\n      typeof model !== \"string\" &&\n      Metadata.mirror &&\n      !Object.prototype.hasOwnProperty.call(model, this.baseKey)\n    ) {\n      Object.defineProperty(model, this.baseKey, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: this._metadata[symbol],\n      });\n    }\n  }\n\n  /**\n   * @description Registers a decoration-aware library and its version.\n   * @summary Stores the version string for an integrating library under the shared libraries metadata symbol, preventing duplicate registrations for the same library identifier.\n   * @param {string} library Package name or identifier to register.\n   * @param {string} version Semantic version string associated with the library.\n   * @return {void}\n   * @throws {Error} If the library has already been registered.\n   */\n  static registerLibrary(library: string, version: string) {\n    const symbol = Symbol.for(DecorationKeys.LIBRARIES);\n    const lib = this.innerGet(symbol, library);\n    if (lib)\n      throw new Error(\n        `Library already ${library} registered with version ${version}`\n      );\n    this.innerSet(symbol, library, version);\n  }\n\n  /**\n   * @description Lists registered decoration-aware libraries.\n   * @summary Returns the in-memory map of library identifiers to semantic versions that have been registered with the Decoration metadata store.\n   * @return {Record<string, string>} Map of registered library identifiers to their version strings.\n   */\n  static libraries(): Record<string, string> {\n    const symbol = Symbol.for(DecorationKeys.LIBRARIES);\n    return this.innerGet(symbol) || {};\n  }\n\n  /**\n   * @description Joins path segments using the current splitter.\n   * @summary Constructs a nested metadata key by concatenating string segments with the configured splitter for use with the metadata store.\n   * @param {...string} strs Key segments to join into a full metadata path.\n   * @return {string} Splitter-joined metadata key.\n   */\n  static key(...strs: string[]) {\n    return strs.join(this.splitter);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Metadata.js","sourceRoot":"","sources":["../../../src/metadata/Metadata.ts"],"names":[],"mappings":"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","sourcesContent":["import { BasicMetadata, Constructor } from \"./types\";\nimport { DecorationKeys, ObjectKeySplitter } from \"../constants\";\nimport \"reflect-metadata\";\n\n/**\n * @description Retrieves a nested value from an object given a path.\n * @summary Walks an object structure using a splitter-delimited path and returns the value at that location or `undefined` if any key is missing.\n * @param {Record<string, any>} obj Object to traverse for the lookup.\n * @param {string} path Splitter-delimited path to the desired value (e.g., \"a.b.c\").\n * @param {string} [splitter=ObjectKeySplitter] Delimiter used to separate the path segments.\n * @return {any|undefined} Value resolved at the given path or `undefined` when not found.\n * @function getValueBySplitter\n * @mermaid\n * sequenceDiagram\n *   participant C as Caller\n *   participant F as getValueBySplitter\n *   participant O as Object\n *   C->>F: (obj, path, splitter)\n *   F->>F: split path into keys\n *   loop for each key\n *     F->>O: access current[key]\n *     alt missing or nullish\n *       F-->>C: return undefined\n *     end\n *   end\n *   F-->>C: return final value\n * @memberOf module:decoration\n */\nexport function getValueBySplitter(\n  obj: Record<string, any>,\n  path: string,\n  splitter: string = ObjectKeySplitter\n): any {\n  const keys = path.split(splitter);\n  let current = obj;\n\n  for (const key of keys) {\n    if (\n      current === null ||\n      current === undefined ||\n      !Object.prototype.hasOwnProperty.call(current, key)\n    )\n      return undefined;\n    current = current[key];\n  }\n\n  return current;\n}\n\n/**\n * @description Sets a nested value on an object given a path.\n * @summary Traverses or creates intermediate objects following a splitter-delimited path and assigns the provided value at the destination key.\n * @param {Record<string, any>} obj Object to mutate while drilling into nested keys.\n * @param {string} path Splitter-delimited destination path (e.g., \"a.b.c\").\n * @param {any} value Value to set at the destination node.\n * @param {string} [splitter=ObjectKeySplitter] Delimiter used to separate the path segments.\n * @return {void}\n * @function setValueBySplitter\n * @mermaid\n * sequenceDiagram\n *   participant C as Caller\n *   participant F as setValueBySplitter\n *   participant O as Object\n *   C->>F: (obj, path, value, splitter)\n *   F->>F: split path into keys\n *   loop for each key\n *     alt key missing\n *       F->>O: create intermediate object\n *     else key exists\n *       F->>O: descend into existing object\n *     end\n *   end\n *   F-->>C: void\n * @memberOf module:decoration\n */\nexport function setValueBySplitter(\n  obj: Record<string, any>,\n  path: string,\n  value: any,\n  splitter = ObjectKeySplitter\n): void {\n  const keys = path.split(splitter).filter((k) => k.length > 0);\n  if (keys.length === 0) return;\n\n  let current: Record<any, any> = obj;\n\n  for (let i = 0; i < keys.length - 1; i++) {\n    const key = keys[i];\n    if (\n      current[key] === undefined ||\n      current[key] === null ||\n      typeof current[key] !== \"object\"\n    ) {\n      current[key] = {};\n    }\n    current = current[key];\n  }\n\n  const lastKey = keys[keys.length - 1];\n  current[lastKey] = value;\n}\n\n/**\n * @description Centralized runtime metadata store bound to constructors.\n * @summary Provides utilities to read and write structured metadata for classes and their members, with optional mirroring onto the constructor via a well-known symbol key. Supports nested key paths using a configurable splitter and offers both instance and static APIs.\n * @template M The model type the metadata belongs to.\n * @template META Extends BasicMetadata<M> representing the metadata structure.\n * @param {string} [flavour=DefaultFlavour] Optional flavour identifier applied when instantiating helper builders.\n * @class\n * @example\n * // Define and read metadata for a class\n * class User { name!: string }\n * Metadata.set(User, \"description.class\", \"A user model\");\n * Metadata.set(User, \"properties.name\", String);\n * const desc = Metadata.get(User, \"description.class\"); // \"A user model\"\n * const type = Metadata.type(User, \"name\"); // String\n * @mermaid\n * sequenceDiagram\n *   participant C as Constructor\n *   participant S as Metadata (static)\n *   C->>S: set(User, \"properties.name\", String)\n *   C->>S: get(User, \"properties.name\")\n *   S-->>C: String\n */\nexport class Metadata {\n  /**\n   * @description In-memory storage of metadata by constructor symbol\n   * @summary Maps a Symbol derived from the constructor to its metadata object, enabling efficient lookup.\n   */\n  private static _metadata: Record<symbol, any> = {};\n\n  /**\n   * @description Path delimiter for nested metadata keys\n   * @summary Used by get/set operations to navigate nested structures, defaults to ObjectKeySplitter.\n   */\n  static splitter = ObjectKeySplitter;\n  /**\n   * @description Symbol key used to mirror metadata on the constructor\n   * @summary When mirroring is enabled, the metadata object is defined on the constructor under this non-enumerable key.\n   */\n  static baseKey = DecorationKeys.REFLECT;\n  /**\n   * @description Controls whether metadata is mirrored onto the constructor\n   * @summary When true, the metadata object is defined on the constructor under the non-enumerable baseKey.\n   */\n  static mirror: boolean = true;\n\n  private constructor() {}\n\n  /**\n   * @description Lists known property keys for a model.\n   * @summary Reads the metadata entry and returns the names of properties that have recorded type information.\n   * @param {Constructor} model Target constructor whose property metadata should be inspected.\n   * @return {string[]|undefined} Array of property names or `undefined` if no metadata exists.\n   */\n  static properties(model: Constructor): string[] | undefined {\n    const meta = this.get(model);\n    if (!meta) return undefined;\n    return Object.keys(meta.properties);\n  }\n\n  /**\n   * @description Lists known methods for a model.\n   * @summary Reads the metadata entry and returns the method names that have recorded signature metadata for the provided constructor.\n   * @param {Constructor} model Target constructor whose method metadata should be inspected.\n   * @return {string[]|undefined} Array of method names or `undefined` if no metadata exists.\n   */\n  static methods(model: Constructor): string[] | undefined {\n    const meta = this.get(model, DecorationKeys.METHODS);\n    if (!meta) return undefined;\n    return Object.keys(meta);\n  }\n\n  /**\n   * @description Retrieves a human-readable description for a class or a property.\n   * @summary Looks up the description stored under the metadata \"description\" map. If a property key is provided, returns the property's description; otherwise returns the class description.\n   * @template M\n   * @param {Constructor<M>} model Target constructor whose description is being retrieved.\n   * @param {string} [prop] Optional property key (typed as `keyof M`) for which to fetch the description.\n   * @return {string|undefined} Description text if present, otherwise `undefined`.\n   */\n  static description<M>(\n    model: Constructor<M>,\n    prop?: keyof M\n  ): string | undefined {\n    return this.get(\n      model,\n      [DecorationKeys.DESCRIPTION, prop ? prop : DecorationKeys.CLASS].join(\n        this.splitter\n      )\n    );\n  }\n\n  /**\n   * @description Retrieves the recorded params for a method.\n   * @summary Reads the metadata entry under `methods.<prop>.design:paramtypes` to return the parameter constructors for the given method.\n   * @template M\n   * @param {Constructor<M>} model Target constructor owning the method metadata.\n   * @param {string} prop Method name whose parameters should be fetched.\n   * @return {any[]|undefined} Array of constructor references describing each parameter or `undefined` when not available.\n   */\n  static params<M>(model: Constructor<M>, prop: string): any[] | undefined {\n    return this.get(\n      model,\n      [DecorationKeys.METHODS, prop, DecorationKeys.DESIGN_PARAMS].join(\n        this.splitter\n      )\n    );\n  }\n\n  /**\n   * @description Retrieves a single recorded parameter type for a method.\n   * @summary Looks up the parameter metadata for the provided index, enforcing bounds and returning the constructor reference for that argument.\n   * @template M\n   * @param {Constructor<M>} model Target constructor owning the method metadata.\n   * @param {string} prop Method name whose parameter should be returned.\n   * @param {number} index Zero-based index of the desired parameter metadata.\n   * @return {any|undefined} Constructor reference for the parameter or `undefined` if not recorded.\n   */\n  static param<M>(\n    model: Constructor<M>,\n    prop: string,\n    index: number\n  ): any | undefined {\n    const params = this.params(model, prop);\n    if (!params) return undefined;\n    if (index > params.length - 1)\n      throw new Error(\n        `Parameter index ${index} out of range for ${String(prop)}`\n      );\n    return params[index];\n  }\n\n  /**\n   * @description Retrieves the recorded return type for a method.\n   * @summary Reads the metadata entry under `methods.<prop>.design:returntype` to return the return type for the given method.\n   * @template M\n   * @param {Constructor<M>} model Target constructor whose method metadata should be inspected.\n   * @param {string} prop Method name whose return type should be fetched.\n   * @return {any|undefined} Constructor reference for the return type or `undefined` when not available.\n   */\n  static return<M>(model: Constructor<M>, prop: string): any | undefined {\n    return this.get(\n      model,\n      [DecorationKeys.METHODS, prop, DecorationKeys.DESIGN_RETURN].join(\n        this.splitter\n      )\n    );\n  }\n\n  /**\n   * @description Retrieves the recorded design type for a property.\n   * @summary Reads the metadata entry under `properties.<prop>` to return the constructor recorded for the given property name.\n   * @param {Constructor} model Target constructor whose property metadata should be inspected.\n   * @param {string} prop Property name whose type metadata should be returned.\n   * @return {Constructor|undefined} Constructor reference for the property type or `undefined` if not available.\n   */\n  static type(model: Constructor, prop: string) {\n    return this.get(\n      model,\n      [DecorationKeys.PROPERTIES, prop].join(this.splitter)\n    );\n  }\n\n  /**\n   * @description Resolves the canonical constructor associated with the provided model handle.\n   * @summary Returns the stored constructor reference when the provided model is a proxy or reduced value. Falls back to the original model when no constructor metadata has been recorded yet.\n   * @template M\n   * @param {Constructor<M>} model Model used when recording metadata.\n   * @return {Constructor<M>|undefined} Canonical constructor if stored, otherwise `undefined`.\n   */\n  static constr<M>(model: Constructor<M>) {\n    return model[DecorationKeys.CONSTRUCTOR as keyof typeof model] as\n      | Constructor<M>\n      | undefined;\n  }\n\n  /**\n   * @description Retrieves metadata for a model or a specific key within it.\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model Target constructor used to locate the metadata record.\n   * @return {META|undefined} Metadata object, the value at the key path, or `undefined` if nothing exists.\n   */\n  static get<M, META extends BasicMetadata<M> = BasicMetadata<M>>(\n    model: Constructor<M>\n  ): META | undefined;\n  /**\n   * @description Retrieves metadata for a model or a specific key within it.\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model Target constructor used to locate the metadata record.\n   * @param {string} key Nested key path to fetch a specific value.\n   * @return {META|*|undefined} Metadata object, the value at the key path, or `undefined` if nothing exists.\n   */\n  static get(model: Constructor, key: string): any;\n  /**\n   * @description Retrieves metadata for a model or a specific key within it.\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>|string} model Target constructor used to locate the metadata record or a pre-resolved symbol identifier.\n   * @param {string} [key] Optional nested key path to fetch a specific value.\n   * @return {META|*|undefined} Metadata object, the value at the key path, or `undefined` if nothing exists.\n   */\n  static get(model: Constructor, key?: string) {\n    if (key === DecorationKeys.CONSTRUCTOR) return this.constr(model);\n    const resolvedModel = this.constr(model) || model;\n    const constructors = this.collectConstructorChain(resolvedModel);\n    if (constructors.length === 0) {\n      const fallbackSymbol = Symbol.for(resolvedModel.toString());\n      return this.innerGet(fallbackSymbol, key);\n    }\n    const collectedValues = constructors\n      .map((ctor) => this.innerGet(Symbol.for(ctor.toString()), key))\n      .filter((value) => value !== undefined);\n\n    if (collectedValues.length === 0) return undefined;\n\n    return this.mergeMetadataChain(collectedValues);\n  }\n\n  /**\n   * @description Retrieves metadata stored under a symbol key.\n   * @summary Internal helper that resolves and optionally drills into the in-memory metadata map for the provided symbol and key path.\n   * @param {symbol} symbol Symbol representing the metadata bucket.\n   * @param {string|symbol} [key] Optional nested key referencing a specific metadata entry.\n   * @return {any} Stored metadata object or value for the provided key, or `undefined` when absent.\n   */\n  private static innerGet(symbol: symbol, key?: string | symbol) {\n    if (!this._metadata[symbol]) return undefined;\n    if (!key) return this._metadata[symbol];\n    if (typeof key === \"string\")\n      return getValueBySplitter(this._metadata[symbol], key, this.splitter);\n    return this._metadata[symbol][key];\n  }\n\n  /**\n   * @description Builds the inheritance chain for a constructor, ordered from base to most-specific class.\n   * @summary Walks the prototype chain starting from the provided constructor until reaching Function/Object and returns the collected constructors.\n   * @param {Constructor} model Constructor whose chain should be collected.\n   * @return {Constructor[]} Array of constructors ordered from base to leaf.\n   */\n  private static collectConstructorChain(model: Constructor): Constructor[] {\n    const chain: Constructor[] = [];\n    let current: any = model;\n\n    while (typeof current === \"function\" && current !== Function) {\n      chain.push(current as Constructor);\n      const parent = Object.getPrototypeOf(current);\n      if (!parent || parent === Function || parent === Object) break;\n      current = parent;\n    }\n\n    return chain.reverse();\n  }\n\n  /**\n   * @description Merges metadata values collected across the inheritance chain.\n   * @summary Performs a deep merge for plain objects while letting non-object values override earlier ones to preserve child metadata precedence.\n   * @param {any[]} values Metadata values gathered from base to child.\n   * @return {any} Aggregated metadata value respecting inheritance precedence.\n   */\n  private static mergeMetadataChain(values: any[]) {\n    let acc: any = undefined;\n\n    for (const value of values) {\n      if (acc === undefined) {\n        acc = this.cloneMetadataValue(value);\n        continue;\n      }\n\n      if (this.isPlainObject(acc) && this.isPlainObject(value)) {\n        acc = this.mergePlainObjects(\n          acc as Record<string, any>,\n          value as Record<string, any>\n        );\n        continue;\n      }\n\n      acc = this.cloneMetadataValue(value);\n    }\n\n    return acc;\n  }\n\n  /**\n   * @description Produces a deep clone of a metadata value when necessary.\n   * @summary Arrays are shallow-cloned, plain objects are deep-cloned, and primitive/function values are returned as-is.\n   * @param {any} value Metadata value to clone.\n   * @return {any} Cloned metadata value preventing mutation of the backing store.\n   */\n  private static cloneMetadataValue(value: any) {\n    if (Array.isArray(value)) return [...value];\n    if (this.isPlainObject(value))\n      return this.mergePlainObjects({}, value as Record<string, any>);\n    return value;\n  }\n\n  /**\n   * @description Deeply merges two plain metadata objects.\n   * @summary Recursively merges nested plain objects while cloning arrays; values from `source` override those from `target` when conflicts occur.\n   * @param {Record<string, any>} target Base object to merge into.\n   * @param {Record<string, any>} source Object providing overriding metadata.\n   * @return {Record<string, any>} Newly merged metadata object.\n   */\n  private static mergePlainObjects(\n    target: Record<string, any>,\n    source: Record<string, any>\n  ): Record<string, any> {\n    const result: Record<string, any> = { ...target };\n\n    for (const key of Object.keys(source)) {\n      const sourceValue = source[key];\n      const targetValue = result[key];\n\n      if (this.isPlainObject(sourceValue)) {\n        result[key] = this.isPlainObject(targetValue)\n          ? this.mergePlainObjects(\n              targetValue as Record<string, any>,\n              sourceValue as Record<string, any>\n            )\n          : this.mergePlainObjects({}, sourceValue as Record<string, any>);\n        continue;\n      }\n\n      if (Array.isArray(sourceValue)) {\n        result[key] = [...sourceValue];\n        continue;\n      }\n\n      result[key] = sourceValue;\n    }\n\n    return result;\n  }\n\n  /**\n   * @description Checks if a value is a plain object suitable for deep merging.\n   * @summary Ensures arrays and null are excluded while accepting objects created via literal/class syntax.\n   * @param {any} value Value to inspect.\n   * @return {boolean} True when the value is a plain object.\n   */\n  private static isPlainObject(value: any): value is Record<string, any> {\n    if (value === null || typeof value !== \"object\" || Array.isArray(value))\n      return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n  }\n\n  /**\n   * @description Writes metadata under a symbol key.\n   * @summary Internal helper that ensures the metadata bucket exists for the provided symbol and persists the given value, drilling into nested structures when the key is a string path.\n   * @param {symbol} symbol Symbol representing the metadata bucket.\n   * @param {string|symbol} key Nested key path or direct symbol under which to store the metadata value.\n   * @param {any} value Value persisted in the metadata store.\n   * @return {void}\n   */\n  private static innerSet(symbol: symbol, key: string | symbol, value: any) {\n    if (!this._metadata[symbol]) this._metadata[symbol] = {} as any;\n    if (typeof key === \"string\")\n      return setValueBySplitter(\n        this._metadata[symbol],\n        key,\n        value,\n        this.splitter\n      );\n    this._metadata[symbol][key] = value;\n  }\n\n  /**\n   * @description Writes a metadata value at a given nested key path.\n   * @summary Ensures the metadata record exists for the constructor, mirrors it on the constructor when enabled, and sets the provided value on the nested key path using the configured splitter.\n   * @template M\n   * @param {Constructor<M>|string} model Target constructor to which the metadata belongs or a direct identifier string.\n   * @param {string} key Nested key path at which to store the value.\n   * @param {any} value Value to store in the metadata.\n   * @return {void}\n   */\n  static set(model: Constructor | string, key: string, value: any): void {\n    if (key === DecorationKeys.CONSTRUCTOR) {\n      Object.defineProperty(model, DecorationKeys.CONSTRUCTOR, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: value,\n      });\n      return;\n    }\n    if (typeof model !== \"string\") model = this.constr(model) || model;\n    const symbol = Symbol.for(model.toString());\n    this.innerSet(symbol, key, value);\n    if (\n      typeof model !== \"string\" &&\n      Metadata.mirror &&\n      !Object.prototype.hasOwnProperty.call(model, this.baseKey)\n    ) {\n      Object.defineProperty(model, this.baseKey, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: this._metadata[symbol],\n      });\n    }\n  }\n\n  /**\n   * @description Registers a decoration-aware library and its version.\n   * @summary Stores the version string for an integrating library under the shared libraries metadata symbol, preventing duplicate registrations for the same library identifier.\n   * @param {string} library Package name or identifier to register.\n   * @param {string} version Semantic version string associated with the library.\n   * @return {void}\n   * @throws {Error} If the library has already been registered.\n   */\n  static registerLibrary(library: string, version: string) {\n    const symbol = Symbol.for(DecorationKeys.LIBRARIES);\n    const lib = this.innerGet(symbol, library);\n    if (lib)\n      throw new Error(\n        `Library already ${library} registered with version ${version}`\n      );\n    this.innerSet(symbol, library, version);\n  }\n\n  /**\n   * @description Lists registered decoration-aware libraries.\n   * @summary Returns the in-memory map of library identifiers to semantic versions that have been registered with the Decoration metadata store.\n   * @return {Record<string, string>} Map of registered library identifiers to their version strings.\n   */\n  static libraries(): Record<string, string> {\n    const symbol = Symbol.for(DecorationKeys.LIBRARIES);\n    return this.innerGet(symbol) || {};\n  }\n\n  /**\n   * @description Joins path segments using the current splitter.\n   * @summary Constructs a nested metadata key by concatenating string segments with the configured splitter for use with the metadata store.\n   * @param {...string} strs Key segments to join into a full metadata path.\n   * @return {string} Splitter-joined metadata key.\n   */\n  static key(...strs: string[]) {\n    return strs.join(this.splitter);\n  }\n}\n"]}

package/lib/esm/metadata/types.d.ts

@@ -1,24 +1,36 @@
 import { DecorationKeys } from "../constants";
 /**
  * @description Shape of the metadata stored for a decorated model.
- * @summary Describes the required and optional metadata buckets tracked for a model, including constructor, descriptions, property types, and method signatures.
+ * @summary Captures the constructor reference alongside optional description, property, and method metadata buckets maintained by the decoration runtime.
  * @template M
- * @typeDef {Object} module:decoration.BasicMetadata
- * @property {Constructor} class Canonical constructor associated with the metadata (`DecorationKeys.CLASS`).
- * @property {Object<string, string>} [description] Human-readable descriptions for the class and its members (`DecorationKeys.DESCRIPTION`).
- * @property {Object<string, Constructor|undefined>} properties Reflected property type constructors keyed by property name (`DecorationKeys.PROPERTIES`).
- * @property {Object<string, Constructor|undefined>} methods Reflected method signature constructors keyed by method name (`DecorationKeys.METHODS`).
+ * @typeDef BasicMetadata<M>
+ * @property {Constructor<M>} [DecorationKeys.CLASS] Canonical constructor associated with the metadata entry.
+ * @property {Record<string, string>} [DecorationKeys.DESCRIPTION] Human-readable descriptions for the class and its members.
+ * @property {Record<string, Constructor<M>|undefined>} [DecorationKeys.PROPERTIES] Reflected property type constructors keyed by property name.
+ * @property {Record<string, Constructor<M>|undefined>} [DecorationKeys.METHODS] Reflected method signature constructors keyed by method name.
  * @memberOf module:decoration
  */
 /** @ignore */
 export type BasicMetadata<M> = {
-    /** @type {Constructor} */
+    /**
+     * @description Canonical constructor associated with the metadata entry.
+     * @type {Constructor<M>}
+     */
     [DecorationKeys.CLASS]: Constructor<M>;
-    /** @type {Object<string, string>} */
+    /**
+     * @description Map of human-friendly descriptions for the class and its members.
+     * @type {Record<string, string>}
+     */
     [DecorationKeys.DESCRIPTION]?: Record<string, string>;
-    /** @type {Object<string, Constructor|undefined>} */
+    /**
+     * @description Property metadata keyed by property name including recorded design types.
+     * @type {Record<string, Constructor<M>|undefined>}
+     */
     [DecorationKeys.PROPERTIES]: Record<string, Constructor<M> | undefined>;
-    /** @type {Object<string, Constructor|undefined>} */
+    /**
+     * @description Method metadata keyed by method name including recorded design signatures.
+     * @type {Record<string, Constructor<M>|undefined>}
+     */
     [DecorationKeys.METHODS]: Record<string, Constructor<M> | undefined>;
 };
 /**

package/lib/esm/metadata/types.js

@@ -1,2 +1,2 @@
 import { DecorationKeys } from "./../constants.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.cjs

@@ -1,11 +1,7 @@
 "use strict";
 /**
- * @description Root entry point for the decoration module.
- * @summary Aggregates and re-exports the public API of the decoration library, including {@link Decoration}, decorator utilities from {@link module:decoration|./decorators}, {@link Metadata}, and shared constants such as {@link DecorationKeys} and {@link DefaultFlavour}. This is the primary import surface for consumers and exposes:
- * - Core builder: {@link Decoration}
- * - Decorator utilities: {@link module:decoration|decorators in ./decorators}
- * - Metadata utilities: {@link Metadata}
- * - Constants and enums: {@link DecorationKeys}, {@link DefaultFlavour}
+ * @description Root entry point for the decoration package.
+ * @summary Re-exports the builder API, decorator helpers, metadata utilities, and shared constants so consumers can import {@link Decoration}, {@link Metadata}, {@link DecorationKeys}, and {@link DefaultFlavour} from a single surface.
  * @module decoration
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -30,11 +26,12 @@ __exportStar(require("./metadata/index.cjs"), exports);
 __exportStar(require("./constants.cjs"), exports);
 __exportStar(require("./decorators.cjs"), exports);
 /**
- * @description Current version of the reflection package
- * @summary Stores the semantic version number of the package
+ * @description Current version of the decoration package.
+ * @summary Stores the semantic version string registered through {@link Metadata.registerLibrary}.
+ * @type {string}
  * @const VERSION
  * @memberOf module:decoration
  */
-exports.VERSION = "0.0.15";
+exports.VERSION = "0.0.17";
 index_1.Metadata.registerLibrary("@decaf-ts/decoration", exports.VERSION);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7OztHQVFHOzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILGdEQUE0QztBQUU1Qyx5REFBNkI7QUFDN0IsdURBQTJCO0FBQzNCLGtEQUE0QjtBQUM1QixtREFBNkI7QUFFN0I7Ozs7O0dBS0c7QUFDVSxRQUFBLE9BQU8sR0FBRyxhQUFhLENBQUM7QUFFckMsZ0JBQVEsQ0FBQyxlQUFlLENBQUMsc0JBQXNCLEVBQUUsZUFBTyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXNjcmlwdGlvbiBSb290IGVudHJ5IHBvaW50IGZvciB0aGUgZGVjb3JhdGlvbiBtb2R1bGUuXG4gKiBAc3VtbWFyeSBBZ2dyZWdhdGVzIGFuZCByZS1leHBvcnRzIHRoZSBwdWJsaWMgQVBJIG9mIHRoZSBkZWNvcmF0aW9uIGxpYnJhcnksIGluY2x1ZGluZyB7QGxpbmsgRGVjb3JhdGlvbn0sIGRlY29yYXRvciB1dGlsaXRpZXMgZnJvbSB7QGxpbmsgbW9kdWxlOmRlY29yYXRpb258Li9kZWNvcmF0b3JzfSwge0BsaW5rIE1ldGFkYXRhfSwgYW5kIHNoYXJlZCBjb25zdGFudHMgc3VjaCBhcyB7QGxpbmsgRGVjb3JhdGlvbktleXN9IGFuZCB7QGxpbmsgRGVmYXVsdEZsYXZvdXJ9LiBUaGlzIGlzIHRoZSBwcmltYXJ5IGltcG9ydCBzdXJmYWNlIGZvciBjb25zdW1lcnMgYW5kIGV4cG9zZXM6XG4gKiAtIENvcmUgYnVpbGRlcjoge0BsaW5rIERlY29yYXRpb259XG4gKiAtIERlY29yYXRvciB1dGlsaXRpZXM6IHtAbGluayBtb2R1bGU6ZGVjb3JhdGlvbnxkZWNvcmF0b3JzIGluIC4vZGVjb3JhdG9yc31cbiAqIC0gTWV0YWRhdGEgdXRpbGl0aWVzOiB7QGxpbmsgTWV0YWRhdGF9XG4gKiAtIENvbnN0YW50cyBhbmQgZW51bXM6IHtAbGluayBEZWNvcmF0aW9uS2V5c30sIHtAbGluayBEZWZhdWx0Rmxhdm91cn1cbiAqIEBtb2R1bGUgZGVjb3JhdGlvblxuICovXG5cbmltcG9ydCB7IE1ldGFkYXRhIH0gZnJvbSBcIi4vbWV0YWRhdGEvaW5kZXhcIjtcblxuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbWV0YWRhdGFcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDdXJyZW50IHZlcnNpb24gb2YgdGhlIHJlZmxlY3Rpb24gcGFja2FnZVxuICogQHN1bW1hcnkgU3RvcmVzIHRoZSBzZW1hbnRpYyB2ZXJzaW9uIG51bWJlciBvZiB0aGUgcGFja2FnZVxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6ZGVjb3JhdGlvblxuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcblxuTWV0YWRhdGEucmVnaXN0ZXJMaWJyYXJ5KFwiQGRlY2FmLXRzL2RlY29yYXRpb25cIiwgVkVSU0lPTik7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7O0dBSUc7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsZ0RBQTRDO0FBRTVDLHlEQUE2QjtBQUM3Qix1REFBMkI7QUFDM0Isa0RBQTRCO0FBQzVCLG1EQUE2QjtBQUU3Qjs7Ozs7O0dBTUc7QUFDVSxRQUFBLE9BQU8sR0FBRyxhQUFhLENBQUM7QUFFckMsZ0JBQVEsQ0FBQyxlQUFlLENBQUMsc0JBQXNCLEVBQUUsZUFBTyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXNjcmlwdGlvbiBSb290IGVudHJ5IHBvaW50IGZvciB0aGUgZGVjb3JhdGlvbiBwYWNrYWdlLlxuICogQHN1bW1hcnkgUmUtZXhwb3J0cyB0aGUgYnVpbGRlciBBUEksIGRlY29yYXRvciBoZWxwZXJzLCBtZXRhZGF0YSB1dGlsaXRpZXMsIGFuZCBzaGFyZWQgY29uc3RhbnRzIHNvIGNvbnN1bWVycyBjYW4gaW1wb3J0IHtAbGluayBEZWNvcmF0aW9ufSwge0BsaW5rIE1ldGFkYXRhfSwge0BsaW5rIERlY29yYXRpb25LZXlzfSwgYW5kIHtAbGluayBEZWZhdWx0Rmxhdm91cn0gZnJvbSBhIHNpbmdsZSBzdXJmYWNlLlxuICogQG1vZHVsZSBkZWNvcmF0aW9uXG4gKi9cblxuaW1wb3J0IHsgTWV0YWRhdGEgfSBmcm9tIFwiLi9tZXRhZGF0YS9pbmRleFwiO1xuXG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tZXRhZGF0YVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEN1cnJlbnQgdmVyc2lvbiBvZiB0aGUgZGVjb3JhdGlvbiBwYWNrYWdlLlxuICogQHN1bW1hcnkgU3RvcmVzIHRoZSBzZW1hbnRpYyB2ZXJzaW9uIHN0cmluZyByZWdpc3RlcmVkIHRocm91Z2gge0BsaW5rIE1ldGFkYXRhLnJlZ2lzdGVyTGlicmFyeX0uXG4gKiBAdHlwZSB7c3RyaW5nfVxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6ZGVjb3JhdGlvblxuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcblxuTWV0YWRhdGEucmVnaXN0ZXJMaWJyYXJ5KFwiQGRlY2FmLXRzL2RlY29yYXRpb25cIiwgVkVSU0lPTik7XG4iXX0=

package/lib/index.d.ts

@@ -1,10 +1,6 @@
 /**
- * @description Root entry point for the decoration module.
- * @summary Aggregates and re-exports the public API of the decoration library, including {@link Decoration}, decorator utilities from {@link module:decoration|./decorators}, {@link Metadata}, and shared constants such as {@link DecorationKeys} and {@link DefaultFlavour}. This is the primary import surface for consumers and exposes:
- * - Core builder: {@link Decoration}
- * - Decorator utilities: {@link module:decoration|decorators in ./decorators}
- * - Metadata utilities: {@link Metadata}
- * - Constants and enums: {@link DecorationKeys}, {@link DefaultFlavour}
+ * @description Root entry point for the decoration package.
+ * @summary Re-exports the builder API, decorator helpers, metadata utilities, and shared constants so consumers can import {@link Decoration}, {@link Metadata}, {@link DecorationKeys}, and {@link DefaultFlavour} from a single surface.
  * @module decoration
  */
 export * from "./decoration";
@@ -12,9 +8,10 @@ export * from "./metadata";
 export * from "./constants";
 export * from "./decorators";
 /**
- * @description Current version of the reflection package
- * @summary Stores the semantic version number of the package
+ * @description Current version of the decoration package.
+ * @summary Stores the semantic version string registered through {@link Metadata.registerLibrary}.
+ * @type {string}
  * @const VERSION
  * @memberOf module:decoration
  */
-export declare const VERSION = "0.0.15";
+export declare const VERSION = "0.0.17";