@decaf-ts/decoration 0.0.7 → 0.0.9

package/lib/esm/metadata/Metadata.js

@@ -1,12 +1,12 @@
 import { DecorationKeys, ObjectKeySplitter } from "./../constants.js";
 import "reflect-metadata";
 /**
- * @description Retrieves a nested value from an object given a path
- * @summary Walks an object structure using a splitter-delimited path and returns the value at that location or undefined if any key is missing.
- * @param {Record<string, any>} obj The object to traverse
- * @param {string} path The path to the desired value (e.g., "a.b.c")
- * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path
- * @return {*} The resolved value at the given path or undefined if not found
+ * @description Retrieves a nested value from an object given a path.
+ * @summary Walks an object structure using a splitter-delimited path and returns the value at that location or `undefined` if any key is missing.
+ * @param {Record<string, any>} obj Object to traverse for the lookup.
+ * @param {string} path Splitter-delimited path to the desired value (e.g., "a.b.c").
+ * @param {string} [splitter=ObjectKeySplitter] Delimiter used to separate the path segments.
+ * @return {any|undefined} Value resolved at the given path or `undefined` when not found.
  * @function getValueBySplitter
  * @mermaid
  * sequenceDiagram
@@ -37,12 +37,12 @@ export function getValueBySplitter(obj, path, splitter = ObjectKeySplitter) {
     return current;
 }
 /**
- * @description Sets a nested value on an object given a path
+ * @description Sets a nested value on an object given a path.
  * @summary Traverses or creates intermediate objects following a splitter-delimited path and assigns the provided value at the destination key.
- * @param {Record<string, any>} obj The object to mutate
- * @param {string} path The destination path (e.g., "a.b.c")
- * @param {*} value The value to set at the destination
- * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path
+ * @param {Record<string, any>} obj Object to mutate while drilling into nested keys.
+ * @param {string} path Splitter-delimited destination path (e.g., "a.b.c").
+ * @param {any} value Value to set at the destination node.
+ * @param {string} [splitter=ObjectKeySplitter] Delimiter used to separate the path segments.
  * @return {void}
  * @function setValueBySplitter
  * @mermaid
@@ -80,10 +80,11 @@ export function setValueBySplitter(obj, path, value, splitter = ObjectKeySplitte
     current[lastKey] = value;
 }
 /**
- * @description Centralized runtime metadata store bound to constructors
+ * @description Centralized runtime metadata store bound to constructors.
  * @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.
- * @template M The model type the metadata belongs to
- * @template META Extends BasicMetadata<M> representing the metadata structure
+ * @template M The model type the metadata belongs to.
+ * @template META Extends BasicMetadata<M> representing the metadata structure.
+ * @param {string} [flavour=DefaultFlavour] Optional flavour identifier applied when instantiating helper builders.
  * @class
  * @example
  * // Define and read metadata for a class
@@ -123,10 +124,10 @@ export class Metadata {
     static { this.mirror = true; }
     constructor() { }
     /**
-     * @description Lists known property keys for a model
+     * @description Lists known property keys for a model.
      * @summary Reads the metadata entry and returns the names of properties that have recorded type information.
-     * @param {Constructor} model The target constructor
-     * @return {string[]|undefined} Array of property names or undefined if no metadata exists
+     * @param {Constructor} model Target constructor whose property metadata should be inspected.
+     * @return {string[]|undefined} Array of property names or `undefined` if no metadata exists.
      */
     static properties(model) {
         const meta = this.get(model);
@@ -135,10 +136,10 @@ export class Metadata {
         return Object.keys(meta.properties);
     }
     /**
-     * @description Lists known methods for a model
+     * @description Lists known methods for a model.
      * @summary Reads the metadata entry and returns the method names that have recorded signature metadata for the provided constructor.
-     * @param {Constructor} model The target constructor
-     * @return {string[]|undefined} Array of property names or undefined if no metadata exists
+     * @param {Constructor} model Target constructor whose method metadata should be inspected.
+     * @return {string[]|undefined} Array of method names or `undefined` if no metadata exists.
      */
     static methods(model) {
         const meta = this.get(model, DecorationKeys.METHODS);
@@ -147,94 +148,142 @@ export class Metadata {
         return Object.keys(meta);
     }
     /**
-     * @description Retrieves a human-readable description for a class or a property
+     * @description Retrieves a human-readable description for a class or a property.
      * @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.
      * @template M
-     * @param {Constructor<M>} model The target constructor whose description is being retrieved
-     * @param {string} [prop] Optional property key for which to fetch the description
-     * @return {string|undefined} The description text if present, otherwise undefined
+     * @param {Constructor<M>} model Target constructor whose description is being retrieved.
+     * @param {string} [prop] Optional property key (typed as `keyof M`) for which to fetch the description.
+     * @return {string|undefined} Description text if present, otherwise `undefined`.
      */
     static description(model, prop) {
         return this.get(model, [DecorationKeys.DESCRIPTION, prop ? prop : DecorationKeys.CLASS].join(this.splitter));
     }
     /**
-     * @description Retrieves the recorded params for a method
-     * @summary Reads the metadata entry under "methods.<prop>.design:params" to return the arguments for the iven method.
-     * @param {Constructor} model The target constructor
-     * @param {string} prop The method name
-     * @return {any[] | undefined} The argument types of the method or undefined if not available
+     * @description Retrieves the recorded params for a method.
+     * @summary Reads the metadata entry under `methods.<prop>.design:paramtypes` to return the parameter constructors for the given method.
+     * @template M
+     * @param {Constructor<M>} model Target constructor owning the method metadata.
+     * @param {string} prop Method name whose parameters should be fetched.
+     * @return {any[]|undefined} Array of constructor references describing each parameter or `undefined` when not available.
      */
     static params(model, prop) {
         return this.get(model, [DecorationKeys.METHODS, prop, DecorationKeys.DESIGN_PARAMS].join(this.splitter));
     }
     /**
-     * @description Retrieves the recorded return type for a method
-     * @summary Reads the metadata entry under "methods.<prop>.design:return" to return the return type for the given method.
-     * @param {Constructor} model The target constructor
-     * @param {string} prop The method name
-     * @return {any|undefined} The return type of the method or undefined if not available
+     * @description Retrieves a single recorded parameter type for a method.
+     * @summary Looks up the parameter metadata for the provided index, enforcing bounds and returning the constructor reference for that argument.
+     * @template M
+     * @param {Constructor<M>} model Target constructor owning the method metadata.
+     * @param {string} prop Method name whose parameter should be returned.
+     * @param {number} index Zero-based index of the desired parameter metadata.
+     * @return {any|undefined} Constructor reference for the parameter or `undefined` if not recorded.
+     */
+    static param(model, prop, index) {
+        const params = this.params(model, prop);
+        if (!params)
+            return undefined;
+        if (index > params.length - 1)
+            throw new Error(`Parameter index ${index} out of range for ${String(prop)}`);
+        return params[index];
+    }
+    /**
+     * @description Retrieves the recorded return type for a method.
+     * @summary Reads the metadata entry under `methods.<prop>.design:returntype` to return the return type for the given method.
+     * @template M
+     * @param {Constructor<M>} model Target constructor whose method metadata should be inspected.
+     * @param {string} prop Method name whose return type should be fetched.
+     * @return {any|undefined} Constructor reference for the return type or `undefined` when not available.
      */
     static return(model, prop) {
         return this.get(model, [DecorationKeys.METHODS, prop, DecorationKeys.DESIGN_RETURN].join(this.splitter));
     }
     /**
-     * @description Retrieves the recorded design type for a property
-     * @summary Reads the metadata entry under "properties.<prop>" to return the constructor recorded for the given property name.
-     * @param {Constructor} model The target constructor
-     * @param {string} prop The property name whose type should be returned
-     * @return {Constructor|undefined} The constructor reference of the property type or undefined if not available
+     * @description Retrieves the recorded design type for a property.
+     * @summary Reads the metadata entry under `properties.<prop>` to return the constructor recorded for the given property name.
+     * @param {Constructor} model Target constructor whose property metadata should be inspected.
+     * @param {string} prop Property name whose type metadata should be returned.
+     * @return {Constructor|undefined} Constructor reference for the property type or `undefined` if not available.
      */
     static type(model, prop) {
         return this.get(model, [DecorationKeys.PROPERTIES, prop].join(this.splitter));
     }
     /**
-     * @description Resolves the canonical constructor associated with the provided model handle
-     * @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.
+     * @description Resolves the canonical constructor associated with the provided model handle.
+     * @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.
      * @template M
-     * @param {Constructor<M>} model The model used when recording metadata
-     * @return {Constructor<M> | undefined} The canonical constructor if stored, otherwise undefined
+     * @param {Constructor<M>} model Model used when recording metadata.
+     * @return {Constructor<M>|undefined} Canonical constructor if stored, otherwise `undefined`.
      */
     static constr(model) {
-        return this.get(model, DecorationKeys.CONSTRUCTOR);
+        return model[DecorationKeys.CONSTRUCTOR];
     }
     /**
-     * @description Retrieves metadata for a model or a specific key within it
+     * @description Retrieves metadata for a model or a specific key within it.
      * @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.
      * @template M
      * @template META
-     * @param {Constructor<M> | string} model The target constructor used to locate the metadata record
-     * @param {string} [key] Optional nested key path to fetch a specific value
-     * @return {META|*|undefined} The metadata object, the value at the key path, or undefined if nothing exists
+     * @param {Constructor<M>|string} model Target constructor used to locate the metadata record or a pre-resolved symbol identifier.
+     * @param {string} [key] Optional nested key path to fetch a specific value.
+     * @return {META|*|undefined} Metadata object, the value at the key path, or `undefined` if nothing exists.
      */
     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);
     }
