@cldmv/slothlet 3.2.3 → 3.3.2

package/types/dist/lib/handlers/unified-wrapper.d.mts

@@ -1,250 +1,37 @@
-/**
- * Resolves a value to its backing UnifiedWrapper instance.
- * Accepts a proxy registered via createProxy() or a raw UnifiedWrapper instance.
- * Returns null for any other value.
- *
- * @param {unknown} value - Value to resolve
- * @returns {UnifiedWrapper|null} The backing wrapper, or null
- *
- * @example
- * const wrapper = resolveWrapper(someProxy);
- * if (wrapper) wrapper.____slothletInternal.impl = newImpl;
- */
-export function resolveWrapper(value: unknown): UnifiedWrapper | null;
 export namespace TYPE_STATES {
     let UNMATERIALIZED: symbol;
     let IN_FLIGHT: symbol;
 }
-/**
- * Unified wrapper class that handles all proxy concerns in one place:
- * - __impl pattern for reload support
- * - Lazy/eager mode materialization
- * - Recursive waiting proxy for deep lazy loading
- * - Context binding through contextManager
- *
- * @class
- * @extends ComponentBase
- * @public
- */
 export class UnifiedWrapper extends ComponentBase {
-    /**
-     * Shallow-clone a non-Proxy object implementation to prevent ___adoptImplChildren
-     * from mutating shared module export references via its `delete this.____slothletInternal.impl[key]`
-     * operations. When concurrent materializations (e.g., old + new wrapper during reload)
-     * both load the same cached module, the first ___adoptImplChildren would destroy the
-     * shared export, causing subsequent wrappers to receive empty objects.
-     *
-     * Returns the value unchanged if it is not a plain object, or if it IS a Proxy
-     * (cloning a Proxy destroys its trap behavior - e.g., LG TV controllers using
-     * numeric-index access through custom get traps).
-     *
-     * @param {*} value - The implementation value to (maybe) clone.
-     * @returns {*} A shallow clone of `value` when it is a non-Proxy plain object,
-     *              otherwise the original `value`.
-     * @static
-     * @private
-     */
-    private static _cloneImpl;
-    /**
-     * Reconstruct a full implementation object from a wrapper whose _impl may have
-     * been depleted by ___adoptImplChildren.
-     *
-     * @description
-     * After ___adoptImplChildren runs, children are moved from _impl onto the wrapper as
-     * own properties and deleted from _impl. This helper reconstructs the original
-     * impl by merging the remaining _impl keys with the adopted children extracted
-     * from the wrapper.
-     *
-     * Recursively walks the wrapper tree so nested objects whose _impl was also
-     * depleted are properly reconstructed. For callable (function) impls, returns
-     * the function directly since keepImplProperties prevents depletion.
-     *
-     * @param {Object} wrapper - The UnifiedWrapper instance to extract from
-     * @returns {*} The reconstructed implementation mirroring original module exports
-     * @static
-     * @private
-     */
-    private static _extractFullImpl;
-    /**
-     * @param {Object} slothlet - Slothlet instance (provides contextManager, instanceID, ownership)
-     * @param {Object} options - Configuration options
-     * @param {string} options.mode - "lazy" or "eager"
-     * @param {string} options.apiPath - API path for this wrapper (e.g., "math.advanced.calc")
-     * @param {Object} [options.initialImpl=null] - Initial implementation (null for lazy mode)
-     * @param {Function} [options.materializeFunc=null] - Async function to materialize lazy modules
-     * @param {boolean} [options.isCallable=false] - Whether the wrapper should be callable
-     * @param {boolean} [options.materializeOnCreate=false] - Whether to materialize on creation
-     * @param {string} [options.filePath=null] - File path of the module source
-     * @param {string} [options.moduleID=null] - Module identifier
-     * @param {string} [options.sourceFolder=null] - Source folder for metadata
-     *
-     * @description
-     * Creates a unified wrapper instance for a specific API path. Extends ComponentBase
-     * to access slothlet.contextManager, slothlet.instanceID, and slothlet.handlers.ownership.
-     *
-     * @example
-     * const wrapper = new UnifiedWrapper(this.slothlet, {
-     * 	mode: "lazy",
-     * 	apiPath: "math",
-     * 	initialImpl: null,
-     * 	materializeFunc: async () => import("./math.mjs")
-     * });
-     */
+    [x: number]: (____depth: any, ____options: any, ____inspect: any) => any;
+    static _cloneImpl(value: any): any;
+    static _extractFullImpl(wrapper: any): any;
     constructor(slothlet: any, { mode, apiPath, initialImpl, materializeFunc, isCallable, materializeOnCreate, filePath, moduleID, sourceFolder }: {
-        mode: string;
-        apiPath: string;
-        initialImpl?: any;
-        materializeFunc?: Function;
-        isCallable?: boolean;
-        materializeOnCreate?: boolean;
-        filePath?: string;
-        moduleID?: string;
-        sourceFolder?: string;
+        mode: any;
+        apiPath: any;
+        initialImpl?: null | undefined;
+        materializeFunc?: null | undefined;
+        isCallable: any;
+        materializeOnCreate?: boolean | undefined;
+        filePath?: null | undefined;
+        moduleID?: null | undefined;
+        sourceFolder?: null | undefined;
     });
-    /**
-     * Internal state accessor used by framework-internal code only.
-     * Backed by the private `#internal` field - prototype property, not an own property,
-     * so proxy invariants never apply and getTrap can legally return undefined for it.
-     *
-     * Uses a private-field brand check (`#internal in this`) so the getter is safe to
-     * invoke with any receiver - including `UnifiedWrapper.prototype` itself during a
-     * prototype chain walk via `Object.getPrototypeOf` - without throwing a TypeError.
-     * Without the brand check, `Object.getPrototypeOf(proxy).____slothletInternal` would
-     * throw because the prototype object was never constructed and has no `#internal` field.
-     * @returns {Object|undefined} Internal state container, or undefined for non-instances
-     */
-    get ____slothletInternal(): any | undefined;
-    /**
-     * Get current implementation
-     * @returns {Object|null} Current __impl value
-     * @public
-     */
-    public get __impl(): any | null;
-    /**
-     * Core implementation-application logic shared by ___setImpl and lazy materialization.
-     * Clones the implementation (protecting the API cache from ___adoptImplChildren's
-     * delete operations), clears the invalid flag, upgrades __isCallable when a
-     * callable impl arrives on a configurable wrapper, updates __filePath for lazy
-     * folder wrappers, and adopts children.
-     *
-     * @param {*} newImpl - The new implementation value.
-     * @param {boolean} [forceReuseChildren=false] - When true, always reuse existing child
-     *   wrappers regardless of mode (used by ___setImpl to preserve live references).
-     * @private
-     */
-    private _applyNewImpl;
-    /**
-     * Set new implementation and adopt children.
-     * Delegates core impl work to _applyNewImpl, then emits lifecycle events
-     * and updates materialization state.
-     *
-     * @param {*} newImpl - New implementation
-     * @param {string} [moduleID] - Optional moduleID for lifecycle event (for replacements)
-     * @param {boolean} [forceReuseChildren=false] - When true, always reuse existing child
-     *   wrappers and bypass collision-merged key guards. Use this for direct/explicit
-     *   ___setImpl calls where reference preservation is the intent. Do NOT set for
-     *   hot-reload paths (syncWrapper) where lazy refs should intentionally break.
-     * @private
-     */
-    private ___setImpl;
-    /**
-     * Reset wrapper to un-materialized lazy state with a fresh materialization function.
-     * Used during reload to restore lazy wrappers to their shell state instead of
-     * eagerly loading all implementations. Preserves proxy identity so existing
-     * references continue to work - next property access triggers materialization
-     * from the fresh materializeFunc (which reads updated source files from disk).
-     * @param {Function} newMaterializeFunc - Fresh materialization function from rebuild
-     * @returns {void}
-     * @private
-     */
-    private ___resetLazy;
-    /**
-     * Trigger materialization (lazy mode only)
-     * @returns {Promise<void>}
-     * @private
-     */
-    private ___materialize;
-    /**
-     * @private
-     * @returns {Promise<void>}
-     *
-     * @description
-     * Exposes lazy materialization for waiting proxies and nested wrappers.
-     *
-     * @example
-     * await wrapper._materialize();
-     */
-    private _materialize;
-    /**
-     * @private
-     * @returns {void}
-     *
-     * @description
-     * Invalidates this wrapper when its parent removes the API path.
-     *
-     * @example
-     * wrapper.___invalidate();
-     */
-    private ___invalidate;
-    /**
-     * @private
-     * @returns {void}
-     *
-     * @description
-     * Moves child properties off the impl and attaches them to wrapper as properties
-     * so this wrapper only represents the current API path.
-     *
-     * @example
-     * wrapper.___adoptImplChildren();
-     */
-    private ___adoptImplChildren;
-    /**
-     * @private
-     * @param {string|symbol} key - Child property name
-     * @param {unknown} value - Child value
-     * @returns {Object|Function|undefined} Wrapped child proxy when applicable
-     *
-     * @description
-     * Creates a child wrapper for impl values, including primitives.
-     *
-     * @example
-     * const child = wrapper.___createChildWrapper("add", fn);
-     */
-    private ___createChildWrapper;
-    /**
-     * Create recursive waiting proxy for deep lazy loading
-     * Builds property chain (e.g., ["advanced", "calc", "power"]) and waits for all parent
-     * wrappers to materialize before accessing the final property.
-     *
-     * Waiting proxies are ONLY created when not materialized or in-flight.
-     * Once materialized, we return actual cached values, not waiting proxies.
-     * Therefore, waiting proxies always represent in-flight/unmaterialized state.
-     *
-     * CRITICAL: Caches waiting proxies by propChain key to ensure subsequent accesses
-     * return the SAME proxy object, which can then delegate once materialization completes.
-     * This matches v2's propertyProxyCache behavior.
-     *
-     * @private
-     * @param {Array<string|symbol>} [propChain=[]] - Property chain to resolve.
-     * @returns {Proxy} Proxy that waits for materialization before applying calls.
-     */
-    private ___createWaitingProxy;
-    /**
-     * Create main proxy for this wrapper
-     * Handles lazy/eager mode logic, property access, and context binding
-     *
-     * @returns {Proxy} Main proxy for API
-     * @public
-     */
-    public createProxy(): ProxyConstructor;
-    lastSyncError: any;
-    /**
-     * Custom inspect output for Node.js util.inspect.
-     * @returns {*} The actual implementation for inspection.
-     */
-    [util.inspect.custom](____depth: any, ____options: any, ____inspect: any): any;
+    get ____slothletInternal(): null | undefined;
+    get __impl(): any;
+    _applyNewImpl(newImpl: any, forceReuseChildren?: boolean): void;
+    ___setImpl(newImpl: any, moduleID?: null, forceReuseChildren?: boolean): void;
+    ___resetLazy(newMaterializeFunc: any): void;
+    ___materialize(): Promise<any>;
+    _materialize(): Promise<any>;
+    ___invalidate(): void;
+    ___adoptImplChildren(forceReuseChildren?: boolean): void;
+    ___createChildWrapper(key: any, value: any): any;
+    ___createWaitingProxy(propChain?: any[]): any;
+    createProxy(): any;
+    lastSyncError: unknown;
     #private;
 }
