@otorp/plugin-utils 1.0.0 → 1.0.1-0

package/README.md

@@ -8,9 +8,9 @@
 <!-- omit in toc -->
 ## 🎯 Objective
 
-Small, init-time utilities extracted from the Otorp core so plugin authors can register modules without duplicating boilerplate or reimplementing the shared symbol registry.
+Small, init-time utilities extracted from the Otorp monolith so plugin authors can register modules without duplicating boilerplate or reimplementing the shared symbol registry.
 
-This package does not extend prototypes or run Otorp's alias pass — it only wires your plugin into the registry that **Otorp core** consumes during initialization.
+This package does not extend prototypes or run Otorp's alias pass — it only wires your plugin into otorp plugin registry that **Otorp** consumes during initialization.
 
 ---
 
@@ -20,20 +20,42 @@ This package does not extend prototypes or run Otorp's alias pass — it only wi
 - [🚀 Quickstart](#-quickstart)
 - [📚 API](#-api)
   - [`setMod(config)`](#setmodconfig)
-  - [`newErrorHandler(modName?)`](#newerrorhandlermodname)
   - [`ref(key, value?)`](#refkey-value)
+  - [`newErrorHandler(modName?)`](#newerrorhandlermodname)
   - [`root`](#root)
 - [🔌 Plugin registration](#-plugin-registration)
   - [With `@otorp/plugin-utils` (recommended)](#with-otorpplugin-utils-recommended)
   - [Manual registration (equivalent)](#manual-registration-equivalent)
 - [❓ FAQ](#-faq)
+  - [Why a separate package?](#why-a-separate-package)
+  - [Do I need this package to write a plugin?](#do-i-need-this-package-to-write-a-plugin)
 - [🤝 Contributing](#-contributing)
 
 <!-- /TOC -->
 
 ## 📦 Installation
 
-> **Load order requirement:** this package — and your plugin script — must be registered **before** Otorp core initializes. Otorp deletes itself after its init pass; any plugin registered after that point will be silently ignored.
+Load **before** Otorp core, alongside your plugin script:
+
+```html
+<script type="module">
+  import { setMod, newErrorHandler } from './path/to/@otorp/plugin-utils/src/main.js';
+
+  const key = setMod({
+    source: 'myPlugin',
+    endpoints: { HTMLElement: ['myPlugin.customMethod'] },
+    modules(methodName) {
+      return function (...args) {
+        // `this` is the DOM instance
+      };
+    }
+  });
+
+  // Optional: use error helpers attached to the returned symbol key
+  key.warn('registered');
+</script>
+<script src="path/to/otorp.js"></script>
+```
 
 **npm**
 
@@ -42,51 +64,42 @@ npm install @otorp/plugin-utils
 ```
 
 ```javascript
-import setMod from '@otorp/plugin-utils';
-
+import { setMod } from '@otorp/plugin-utils';
 ```
 
+> **Requirement:** [Otorp core](https://gitlab.com/tdj.dev/otorp) must be loaded after your plugin. See the core README for configuration (`otorpConfig`), alias behaviour, and the init pass.
+
 ---
 
 ## 🚀 Quickstart
 
+Minimal plugin using `setMod`:
+
 ```javascript
-import setMod from '@otorp/plugin-utils';
+import { setMod } from '@otorp/plugin-utils';
 
 setMod({
   source: 'myPlugin',
   endpoints: {
     "HTMLElement": [
       'myPlugin.customMethod',
-      'myPlugin.meta1.meta2.customMethod'
+      'myPlugin.meta.customMethod'
     ]
   },
-  factory(methodName, ...meta) {
-    // methodName: last segment of the query string
-    // meta: everything between source and methodName
+  factory(customMethod, meta) {
     return function (...args) {
-      // `this` is the DOM instance at call time
+      // Installed on HTMLElement.prototype during Otorp init
     };
   }
 });
 ```
 
-**Query string anatomy:**
-
-```
-"myPlugin.meta1.meta2.methodName"
-    │       │     │       └── methodName  (passed as first arg to factory)
-    │       └─────┘────────── meta        (spread as remaining args to factory)
-    └────────────────────────── source    (identifies your plugin)
-```
-
 What `setMod` does in one call:
 
-1. Validates the `factory` argument.
-2. Tracks registration count to warn on duplicate source names.
-3. Registers `{ endpoints, aliases, key, count }` in the shared modules Map under `source`.
-4. Creates a unique symbol-like key object with `.throw`, `.warn`, and `.error` helpers attached.
-5. Assigns the factory to `root` under the returned key so Otorp core can invoke it once per resolved endpoint during init.
+1. Validates the `modules` factory.
+2. Registers `{ endpoints, aliases, key }` in the modules **Map** under `source`.
+3. Creates a unique symbol-like key object with `.throw`, `.warn`, and `.error` helpers.
+4. Assigns the factory to `window` under the returned key so Otorp core can invoke it once per resolved endpoint.
 
 ---
 
@@ -94,56 +107,39 @@ What `setMod` does in one call:
 
 All exports are init-time helpers. There is no runtime API after Otorp finishes its pass.
 
-### `setMod(config)` (Default Export)
+### `setMod(config)`
 
 Register a plugin module for Otorp's initialization pass.
 
-| Property | Type | Required | Description |
-| --- | --- | --- | --- |
-| `source` | `string` | ✓ | Unique module identifier — used as the Map key and as the first segment of endpoint query strings. |
-| `endpoints` | `Record<string, string[]>` | ✓ | Maps a target prototype name to an array of endpoint query strings (e.g. `{ HTMLElement: ['myPlugin.customMethod'] }`). |
-| `factory` | `Function` | ✓ | Called by Otorp once per resolved endpoint. Receives `(methodName, ...meta)` and must return the function to install on the prototype. |
-| `aliases` | `Record<string, string> \| null` | — | Optional alias map. Defaults to `null`. |
+| Property | Type | Description |
+| :--- | :--- | :--- |
+| `source` | `string` | Unique module id — used as the Map key. |
+| `endpoints` | `Record<string, string[]>` | Target prototype name → endpoint query strings. |
+| `modules` | `Function` | Factory called per endpoint; must return the function to install on the prototype. |
+| `aliases` | `Record<string, string> \| null` | Optional alias map. Default `null`. |
 
-**Returns:** A unique symbol-like key object (`Object(Symbol(source))`) with `.throw`, `.warn`, and `.error` error handlers attached.
+**Returns:** a Symbol-like object with attached `.throw`, `.warn`, and `.error` handlers.
 
----
+### `ref(key, value?)`
+
+Read or write an entry in Otorp namespace.
+
+- Pass a **truthy** `value` to assign and return it.
+- Omit `value` (or pass a falsy one) to read only.
 
 ### `newErrorHandler(modName?)`
 
-Creates a namespaced error handler. The namespace appears in `error.name` so stack traces remain readable.
+Creates a namespaced error handler. The namespace is written to `error.name`.
 
 | Callable | Behaviour |
 | :--- | :--- |
-| `handler(msg, opts?)` | Throws an `Error`. Accepts optional `{ type, cause }`. |
-| `handler.log(msg, opts?)` | `console.error` with the same formatting. |
-| `handler.warn(msg, opts?)` | `console.warn` with the same formatting. |
-
-```javascript
-import { newErrorHandler } from '@otorp/plugin-utils';
-
-const err = newErrorHandler('myPlugin');
-err('Missing endpoint');             // throws exeption "[myPlugin] Missing endpoint"
-err.log('Deprecated alias used');    // error log       "[myPlugin] Deprecated alias used"
-err.warn('Init failed', { cause });  // warning log     "[myPlugin - <cause.name>] Init failed"
-```
-
----
-
-### `ref(key, value?)`
-
-Read or write an entry in the Otorp namespace (`Symbol.for('otorp:' + key)` on `root`). Designed for registries, configuration objects, and shared tooling.
-
-* Pass a **truthy** `value` to assign and return it.
-* Omit `value` (or pass a falsy one) to read the current value.
-
-> Falsy values cannot be stored through this helper.
-
----
+| `handler(msg, options?)` | Throws an `Error` (optional `cause` / `type`). |
+| `handler.warn(...)` | `console.warn` with the same formatting. |
+| `handler.log(...)` | `console.error` with the same formatting. |
 
 ### `root`
 
-Minifier-friendly alias for `window`. Allows bundlers to mangle the identifier across the codebase, reducing bundle size without impacting runtime behavior.
+Shorthand for `window` — Minifier-friendly alias used internally and exposed for advanced plugin setups.
 
 ---
 
@@ -152,46 +148,42 @@ Minifier-friendly alias for `window`. Allows bundlers to mangle the identifier a
 ### With `@otorp/plugin-utils` (recommended)
 
 ```javascript
-import setMod from '@otorp/plugin-utils';
+import { setMod } from '@otorp/plugin-utils';
 
-const key = setMod({
+setMod({
   source: 'myPlugin',
-  endpoints: { "HTMLElement": ['myPlugin.customMethod'] },
-  factory(methodName, ...meta) {
+  endpoints: { HTMLElement: ['myPlugin.customMethod'] },
+  modules(methodName) {
     return function (...args) { /* … */ };
   }
 });
-
-key.warn('registered'); // "[myPlugin] registered"
-
 ```
 
 ### Manual registration (equivalent)
 
-If you prefer not to depend on this package, the same contract applies. Core expects a **Map**, tracks registration instances via `count`, and resolves factories from `window` object:
+If you prefer not to use this package, the same contract applies — core expects a **Map**, not a plain object:
 
 ```javascript
-const source = 'myPlugin';
-const pluginKey = Object(Symbol(source));
-const modulesMap = (window[Symbol.for('otorp:modules')] ??= new Map());
+const pluginKey = Object(Symbol('myPlugin'));
 
-// Core tracks duplicates, so you must supply the count.
-const count = (modulesMap.get(source)?.count || 0) + 1;
+Object.defineProperties(pluginKey, {
+  throw: { value: myErrHandler, writable: false, configurable: false },
+  warn:  { value: myErrHandler.warn, writable: false, configurable: false },
+  error: { value: myErrHandler.log, writable: false, configurable: false }
+});
 
-modulesMap.set(source, {
-  endpoints: { "HTMLElement": ['myPlugin.customMethod'] },
+(window[Symbol.for('otorp:modules')] ??= new Map()).set('myPlugin', {
+  endpoints: { HTMLElement: ['myPlugin.customMethod'] },
   aliases: null,
-  key: pluginKey,
-  count
+  key: pluginKey
 });
 
-// The factory must be exposed on the global object using the exact symbol object.
-window[pluginKey] = function factory(methodName, ...meta) {
+window[pluginKey] = function factory (methodName) {
   return function (...args) { /* … */ };
 };
 ```
 
-`setMod` exists so you do not maintain that boilerplate and the error handler logic in every plugin repo.
+`setMod` exists so you do not maintain that boilerplate in every plugin repo.
 
 ---
 
@@ -199,18 +191,16 @@ window[pluginKey] = function factory(methodName, ...meta) {
 
 ### Why a separate package?
 
-Otorp originally bundled core, helpers, and plugin utilities together. Splitting `@otorp/plugin-utils` keeps the core lean and gives plugin authors a stable, shared registration layer without copy-pasting registry code.
+Otorp originally bundled core, helpers, and plugin utilities in one repo. Splitting `@otorp/plugin-utils` keeps the core lean and gives plugin authors a stable, shared registration layer without copy-pasting registry code.
 
 ### Do I need this package to write a plugin?
 
-No. Any script that writes the correct shape into `otorp:modules` and `root[key]` before Otorp initializes will work. This package is the supported shortcut.
+No. Any script that writes the correct shape into `otorp:modules` and `root[key]` before Otorp loads will work. This package is the supported shortcut.
 
 ---
 
 ## 🤝 Contributing
 
-Contributions, bug reports, and feature requests are welcome.
+Contributions, bug reports, and feature requests are welcome! Please read [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 
-* **Homepage & Wiki:** [gitlab.com/otorp/plugin-utils/-/wikis/home](https://gitlab.com/otorp/plugin-utils/-/wikis/home)
-* **Issue Tracker:** [gitlab.com/otorp/plugin-utils/-/issues](https://gitlab.com/otorp/plugin-utils/-/issues)
-* **Core Otorp Docs:** [gitlab.com/tdj.dev/otorp](https://gitlab.com/tdj.dev/otorp)
+**Core Otorp docs:** [gitlab.com/tdj.dev/otorp](https://gitlab.com/tdj.dev/otorp)

package/index.js

@@ -1,173 +1,139 @@
-// ─── Public exports ───────────────────────────────────────────────────────────
-
-
-/** Register an Otorp plugin module for the initialization pass.
- *
- * Stores endpoint and aliases metadata in the shared Otorp modules Map,
- * attaches module-scoped error helpers to the returned key, and installs
- * the factory on `root` so Otorp core can resolve it during init.
- *
- * > **Load order:** must be called before Otorp core initializes.
- * > Otorp deletes itself after its init pass — late registrations are ignored.
- *
- * @param {object} config - Plugin registration payload.
- * @param {string} config.source - Unique module identifier. Used as the Map
- *   key and as the first segment of endpoint query strings.
- * @param {Record<string, string[]>} config.endpoints - Maps a target prototype
- *   name to an array of endpoint query strings.
- *   Format: `"source.meta1.meta2.methodName"` — everything between `source`
- *   and `methodName` is forwarded to `factory` as metadata.
- *   (e.g. `{ "HTMLElement": ['myPlugin.meta.customMethod'] }`)
- * @param {Function} config.factory - Called by Otorp once per resolved
- *   endpoint. Receives `(methodName, ...meta)` and must return the function
- *   to install on the prototype, where `this` will be the target instance.
- * @param {Record<string, string>|null} [config.aliases] - Optional alias
- *   map consumed by Otorp's aliaser during the init pass.
- * @returns {Object} A unique symbol-like key object (`Object(Symbol(source))`)
- *   with `.throw`, `.warn`, and `.error` error handlers attached.
- *   Otorp resolves the factory via `root[key]` — not through `Symbol.for`.
- *
- * @example
- * import setMod from '@otorp/plugin-utils'
- * const key = setMod({
- *   source: 'myPlugin',
- *   endpoints: { "HTMLElement": ['myPlugin.meta.customMethod'] },
- *   factory(methodName, ...meta) {
- *     return function (...args) { /* `this` is the DOM instance *\/ };
- *   }
- * });
- *
- * key.warn('registered'); // "[myPlugin] registered"
- */
-export default function ({ source, endpoints, factory, aliases = null }) {
-  typeof factory !== 'function' && err("factory must be a function")
-
-  // Non-global Symbol wrapped in Object() so it can carry properties (.throw,
-  // .warn, .error) while remaining usable as a Map/window key.
-  // Symbol.for is intentionally avoided — each registration must be isolated.
-  const key = Object(Symbol(source)), modErr = newErrorHandler(source);
-
-  // Attach scoped error helpers directly on the key so plugin authors can use
-  // them without importing newErrorHandler separately.
-  Object.defineProperties(key, propsDesc(modErr, modErr.log, modErr.warn));
-
-  // Track registration count so Otorp core can warn on duplicate source names
-  // (same source registered twice, or two plugins sharing the same identifier).
-  const count = (get(source)?.count || 0) + 1
-
-  set(source, { endpoints, aliases, key, count });
-
-  // Install factory under the unique key on root. Otorp reads root[key] during
-  // its init pass — it never uses Symbol.for to look up plugin factories.
-  return (root[key] = factory), key;
-}
-
-/** Creates a namespaced error handler.
- *
- * Returns a callable that throws an `Error`. The namespace appears in
- * `error.name` so stack traces remain readable.
- * `.warn` and `.log` variants emit to the console instead of throwing.
- *
- * @param {string} [modName] - Namespace prefix written to `error.name`.
- * @returns {((msg: string, options?: { type?: string, cause?: any }) => never) & { warn: Function, log: Function }}
- *
- * @example
- * const err = newErrorHandler('myPlugin');
- * err('Missing endpoint');            // throws    — name: "[myPlugin]"
- * err.log('Deprecated alias used');   // error log — name: "[myPlugin]"
- * err.warn('Init failed', { cause }); // warns     — name: "[myPlugin - <cause.name>]"
- */
-export function newErrorHandler(modName) {
-  let [prefix, separator, suffix] = modName ? [`[${modName}`, "-", "]"] : ["", "", ""];
-
-  /** Builds an Error and delegates to the bound `output` sink. */
-  function genErrHandler(msg, { type: errType, cause } = {}) {
-    const error = new Error(msg, { cause }), actualType = errType || cause?.name;
-    error.name = actualType
-      ? (`${prefix} ${separator} ${actualType + suffix}`).trim()
-      : prefix + suffix;
-    // V8-only: removes genErrHandler from the stack trace.
-    // Falls back to a no-op on other engines — full trace is kept.
-    (Error.captureStackTrace || (x => x))(error, genErrHandler);
-    this.output(error)
-  }
-
-  const myErrHandler = genErrHandler.bind({ output(err) { throw err } })
-  myErrHandler.log = genErrHandler.bind({ output(err) { console.error(err) } })
-  myErrHandler.warn = genErrHandler.bind({ output(err) { console.warn(err) } })
-  return myErrHandler
-}
-
+// public
 export const
 
-  /** Minifier-friendly alias for `window`.
-   *
-   * Allows bundlers to mangle the identifier across the codebase,
-   * reducing bundle size without impacting runtime behavior.
+  /** Uglyfiable shorthand for the window object.
    *
+   * Make the bundle more concise and lightweight 
+   * 
    * @type {Window}
    */
   root = window,
 
-  /** Read or write an entry in the Otorp namespace.
+  /** Read or write an entry in otorp namespace.
    *
-   * Keys are stored under `Symbol.for('otorp:' + key)` on `root`.
-   * Designed for registries, configuration objects, and shared tooling —
-   * not for arbitrary value storage. Falsy values cannot be written.
+   * Keys are stored as `Symbol.for('otorp:' + key)`. Pass a truthy `value` to
+   * assign and return it; omit `value` or pass a falsy one to read only. Falsy
+   * values cannot be stored through this helper.
    *
-   * @param {string} key - Entry name.
-   * @param {*} [value] - Truthy value to store. Omit to read.
+   * @param {string} key - Registry name (without the `otorp:` prefix).
+   * @param {*} [value] - Value to store. Must be truthy when writing.
    * @returns {*} The stored or newly assigned value.
    *
    * @example
-   * ref('modules', new Map()); // write
-   * ref('modules');            // read → same Map instance
+   * const modules = ref('modules', new Map()); // create registry
+   * ref('modules'); // → same Map instance
    */
-  ref = (key, value) => value
-    ? (root[sym(refPrefix + key)] = value)
-    : root[sym(refPrefix + key)];
-
-// ─── Private ──────────────────────────────────────────────────────────────────
-
-
-// Builds the descriptor map passed to `Object.defineProperties` on a plugin key.
-// Mutates `propsDescDummy` in place to avoid a per-call object allocation —
-// safe because defineProperties consumes the descriptors synchronously before
-// this function can be called again.
-function propsDesc(_throw, _error, _warn) {
-  propsDescDummy.throw.value = _throw
-  propsDescDummy.error.value = _error
-  propsDescDummy.warn.value = _warn
-  return propsDescDummy
-}
+  ref = (key, value) => value ? (root[sym(refPrefix + key)] = value) : root[sym(refPrefix + key)],
+
+  /** Creates a namespaced error logger.
+   *
+   * Returns a callable that throws an Error with an optional `cause`. The
+   * returned function also has `.warn` and `.log` variants that emit warnings or
+   * errors to the console instead of throwing.
+   *
+   * @param {string} [modName] - Optional namespace written to `error.name` (not `message`).
+   * @returns {((msg:string, options?:{type?:string, cause?:any})=>never) & { warn:Function, log:Function }}
+   *
+   * @example
+   * const err = newErrorHandler('myPlugin');
+   * err('Missing endpoint');           // throws: "[myPlugin] Missing endpoint"
+   * err.warn('Deprecated alias used'); // console.warn: "[myPlugin] Deprecated alias used'"
+   * err.log('Init failed', { cause }); // console.error => "[myPlugin - <cause>] Missing endpoint"
+   */
+  newErrorHandler = (modName) => {
+    let [prefix, separator, suffix] = modName ? [`[${modName}`, "-", "]"] : ["", "", ""];
+
+    /** Builds an Error and delegates to the bound `output` sink. */
+    function genErrHandler(msg, { type: errType, cause } = {}) {
+      const error = new Error(msg, { cause }), actualType = errType || cause?.name;
+      error.name = actualType ? (`${prefix} ${separator} ${actualType + suffix}`).trim() : prefix + suffix;
+      // V8 trims the factory from the stack; other engines keep the full trace.
+      (Error.captureStackTrace || (x => x))(error, genErrHandler);
+      this.output(error)
+    }
+    const myErrHandler = genErrHandler.bind({ output(err) { throw err } })
+    myErrHandler.log = genErrHandler.bind({ output(err) { console.error(err) } })
+    myErrHandler.warn = genErrHandler.bind({ output(err) { console.warn(err) } })
+    return myErrHandler
+  },
+
+  /** Register an Otorp plugin module for the initialization pass.
+   *
+   * Stores endpoint and aliases metadata in otorp module Map, exposes
+   * module-scoped error helpers on the plugin's symbol key, and installs the
+   * factory on root` so Otorp can resolve it from the registered `key`.
+   *
+   * @param {object} config - Plugin registration payload.
+   * @param {string} config.source - Unique module identifier used as the Map key.
+   * @param {Record<string, string[]>} config.endpoints - Target's name to
+   *   endpoint query strings (e.g. `{ "HTMLElement": ['myPlugin.customMethod'] }`).
+   * @param {Function} config.factory - Factory called during Otorp init; receives
+   *   the resolved method name and optional metadata segments, and must return
+   *   the function to install on the prototype.
+   * @param {Record<string, string>|null} [config.aliases=null] - Optional alias map.
+   * @returns {Object} A unique symbol object (via `Object(Symbol(source))`) with
+   *   `.throw`, `.warn`, and `.error` handlers attached. Otorp reads the factory
+   *   from `root[key]`, not from a global `Symbol.for` lookup.
+   *
+   * @example
+   * setMod({
+   *   source: 'myPlugin',
+   *   endpoints: { "HTMLElement": ['myPlugin.customMethod'] },
+   *   factory(methodName) {
+   *     return function (...args) { /* `this` is the DOM instance *\/ };
+   *   }
+   * });
+   */
+  setMod = ({ source, endpoints, factory, aliases = null }) => {
+    typeof factory !== 'function' && err("factory must be a function")
+
+    // Unique per call — Symbol(source), not Symbol.for. Otorp resolves the
+    // factory through the Map entry's `key`, keeping plugins isolated.
+    const key = Object(Symbol(source)), modErr = newErrorHandler(source);
+
+    // Attach throw / warn / log helpers to the symbol object itself.
+    Object.defineProperties(key, {
+      'throw': newDescritor(modErr),
+      'error': newDescritor(modErr.log),
+      'warn': newDescritor(modErr.warn),
+    });
+
+    const count = (get(source)?.count || 0) + 1
+
+    set(source, {
+      endpoints,
+      aliases,
+      key,
+      count
+    });
+
+    return (root[key] = factory), key;
+  };
 
+// private
 const
   /** Error handler for this package's own validation and setup failures. */
   err = newErrorHandler('@otorp/plugin-utils'),
 
-  /** Cached `Symbol.for` to avoid repeated property lookups on each `ref` call. */
+  /** Shorthand for `Symbol.for` to reduce resolution/lookup at each `ref` invocation. */
   sym = Symbol.for,
 
-  /** Namespace prefix used by `ref` to scope all Otorp entries on `root`. */
+  /** Otorp namespace. Used as prefix in the ref function */
   refPrefix = 'otorp:',
 
-  /** Bound Map#get and Map#set for the shared modules Map.
-   *
-   * The Map is retrieved (or created) once at module evaluation time.
-   * Methods are bound directly to avoid prototype lookups on every registration.
-   */
-  [get, set] = (map => [map.get.bind(map), map.set.bind(map)])(
-    ref('modules') || ref('modules', new Map)
-  ),
+  /** Bound `Map#set` to reduce resolution/lookup during plugins registration. */
+  [get, set] = (map => [map.get.bind(map), map.set.bind(map)])(ref('modules') || ref('modules', new Map));
 
-  /** Reusable descriptor map for attaching error helpers to plugin keys.
-   *
-   * Mutated in place by `propsDesc` before each `Object.defineProperties` call.
-   * The defined properties are non-writable and non-configurable on the target
-   * to prevent plugin authors from accidentally overwriting the error helpers.
-   */
-  propsDescDummy = {
-    throw: { value: null, writable: false, configurable: false },
-    error: { value: null, writable: false, configurable: false },
-    warn: { value: null, writable: false, configurable: false },
-  };
+/**
+ * @type {{ value: any, writable: boolean, configurable: boolean }}
+ */
+const descriptorDummy = Object.create(null)
+descriptorDummy.writable = descriptorDummy.configurable = false
+
+/**
+ * 
+ * @param {any} val
+ */
+export function newDescritor(val) {
+  return descriptorDummy.value = val, descriptorDummy
+}

package/package.json

@@ -1,27 +1,21 @@
 {
   "name": "@otorp/plugin-utils",
-  "version": "1.0.0",
-  "description": "Plugin registration and error-handling utilities for the Otorp ecosystem — minimal, zero side-effects.",
-  "exports": {
-    ".": "./index.js"
-  },
+  "version": "1.0.1-0",
+  "description": "",
+  "main": "main.js",
   "type": "module",
   "files": [
     "index.js"
   ],
   "keywords": [
-    "javascript",
-    "otorp",
-    "plugin",
-    "utilities",
-    "error-handler",
-    "registry"
+    "JavaScript",
+    "Otorp"
   ],
   "homepage": "https://gitlab.com/otorp/plugin-utils/-/wikis/home",
   "bugs": {
     "url": "https://gitlab.com/otorp/plugin-utils/-/issues"
   },
-  "author": "TISSOT Davy",
+  "author": "TDJ.dev",
   "license": "MIT",
   "repository": {
     "type": "git",