+    /**
+     * @description Retrieves metadata stored under a symbol key.
+     * @summary Internal helper that resolves and optionally drills into the in-memory metadata map for the provided symbol and key path.
+     * @param {symbol} symbol Symbol representing the metadata bucket.
+     * @param {string|symbol} [key] Optional nested key referencing a specific metadata entry.
+     * @return {any} Stored metadata object or value for the provided key, or `undefined` when absent.
+     */
     static innerGet(symbol, key) {
         if (!this._metadata[symbol])
             return undefined;
         if (!key)
             return this._metadata[symbol];
-        return getValueBySplitter(this._metadata[symbol], key, this.splitter);
+        if (typeof key === "string")
+            return getValueBySplitter(this._metadata[symbol], key, this.splitter);
+        return this._metadata[symbol][key];
     }
+    /**
+     * @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.
+     * @param {symbol} symbol Symbol representing the metadata bucket.
+     * @param {string|symbol} key Nested key path or direct symbol under which to store the metadata value.
+     * @param {any} value Value persisted in the metadata store.
+     * @return {void}
+     */
     static innerSet(symbol, key, value) {
         if (!this._metadata[symbol])
             this._metadata[symbol] = {};
-        setValueBySplitter(this._metadata[symbol], key, value, this.splitter);
+        if (typeof key === "string")
+            return setValueBySplitter(this._metadata[symbol], key, value, this.splitter);
+        this._metadata[symbol][key] = value;
     }
     /**
-     * @description Writes a metadata value at a given nested key path
+     * @description Writes a metadata value at a given nested key path.
      * @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.
      * @template M
-     * @param {Constructor<M> | string} model The target constructor to which the metadata belongs
-     * @param {string} key The nested key path at which to store the value
-     * @param {*} value The value to store in the metadata
+     * @param {Constructor<M>|string} model Target constructor to which the metadata belongs or a direct identifier string.
+     * @param {string} key Nested key path at which to store the value.
+     * @param {any} value Value to store in the metadata.
      * @return {void}
      */
     static set(model, key, value) {
+        if (key === DecorationKeys.CONSTRUCTOR) {
+            Object.defineProperty(model, DecorationKeys.CONSTRUCTOR, {
+                enumerable: false,
+                configurable: false,
+                writable: false,
+                value: value,
+            });
+            return;
+        }
         if (typeof model !== "string")
             model = this.constr(model) || model;
         const symbol = Symbol.for(model.toString());
@@ -250,11 +299,12 @@ export class Metadata {
         }
     }
     /**
-     * @description Registers a decoration-aware library and its version
+     * @description Registers a decoration-aware library and its version.
      * @summary Stores the version string for an integrating library under the shared libraries metadata symbol, preventing duplicate registrations for the same library identifier.
-     * @param {string} library Package name or identifier to register
-     * @param {string} version Semantic version string associated with the library
-     * @throws {Error} If the library has already been registered
+     * @param {string} library Package name or identifier to register.
+     * @param {string} version Semantic version string associated with the library.
+     * @return {void}
+     * @throws {Error} If the library has already been registered.
      */
     static registerLibrary(library, version) {
         const symbol = Symbol.for(DecorationKeys.LIBRARIES);
@@ -263,5 +313,23 @@ export class Metadata {
             throw new Error(`Library already ${library} registered with version ${version}`);
         this.innerSet(symbol, library, version);
     }
+    /**
+     * @description Lists registered decoration-aware libraries.
+     * @summary Returns the in-memory map of library identifiers to semantic versions that have been registered with the Decoration metadata store.
+     * @return {Record<string, string>} Map of registered library identifiers to their version strings.
+     */
+    static libraries() {
+        const symbol = Symbol.for(DecorationKeys.LIBRARIES);
+        return this.innerGet(symbol) || {};
+    }
+    /**
+     * @description Joins path segments using the current splitter.
+     * @summary Constructs a nested metadata key by concatenating string segments with the configured splitter for use with the metadata store.
+     * @param {...string} strs Key segments to join into a full metadata path.
+     * @return {string} Splitter-joined metadata key.
+     */
+    static key(...strs) {
+        return strs.join(this.splitter);
+    }
 }