+export function resolveWrapper(value: any): any;
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
-import util from "node:util";
 //# sourceMappingURL=unified-wrapper.d.mts.map

package/types/dist/lib/handlers/unified-wrapper.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unified-wrapper.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/unified-wrapper.mjs"],"names":[],"mappings":"AAgwGA;;;;;;;;;;;GAWG;AACH,sCAPW,OAAO,GACL,cAAc,GAAC,IAAI,CAkB/B;;;;;AA5qGD;;;;;;;;;;GAUG;AACH;IAiQC;;;;;;;;;;;;;;;;OAgBG;IACH,0BA8BC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,gCA0DC;IApWD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,+IAtBG;QAAwB,IAAI,EAApB,MAAM;QACU,OAAO,EAAvB,MAAM;QACW,WAAW;QACT,eAAe;QAChB,UAAU,GAA5B,OAAO;QACW,mBAAmB,GAArC,OAAO;QACU,QAAQ,GAAzB,MAAM;QACW,QAAQ,GAAzB,MAAM;QACW,YAAY,GAA7B,MAAM;KAEd,EA4KF;IA1MD;;;;;;;;;;;OAWG;IACH,4BAFa,MAAO,SAAS,CAK5B;IA+ND;;;;OAIG;IACH,qBAHa,MAAO,IAAI,CAKvB;IAkID;;;;;;;;;;;OAWG;IACH,sBAiCC;IAED;;;;;;;;;;;;OAYG;IACH,mBAgDC;IAED;;;;;;;;;OASG;IACH,qBAmDC;IAED;;;;OAIG;IACH,uBA+FC;IAED;;;;;;;;;OASG;IACH,qBAEC;IAED;;;;;;;;;OASG;IACH,sBAiBC;IAED;;;;;;;;;;OAUG;IACH,6BA2bC;IAED;;;;;;;;;;;OAWG;IACH,8BAwIC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,8BAmpBC;IAED;;;;;;OAMG;IACH,uCA4rCC;IAvVE,mBAA0B;IAzlF7B;;;OAGG;IACH,2EAFa,GAAC,CA8Bb;;CAi5FD;8BAxuG6B,0CAA0C;iBADvD,WAAW"}
+{"version":3,"file":"unified-wrapper.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/unified-wrapper.mjs"],"names":[],"mappings":";;;;AAA+vC;;IAA6jH,mCAAsc;IAAA,2CAAy/B;IAA32J;;;;;;;;;;OAAq1F;IAA56F,6CAAuF;IAAy3G,kBAAmD;IAA+7C,gEAAqyB;IAAA,8EAAgsC;IAAA,4CAA2kC;IAAA,+BAAs4D;IAAA,6BAA4C;IAAA,sBAA8T;IAAA,yDAAq6P;IAAA,iDAA2sG;IAAA,8CAA20Y;IAAA,mBAA4xwB;IAA3oO,uBAAwB;;CAAonO;AAAA,gDAA8N;8BAAt12D,0CAA0C"}

package/types/dist/lib/handlers/version-manager.d.mts

@@ -1,232 +1,35 @@
-/**
- * Manages versioned API paths and their dispatcher proxies.
- *
- * Allows the same logical API path (e.g. `auth`) to be registered under multiple
- * version tags (e.g. `v1`, `v2`). A dispatcher proxy lives at the logical path and
- * routes property accesses to the correct versioned namespace at call time.
- *
- * @class VersionManager
- * @extends ComponentBase
- * @package
- */
 export class VersionManager extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Register a new version for a logical path and rebuild the dispatcher.
-     *
-     * @param {string} logicalPath - Logical API path (e.g. `"auth"`).
-     * @param {string} versionTag - Version tag (e.g. `"v1"`).
-     * @param {string} moduleID - Module ID of the mounted versioned module.
-     * @param {object} versionMeta - User-supplied version metadata (stored in VersionManager only).
-     * @param {boolean} isDefault - Whether this version should be the explicit default.
-     * @returns {void}
-     * @example
-     * versionManager.registerVersion("auth", "v1", "auth_abc", { stable: true }, true);
-     */
-    registerVersion(logicalPath: string, versionTag: string, moduleID: string, versionMeta: object, isDefault: boolean): void;
-    /**
-     * Unregister a version for a logical path.
-     * Rebuilds or tears down the dispatcher accordingly.
-     *
-     * @param {string} logicalPath - Logical API path.
-     * @param {string} versionTag - Version tag to remove.
-     * @returns {boolean} `true` when the version was found and removed.
-     * @example
-     * versionManager.unregisterVersion("auth", "v2");
-     */
-    unregisterVersion(logicalPath: string, versionTag: string): boolean;
-    /**
-     * Get the version key (logicalPath + versionTag) for a given module ID.
-     * Used as a reverse lookup during remove operations.
-     *
-     * @param {string} moduleID - Module ID.
-     * @returns {{ logicalPath: string, versionTag: string } | undefined}
-     * @example
-     * versionManager.getVersionKeyForModule("auth_abc123"); // { logicalPath: "auth", versionTag: "v1" }
-     */
-    getVersionKeyForModule(moduleID: string): {
-        logicalPath: string;
-        versionTag: string;
+    registerVersion(logicalPath: any, versionTag: any, moduleID: any, versionMeta: any, isDefault: any): void;
+    unregisterVersion(logicalPath: any, versionTag: any): boolean;
+    getVersionKeyForModule(moduleID: any): any;
+    hasDispatcher(logicalPath: any): boolean;
+    getVersionMetadata(moduleID: any): any;
+    getVersionMetadataByPath(logicalPath: any, versionTag: any): any;
+    setVersionMetadataByPath(logicalPath: any, versionTag: any, patch: any): void;
+    list(logicalPath: any): {
+        versions: {};
+        default: any;
     } | undefined;
-    /**
-     * Returns `true` when a live dispatcher proxy is tracked for the given logical path.
-     * Used by ApiManager to detect whether a removed path was a logical dispatcher.
-     *
-     * @param {string} logicalPath - Logical API path (e.g. `"auth"`).
-     * @returns {boolean}
-     * @example
-     * versionManager.hasDispatcher("auth"); // true
-     */
-    hasDispatcher(logicalPath: string): boolean;
-    /**
-     * Retrieve the VersionManager-only metadata object stored for a module ID.
-     * Used internally by `buildAllVersionsArg` and `buildCallerArg`.
-     *
-     * @param {string} moduleID - Opaque module ID.
-     * @returns {object | undefined} Stored version metadata or `undefined`.
-     * @example
-     * versionManager.getVersionMetadata("auth_abc123"); // { version: "v1", logicalPath: "auth", stable: true }
-     */
-    getVersionMetadata(moduleID: string): object | undefined;
-    /**
-     * Retrieve the VersionManager-only metadata for a logical path and version tag.
-     *
-     * @param {string} logicalPath - Logical API path (e.g. `"auth"`).
-     * @param {string} versionTag - Version tag (e.g. `"v1"`, `"2.3.0"`).
-     * @returns {object | undefined} Stored version metadata or `undefined` if not registered.
-     * @example
-     * versionManager.getVersionMetadataByPath("auth", "v1"); // { version: "v1", logicalPath: "auth", stable: true }
-     */
-    getVersionMetadataByPath(logicalPath: string, versionTag: string): object | undefined;
-    /**
-     * Patch (merge) the VersionManager-only metadata for a registered logical path and version tag at runtime.
-     * The injected `version` and `logicalPath` keys always win over any user-supplied fields in `patch`.
-     *
-     * @param {string} logicalPath - Logical API path (e.g. `"auth"`).
-     * @param {string} versionTag - Version tag (e.g. `"v1"`, `"2.3.0"`).
-     * @param {object} patch - Plain object of keys to merge into the stored version metadata.
-     * @returns {void}
-     * @throws {SlothletError} When the logical path or version tag is not registered.
-     * @example
-     * versionManager.setVersionMetadataByPath("auth", "v1", { stable: true });
-     */
-    setVersionMetadataByPath(logicalPath: string, versionTag: string, patch: object): void;
-    /**
-     * Return a snapshot of all registered versions and the default tag for a logical path.
-     *
-     * @param {string} logicalPath - Logical API path.
-     * @returns {{ versions: object, default: string | null } | undefined} Snapshot object, or `undefined` if the path is not registered.
-     * @example
-     * versionManager.list("auth"); // { versions: { v1: {...}, v2: {...} }, default: "v2" }
-     * versionManager.list("unknown"); // undefined
-     */
-    list(logicalPath: string): {
-        versions: object;
-        default: string | null;
-    } | undefined;
-    /**
-     * Explicitly override the default version for a logical path at runtime.
-     * Clears any previous explicit defaults and marks only the specified tag.
-     *
-     * @param {string} logicalPath - Logical API path.
-     * @param {string} versionTag - Version tag to set as default.
-     * @returns {void}
-     * @throws {SlothletError} When the version tag is not registered for the path.
-     * @example
-     * versionManager.setDefault("auth", "v1");
-     */
-    setDefault(logicalPath: string, versionTag: string): void;
-    /**
-     * Determine the default version tag for a logical path.
-     *
-     * Algorithm:
-     * 1. Return the first version entry with `isDefault === true`.
-     * 2. Otherwise, normalise all tags, sort descending, return highest.
-     * 3. Return `null` when no versions are registered.
-     *
-     * @param {string} logicalPath - Logical API path.
-     * @returns {string | null} The default version tag, or `null`.
-     * @example
-     * // Given: ["v1", "v3", "v8", "v2"]
-     * versionManager.getDefaultVersion("auth"); // "v8"
-     */
-    getDefaultVersion(logicalPath: string): string | null;
-    /**
-     * Run the configured discriminator and return the winning version tag.
-     *
-     * When the configured `versionDispatcher` is a string, reads that key from
-     * `caller.versionMetadata`. When it is a function, calls it with `(allVersions, caller)`.
-     *
-     * @param {string} logicalPath - Logical API path.
-     * @param {object} allVersions - Pre-built allVersions arg (see `buildAllVersionsArg`).
-     * @param {object} caller - Pre-built caller arg (see `buildCallerArg`).
-     * @returns {string | null} Resolved version tag, or `null` to fall through to default.
-     * @example
-     * const tag = versionManager.resolveForPath("auth", allVersions, caller); // "v2"
-     */
-    resolveForPath(logicalPath: string, allVersions: object, caller: object): string | null;
-    /**
-     * Build the `allVersions` argument passed to function discriminators.
-     *
-     * Each key is a version tag; each value contains `version`, `default`, `metadata`
-     * (regular Metadata system data), and `versionMetadata` (VersionManager-only store).
-     *
-     * @param {string} logicalPath - Logical API path.
-     * @returns {object} Map-like object keyed by version tag.
-     * @example
-     * versionManager.buildAllVersionsArg("auth");
-     * // { v1: { version: "v1", default: true, metadata: {...}, versionMetadata: {...} } }
-     */
-    buildAllVersionsArg(logicalPath: string): object;
-    /**
-     * Build the `caller` argument passed to function discriminators.
-     *
-     * Returns `null` for version-specific fields when the caller is not a registered
-     * versioned module.
-     *
-     * @param {object | null | undefined} callerWrapper - The caller's UnifiedWrapper proxy.
-     * @returns {{ version: string|null, default: boolean|null, metadata: object, versionMetadata: object|null }}
-     * @example
-     * versionManager.buildCallerArg(callerWrapper);
-     * // { version: "v2", default: false, metadata: {...}, versionMetadata: {...} }
-     */
-    buildCallerArg(callerWrapper: object | null | undefined): {
-        version: string | null;
-        default: boolean | null;
-        metadata: object;
-        versionMetadata: object | null;
+    setDefault(logicalPath: any, versionTag: any): void;
+    getDefaultVersion(logicalPath: any): any;
+    resolveForPath(logicalPath: any, allVersions: any, caller: any): any;
+    buildAllVersionsArg(logicalPath: any): {};
+    buildCallerArg(callerWrapper: any): {
+        version: null;
+        default: null;
+        metadata: any;
+        versionMetadata: null;
+    } | {
+        version: any;
+        default: boolean;
+        metadata: any;
+        versionMetadata: any;
     };
-    /**
-     * Create a native Proxy that dispatches property accesses to the correct versioned path.
-     *
-     * The dispatcher handles all property categories defined in the spec (framework
-     * internal keys, stable framework accessors, `then`, symbols, routing, etc.).
-     *
-     * @param {string} logicalPath - Logical API path this dispatcher covers.
-     * @returns {object} A Proxy instance for version-dispatched property access. The returned
-     *   value is a Proxy wrapping a frozen plain-object target; it is NOT the Proxy constructor.
-     * @example
-     * const proxy = versionManager.createDispatcher("auth");
-     * proxy.login; // resolves version then returns api.v2.auth.login
-     */
-    createDispatcher(logicalPath: string): object;
-    /**
-     * Rebuild (or create) the dispatcher proxy for a logical path and mount it
-     * on both `api` and `boundApi`.
-     *
-     * @param {string} logicalPath - Logical API path.
-     * @returns {void}
-     * @example
-     * versionManager.updateDispatcher("auth");
-     */
-    updateDispatcher(logicalPath: string): void;
-    /**
-     * Tear down the dispatcher for a logical path, removing it from the API tree.
-     *
-     * @param {string} logicalPath - Logical API path.
-     * @returns {void}
-     * @example
-     * versionManager.teardownDispatcher("auth");
-     */
-    teardownDispatcher(logicalPath: string): void;
-    /**
-     * Called after a versioned module is reloaded.
-     * Refreshes internal metadata and rebuilds the dispatcher for the affected path.
-     *
-     * @param {string} moduleID - Module ID that was reloaded.
-     * @returns {void}
-     * @example
-     * versionManager.onVersionedModuleReload("auth_abc");
-     */
-    onVersionedModuleReload(moduleID: string): void;
-    /**
-     * Clear all internal state.
-     * Called automatically by the shutdown sequence.
-     *
-     * @returns {void}
-     * @example
-     * versionManager.shutdown();
-     */
+    createDispatcher(logicalPath: any): any;
+    updateDispatcher(logicalPath: any): void;
+    teardownDispatcher(logicalPath: any): void;
+    onVersionedModuleReload(moduleID: any): void;
     shutdown(): void;
     #private;
 }

package/types/dist/lib/handlers/version-manager.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"version-manager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/version-manager.mjs"],"names":[],"mappings":"AAsGA;;;;;;;;;;GAUG;AACH;IACC,gCAA2C;IA8B3C;;;;;;;;;;;OAWG;IACH,6BATW,MAAM,cACN,MAAM,YACN,MAAM,eACN,MAAM,aACN,OAAO,GACL,IAAI,CAyDhB;IAED;;;;;;;;;OASG;IACH,+BANW,MAAM,cACN,MAAM,GACJ,OAAO,CAqCnB;IAED;;;;;;;;OAQG;IACH,iCALW,MAAM,GACJ;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAMnE;IAED;;;;;;;;OAQG;IACH,2BALW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;;;;;OAQG;IACH,6BALW,MAAM,GACJ,MAAM,GAAG,SAAS,CAM9B;IAED;;;;;;;;OAQG;IACH,sCANW,MAAM,cACN,MAAM,GACJ,MAAM,GAAG,SAAS,CAU9B;IAED;;;;;;;;;;;OAWG;IACH,sCARW,MAAM,cACN,MAAM,SACN,MAAM,GACJ,IAAI,CAwBhB;IAED;;;;;;;;OAQG;IACH,kBANW,MAAM,GACJ;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,SAAS,CAcpE;IAED;;;;;;;;;;OAUG;IACH,wBAPW,MAAM,cACN,MAAM,GACJ,IAAI,CAwBhB;IAID;;;;;;;;;;;;;OAaG;IACH,+BANW,MAAM,GACJ,MAAM,GAAG,IAAI,CAqCzB;IAID;;;;;;;;;;;;OAYG;IACH,4BAPW,MAAM,eACN,MAAM,UACN,MAAM,GACJ,MAAM,GAAG,IAAI,CAkDzB;IAID;;;;;;;;;;;OAWG;IACH,iCANW,MAAM,GACJ,MAAM,CAmClB;IAED;;;;;;;;;;;OAWG;IACH,8BANW,MAAM,GAAG,IAAI,GAAG,SAAS,GACvB;QAAE,OAAO,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,OAAO,EAAE,OAAO,GAAC,IAAI,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,GAAC,IAAI,CAAA;KAAE,CAkC3G;IA0DD;;;;;;;;;;;;OAYG;IACH,8BAPW,MAAM,GACJ,MAAM,CA6elB;IAED;;;;;;;;OAQG;IACH,8BALW,MAAM,GACJ,IAAI,CAiChB;IAED;;;;;;;OAOG;IACH,gCALW,MAAM,GACJ,IAAI,CAkBhB;IAID;;;;;;;;OAQG;IACH,kCALW,MAAM,GACJ,IAAI,CAmBhB;IAED;;;;;;;OAOG;IACH,YAJa,IAAI,CAShB;;CACD;8BAttC6B,0CAA0C"}
+{"version":3,"file":"version-manager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/version-manager.mjs"],"names":[],"mappings":"AAA2jB;IAA2C,gCAAyC;IAAoG,0GAAu4B;IAAA,8DAA8kB;IAAA,2CAA+E;IAAA,yCAAqE;IAAA,uCAAgF;IAAA,iEAAwO;IAAA,8EAA8d;IAAA;;;kBAA+N;IAAA,oDAA8Z;IAAA,yCAAihB;IAAA,qEAAyxB;IAAA,0CAA+gB;IAAA;;;;;;;;;;MAAurB;IAAsc,wCAA4+K;IAAA,yCAA8kB;IAAA,2CAAwU;IAAA,6CAA2Q;IAAA,iBAAmI;;CAAC;8BAA93a,0CAA0C"}