-//# 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 The object to traverse\n * @param {string} path The path to the desired value (e.g., \"a.b.c\")\n * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path\n * @return {*} The resolved value at the given path or undefined if 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 The object to mutate\n * @param {string} path The destination path (e.g., \"a.b.c\")\n * @param {*} value The value to set at the destination\n * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path\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 * @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 The target constructor\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 The target constructor\n   * @return {string[]|undefined} Array of property 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 The target constructor whose description is being retrieved\n   * @param {string} [prop] Optional property key for which to fetch the description\n   * @return {string|undefined} The 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:params\" to return the arguments for the iven method.\n   * @param {Constructor} model The target constructor\n   * @param {string} prop The method name\n   * @return {any[] | undefined} The argument types of the method or undefined if 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 the recorded return type for a method\n   * @summary Reads the metadata entry under \"methods.<prop>.design:return\" to return the return type for the given method.\n   * @param {Constructor} model The target constructor\n   * @param {string} prop The method name\n   * @return {any|undefined} The return type of the method or undefined if 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 The target constructor\n   * @param {string} prop The property name whose type should be returned\n   * @return {Constructor|undefined} The constructor reference of 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\n   * original model when no constructor metadata has been recorded yet.\n   * @template M\n   * @param {Constructor<M>} model The model used when recording metadata\n   * @return {Constructor<M> | undefined} The canonical constructor if stored, otherwise undefined\n   */\n  static constr<M>(model: Constructor<M>) {\n    return this.get(model, DecorationKeys.CONSTRUCTOR);\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 The target constructor used to locate the metadata record\n   * @return {META|undefined} The 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 The target constructor used to locate the metadata record\n   * @param {string} key nested key path to fetch a specific value\n   * @return {META|*|undefined} The 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 The target constructor used to locate the metadata record\n   * @param {string} [key] Optional nested key path to fetch a specific value\n   * @return {META|*|undefined} The 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) model = this.constr(model) || model;\n    const symbol = Symbol.for(model.toString());\n    return this.innerGet(symbol, key);\n  }\n\n  private static innerGet(symbol: symbol, key?: string) {\n    if (!this._metadata[symbol]) return undefined;\n    if (!key) return this._metadata[symbol];\n    return getValueBySplitter(this._metadata[symbol], key, this.splitter);\n  }\n\n  private static innerSet(symbol: symbol, key: string, value: any) {\n    if (!this._metadata[symbol]) this._metadata[symbol] = {} as any;\n    setValueBySplitter(this._metadata[symbol], key, value, this.splitter);\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 The target constructor to which the metadata belongs\n   * @param {string} key The nested key path at which to store the value\n   * @param {*} value The value to store in the metadata\n   * @return {void}\n   */\n  static set(model: Constructor | string, key: string, value: any): void {\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      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   * @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"]}
+//# 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,CAAC,CAAC;IACjE,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,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];\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      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,15 +1,31 @@
 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.