package/types/dist/lib/helpers/class-instance-wrapper.d.mts

@@ -1,54 +1,4 @@
-/**
- * @function runtime_shouldWrapMethod
- * @package
- * @param {*} value - The value to check
- * @param {string|symbol} prop - The property name
- * @returns {boolean} True if the method should be wrapped
- *
- * @description
- * Determines if a method should be wrapped with context preservation.
- * Excludes constructors, Object.prototype methods, and internal methods.
- *
- * @example
- * runtime_shouldWrapMethod(myInstance.method, "method"); // true
- * runtime_shouldWrapMethod(myInstance.constructor, "constructor"); // false
- */
-export function runtime_shouldWrapMethod(value: any, prop: string | symbol): boolean;
-/**
- * @function runtime_isClassInstance
- * @package
- * @param {*} val - The value to check
- * @returns {boolean} True if the value is a class instance that should be wrapped
- *
- * @description
- * Determines if a value is a class instance (not a plain object, array, or primitive)
- * that should have its methods wrapped to preserve AsyncLocalStorage context.
- * Uses systematic exclusion lists for better maintainability.
- *
- * @example
- * // Check if value is a class instance
- * const isInstance = runtime_isClassInstance(new MyClass());
- */
 export function runtime_isClassInstance(val: any): boolean;
-/**
- * @function runtime_wrapClassInstance
- * @package
- * @param {object} instance - The class instance to wrap
- * @param {object} contextManager - The context manager (async or live)
- * @param {string} instanceID - The slothlet instance ID
- * @param {WeakMap} instanceCache - The cache for wrapped instances
- * @returns {Proxy} A proxied instance with context-aware method calls
- *
- * @description
- * Wraps a class instance so that all method calls maintain the AsyncLocalStorage context.
- * This ensures that calls to methods on returned class instances preserve the slothlet
- * context for runtime imports like `self` and `context`.
- *
- * V3 Adaptation: Uses contextManager.runInContext() instead of V2's runWithCtx().
- *
- * @example
- * // Wrap a class instance to preserve context
- * const wrappedInstance = runtime_wrapClassInstance(instance, contextManager, instanceID, instanceCache);
- */
-export function runtime_wrapClassInstance(instance: object, contextManager: object, instanceID: string, instanceCache: WeakMap<any, any>): ProxyConstructor;
+export function runtime_shouldWrapMethod(value: any, prop: any): boolean;
+export function runtime_wrapClassInstance(instance: any, contextManager: any, instanceID: any, instanceCache: any): any;
 //# sourceMappingURL=class-instance-wrapper.d.mts.map

package/types/dist/lib/helpers/class-instance-wrapper.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"class-instance-wrapper.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/class-instance-wrapper.mjs"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;GAcG;AACH,gDAZW,GAAC,QACD,MAAM,GAAC,MAAM,GACX,OAAO,CAkBnB;AAED;;;;;;;;;;;;;;GAcG;AACH,6CAZW,GAAC,GACC,OAAO,CA6BnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,oDAjBW,MAAM,kBACN,MAAM,cACN,MAAM,sDA8EhB"}
+{"version":3,"file":"class-instance-wrapper.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/class-instance-wrapper.mjs"],"names":[],"mappings":"AAA2X,2DAAmT;AAAre,yEAAkL;AAAmT,wHAAwkC"}