+ * @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`).
+ * @memberOf module:decoration
+ */
+/** @ignore */
 export type BasicMetadata<M> = {
+    /** @type {Constructor} */
     [DecorationKeys.CLASS]: Constructor<M>;
-    [DecorationKeys.DESCRIPTION]?: Record<keyof M | `${DecorationKeys.CLASS}`, string>;
-    [DecorationKeys.PROPERTIES]: Record<keyof M, Constructor<M> | undefined>;
-    [DecorationKeys.METHODS]: Record<keyof M, Constructor<M> | undefined>;
+    /** @type {Object<string, string>} */
+    [DecorationKeys.DESCRIPTION]?: Record<string, string>;
+    /** @type {Object<string, Constructor|undefined>} */
+    [DecorationKeys.PROPERTIES]: Record<string, Constructor<M> | undefined>;
+    /** @type {Object<string, Constructor|undefined>} */
+    [DecorationKeys.METHODS]: Record<string, Constructor<M> | undefined>;
 };
 /**
- * @description Constructor type for creating instances of a given object type
- * @summary Defines a generic constructor signature that can instantiate objects of type OBJ with any arguments.
+ * @description Constructor signature for instantiating type-safe objects.
+ * @summary Represents a generic constructor function capable of creating instances of `OBJ` with arbitrary arguments.
  * @template OBJ
- * @typedef {Constructor<OBJ>} Constructor
+ * @typeDef Constructor
  * @memberOf module:decoration
  */
 export type Constructor<OBJ = any> = {

package/lib/esm/metadata/types.js

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

package/lib/index.cjs

@@ -1,12 +1,11 @@
 "use strict";
 /**
- * @description Root entry point for the decoration module
- * @summary Aggregates and re-exports the public API of the decoration library, including core classes like {@link Decoration}, utility decorators, metadata helpers, and constants. This module is the primary import surface for consumers and exposes:
+ * @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}
+ * - Decorator utilities: {@link module:decoration|decorators in ./decorators}
  * - Metadata utilities: {@link Metadata}
  * - Constants and enums: {@link DecorationKeys}, {@link DefaultFlavour}
- *
  * @module decoration
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -36,6 +35,6 @@ __exportStar(require("./decorators.cjs"), exports);
  * @const VERSION
  * @memberOf module:decoration
  */
-exports.VERSION = "0.0.7";
+exports.VERSION = "0.0.9";
 index_1.Metadata.registerLibrary("@decaf-ts/decoration", exports.VERSION);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7Ozs7R0FTRzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCxnREFBNEM7QUFFNUMseURBQTZCO0FBQzdCLHVEQUEyQjtBQUMzQixrREFBNEI7QUFDNUIsbURBQTZCO0FBRTdCOzs7OztHQUtHO0FBQ1UsUUFBQSxPQUFPLEdBQUcsYUFBYSxDQUFDO0FBRXJDLGdCQUFRLENBQUMsZUFBZSxDQUFDLHNCQUFzQixFQUFFLGVBQU8sQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZGVzY3JpcHRpb24gUm9vdCBlbnRyeSBwb2ludCBmb3IgdGhlIGRlY29yYXRpb24gbW9kdWxlXG4gKiBAc3VtbWFyeSBBZ2dyZWdhdGVzIGFuZCByZS1leHBvcnRzIHRoZSBwdWJsaWMgQVBJIG9mIHRoZSBkZWNvcmF0aW9uIGxpYnJhcnksIGluY2x1ZGluZyBjb3JlIGNsYXNzZXMgbGlrZSB7QGxpbmsgRGVjb3JhdGlvbn0sIHV0aWxpdHkgZGVjb3JhdG9ycywgbWV0YWRhdGEgaGVscGVycywgYW5kIGNvbnN0YW50cy4gVGhpcyBtb2R1bGUgaXMgdGhlIHByaW1hcnkgaW1wb3J0IHN1cmZhY2UgZm9yIGNvbnN1bWVycyBhbmQgZXhwb3NlczpcbiAqIC0gQ29yZSBidWlsZGVyOiB7QGxpbmsgRGVjb3JhdGlvbn1cbiAqIC0gRGVjb3JhdG9yIHV0aWxpdGllczoge0BsaW5rIG1vZHVsZTpkZWNvcmF0aW9uIHwgZGVjb3JhdG9ycyBpbiAuL2RlY29yYXRvcnN9XG4gKiAtIE1ldGFkYXRhIHV0aWxpdGllczoge0BsaW5rIE1ldGFkYXRhfVxuICogLSBDb25zdGFudHMgYW5kIGVudW1zOiB7QGxpbmsgRGVjb3JhdGlvbktleXN9LCB7QGxpbmsgRGVmYXVsdEZsYXZvdXJ9XG4gKlxuICogQG1vZHVsZSBkZWNvcmF0aW9uXG4gKi9cblxuaW1wb3J0IHsgTWV0YWRhdGEgfSBmcm9tIFwiLi9tZXRhZGF0YS9pbmRleFwiO1xuXG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tZXRhZGF0YVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEN1cnJlbnQgdmVyc2lvbiBvZiB0aGUgcmVmbGVjdGlvbiBwYWNrYWdlXG4gKiBAc3VtbWFyeSBTdG9yZXMgdGhlIHNlbWFudGljIHZlcnNpb24gbnVtYmVyIG9mIHRoZSBwYWNrYWdlXG4gKiBAY29uc3QgVkVSU0lPTlxuICogQG1lbWJlck9mIG1vZHVsZTpkZWNvcmF0aW9uXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIjI1ZFUlNJT04jI1wiO1xuXG5NZXRhZGF0YS5yZWdpc3RlckxpYnJhcnkoXCJAZGVjYWYtdHMvZGVjb3JhdGlvblwiLCBWRVJTSU9OKTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7OztHQVFHOzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILGdEQUE0QztBQUU1Qyx5REFBNkI7QUFDN0IsdURBQTJCO0FBQzNCLGtEQUE0QjtBQUM1QixtREFBNkI7QUFFN0I7Ozs7O0dBS0c7QUFDVSxRQUFBLE9BQU8sR0FBRyxhQUFhLENBQUM7QUFFckMsZ0JBQVEsQ0FBQyxlQUFlLENBQUMsc0JBQXNCLEVBQUUsZUFBTyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXNjcmlwdGlvbiBSb290IGVudHJ5IHBvaW50IGZvciB0aGUgZGVjb3JhdGlvbiBtb2R1bGUuXG4gKiBAc3VtbWFyeSBBZ2dyZWdhdGVzIGFuZCByZS1leHBvcnRzIHRoZSBwdWJsaWMgQVBJIG9mIHRoZSBkZWNvcmF0aW9uIGxpYnJhcnksIGluY2x1ZGluZyB7QGxpbmsgRGVjb3JhdGlvbn0sIGRlY29yYXRvciB1dGlsaXRpZXMgZnJvbSB7QGxpbmsgbW9kdWxlOmRlY29yYXRpb258Li9kZWNvcmF0b3JzfSwge0BsaW5rIE1ldGFkYXRhfSwgYW5kIHNoYXJlZCBjb25zdGFudHMgc3VjaCBhcyB7QGxpbmsgRGVjb3JhdGlvbktleXN9IGFuZCB7QGxpbmsgRGVmYXVsdEZsYXZvdXJ9LiBUaGlzIGlzIHRoZSBwcmltYXJ5IGltcG9ydCBzdXJmYWNlIGZvciBjb25zdW1lcnMgYW5kIGV4cG9zZXM6XG4gKiAtIENvcmUgYnVpbGRlcjoge0BsaW5rIERlY29yYXRpb259XG4gKiAtIERlY29yYXRvciB1dGlsaXRpZXM6IHtAbGluayBtb2R1bGU6ZGVjb3JhdGlvbnxkZWNvcmF0b3JzIGluIC4vZGVjb3JhdG9yc31cbiAqIC0gTWV0YWRhdGEgdXRpbGl0aWVzOiB7QGxpbmsgTWV0YWRhdGF9XG4gKiAtIENvbnN0YW50cyBhbmQgZW51bXM6IHtAbGluayBEZWNvcmF0aW9uS2V5c30sIHtAbGluayBEZWZhdWx0Rmxhdm91cn1cbiAqIEBtb2R1bGUgZGVjb3JhdGlvblxuICovXG5cbmltcG9ydCB7IE1ldGFkYXRhIH0gZnJvbSBcIi4vbWV0YWRhdGEvaW5kZXhcIjtcblxuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbWV0YWRhdGFcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDdXJyZW50IHZlcnNpb24gb2YgdGhlIHJlZmxlY3Rpb24gcGFja2FnZVxuICogQHN1bW1hcnkgU3RvcmVzIHRoZSBzZW1hbnRpYyB2ZXJzaW9uIG51bWJlciBvZiB0aGUgcGFja2FnZVxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6ZGVjb3JhdGlvblxuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcblxuTWV0YWRhdGEucmVnaXN0ZXJMaWJyYXJ5KFwiQGRlY2FmLXRzL2RlY29yYXRpb25cIiwgVkVSU0lPTik7XG4iXX0=

package/lib/index.d.ts

@@ -1,11 +1,10 @@
 /**
- * @description Root entry point for the decoration module
- * @summary Aggregates and re-exports the public API of the decoration library, including core classes like {@link Decoration}, utility decorators, metadata helpers, and constants. This module is the primary import surface for consumers and exposes:
+ * @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}
+ * - Decorator utilities: {@link module:decoration|decorators in ./decorators}
  * - Metadata utilities: {@link Metadata}
  * - Constants and enums: {@link DecorationKeys}, {@link DefaultFlavour}
- *
  * @module decoration
  */
 export * from "./decoration";
@@ -18,4 +17,4 @@ export * from "./decorators";
  * @const VERSION
  * @memberOf module:decoration
  */
-export declare const VERSION = "0.0.7";
+export declare const VERSION = "0.0.9";