@cldmv/slothlet 3.2.3 → 3.3.2

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

@@ -1,16 +1,4 @@
-/**
- * Manages hooks for API function interception.
- * Supports before/after/always/error hooks with pattern matching and priority ordering.
- *
- * @class HookManager
- * @extends ComponentBase
- */
 export class HookManager extends ComponentBase {
-    /**
-     * Property name for auto-discovery
-     * @type {string}
-     * @static
-     */
     static slothletProperty: string;
     enabled: any;
     defaultPattern: any;
@@ -20,180 +8,53 @@ export class HookManager extends ComponentBase {
     hooks: Map<any, any>;
     registrationOrder: number;
     reportedErrors: WeakSet<object>;
-    /**
-     * Register a hook for API functions.
-     *
-     * @param {string} typePattern - Combined type and pattern (e.g., "before:math.*")
-     * @param {function} handler - Hook handler function
-     * @param {object} [options={}] - Hook options
-     * @param {string} [options.id] - Unique identifier (auto-generated if not provided)
-     * @param {number} [options.priority=0] - Higher = earlier execution
-     * @param {string} [options.subset="primary"] - Phase: "before", "primary", or "after"
-     * @returns {string} Hook ID
-     * @public
-     *
-     * @example
-     * hookManager.on("before:math.*", ({ args }) => {
-     *   console.log("Args:", args);
-     *   return args;
-     * }, { priority: 100 });
-     */
-    public on(typePattern: string, handler: Function, options?: {
-        id?: string;
-        priority?: number;
-        subset?: string;
-    }): string;
-    /**
-     * Remove hooks matching filter criteria.
-     *
-     * @param {object} [filter={}] - Filter criteria
-     * @param {string} [filter.id] - Remove hook by ID
-     * @param {string} [filter.type] - Remove hooks by type
-     * @param {string} [filter.pattern] - Remove hooks matching pattern
-     * @returns {number} Number of hooks removed
-     * @public
-     */
-    public remove(filter?: {
-        id?: string;
-        type?: string;
-        pattern?: string;
-    }): number;
-    /**
-     * Enable hooks matching filter criteria.
-     *
-     * @param {object|string} [filter={}] - Filter criteria (empty = enable all, string = pattern)
-     * @param {string} [filter.id] - Enable hook by ID
-     * @param {string} [filter.type] - Enable hooks by type
-     * @param {string} [filter.pattern] - Enable hooks matching pattern
-     * @returns {number} Number of hooks enabled
-     * @public
-     */
-    public enable(filter?: object | string): number;
-    /**
-     * Disable hooks matching filter criteria.
-     *
-     * @param {object|string} [filter={}] - Filter criteria (empty = disable all, string = pattern)
-     * @param {string} [filter.id] - Disable hook by ID
-     * @param {string} [filter.type] - Disable hooks by type
-     * @param {string} [filter.pattern] - Disable hooks matching pattern
-     * @returns {number} Number of hooks disabled
-     * @public
-     */
-    public disable(filter?: object | string): number;
-    /**
-     * List registered hooks matching filter criteria.
-     *
-     * @param {object|string} [filter={}] - Filter criteria (empty = list all), type string, or pattern string
-     * @param {string} [filter.id] - List hook by ID
-     * @param {string} [filter.type] - List hooks by type
-     * @param {string} [filter.pattern] - List hooks matching pattern
-     * @param {boolean} [filter.enabled] - Filter by enabled state
-     * @returns {object} Object with registeredHooks array property
-     * @public
-     */
-    public list(filter?: object | string): object;
-    /**
-     * Get hooks for a specific API path and type.
-     * Used internally by UnifiedWrapper.
-     *
-     * @param {string} type - Hook type (before/after/always/error)
-     * @param {string} apiPath - API path (e.g., "math.add")
-     * @returns {Array<object>} Sorted array of matching hooks
-     * @public
-     */
-    public getHooksForPath(type: string, apiPath: string): Array<object>;
-    /**
-     * Execute before hooks for an API path.
-     *
-     * @param {string} path - API path being called
-     * @param {Array} args - Function arguments
-     * @param {object} api - Bound API object
-     * @param {object} ctx - User context object
-     * @returns {object} Result object: { args, shortCircuit, value }
-     * @public
-     */
-    public executeBeforeHooks(path: string, args: any[], api: object, ctx: object): object;
-    /**
-     * Execute after hooks for an API path.
-     *
-     * @param {string} path - API path being called
-     * @param {*} result - Function return value
-     * @param {Array} args - Original function arguments
-     * @param {object} api - Bound API object
-     * @param {object} ctx - User context object
-     * @returns {HookExecutionResult} Object indicating if result was modified and the final result
-     * @public
-     */
-    public executeAfterHooks(path: string, result: any, args: any[], api: object, ctx: object): HookExecutionResult;
-    /**
-     * Execute always hooks for an API path.
-     *
-     * @param {string} path - API path being called
-     * @param {Array} args - Function arguments
-     * @param {*} resultOrError - Function result or error
-     * @param {boolean} hasError - Whether an error occurred
-     * @param {Array<Error>} errors - Array of errors that occurred
-     * @param {object} api - Bound API object
-     * @param {object} ctx - User context object
-     * @public
-     */
-    public executeAlwaysHooks(path: string, args: any[], resultOrError: any, hasError: boolean, errors: Array<Error>, api: object, ctx: object): void;
-    /**
-     * Execute error hooks for an API path.
-     *
-     * @param {string} path - API path being called
-     * @param {Error} error - The error that occurred
-     * @param {object} source - Error source info with type, hookTag, hookId, timestamp, stack
-     * @param {Array} args - Function arguments
-     * @param {object} api - Bound API object
-     * @param {object} ctx - User context object
-     * @public
-     */
-    public executeErrorHooks(path: string, error: Error, source: object, args: any[], api: object, ctx: object): void;
-    /**
-     * Get the pattern compilation function for diagnostic purposes.
-     * Only exposed when diagnostics mode is enabled.
-     *
-     * @returns {function} The pattern compilation function
-     * @internal
-     */
-    getCompilePatternForDiagnostics(): Function;
-    /**
-     * Export all registered hooks (including handler closures) so they can be
-     * re-registered on a fresh HookManager instance after a full reload.
-     *
-     * @returns {Array<object>} Snapshot of all current hook registrations.
-     * @public
-     */
-    public exportHooks(): Array<object>;
-    /**
-     * Re-register hooks exported by {@link exportHooks} into this (new) instance.
-     * Called after a full `api.slothlet.reload()` to restore user-registered hooks.
-     *
-     * @param {Array<object>} registrations - Snapshot returned by exportHooks().
-     * @returns {void}
-     * @public
-     */
-    public importHooks(registrations: Array<object>): void;
-    /**
-     * Cleanup hook manager on shutdown.
-     * @public
-     */
-    public shutdown(): Promise<void>;
+    on(typePattern: any, handler: any, options?: {}): any;
+    remove(filter?: {}): number;
+    enable(filter?: {}): number;
+    disable(filter?: {}): number;
+    list(filter?: {}): {
+        registeredHooks: {
+            id: any;
+            type: any;
+            pattern: any;
+            priority: any;
+            subset: any;
+            enabled: any;
+        }[];
+    };
+    getHooksForPath(type: any, apiPath: any): any[];
+    executeBeforeHooks(path: any, args: any, api: any, ctx: any): {
+        args: any;
+        shortCircuit: boolean;
+        value: any;
+    } | {
+        args: any;
+        shortCircuit: boolean;
+        value?: undefined;
+    };
+    executeAfterHooks(path: any, result: any, args: any, api: any, ctx: any): {
+        modified: boolean;
+        result?: undefined;
+    } | {
+        modified: boolean;
+        result: any;
+    };
+    executeAlwaysHooks(path: any, args: any, resultOrError: any, hasError: boolean | undefined, errors: any[] | undefined, api: any, ctx: any): void;
+    executeErrorHooks(path: any, error: any, source: any, args: any, api: any, ctx: any): void;
+    getCompilePatternForDiagnostics(): (pattern: any) => any;
+    exportHooks(): {
+        typePattern: string;
+        handler: any;
+        options: {
+            id: any;
+            priority: any;
+            subset: any;
+        };
+        enabled: any;
+    }[];
+    importHooks(registrations: any): void;
+    shutdown(): Promise<void>;
     #private;
 }
-/**
- * Result returned by hook execution methods.
- */
-export type HookExecutionResult = {
-    /**
-     * - Whether any hook modified the result value.
-     */
-    modified: boolean;
-    /**
-     * - The final (possibly hook-modified) return value.
-     */
-    result?: any;
-};
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=hook-manager.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hook-manager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/hook-manager.mjs"],"names":[],"mappings":"AAkCA;;;;;;GAMG;AACH;IACC;;;;OAIG;IACH,yBAHU,MAAM,CAGwB;IAoDvC,aAAiC;IACjC,oBAAgD;IAChD,oBAAwD;IACxD,0BAAgC;IAChC,6BAAgC;IAEhC,qBAAsB;IACtB,0BAA0B;IAC1B,gCAAmC;IAGpC;;;;;;;;;;;;;;;;;OAiBG;IACH,uBAfW,MAAM,+BAGd;QAAyB,EAAE,GAAnB,MAAM;QACW,QAAQ,GAAzB,MAAM;QACW,MAAM,GAAvB,MAAM;KACd,GAAU,MAAM,CA+ElB;IAED;;;;;;;;;OASG;IACH,uBANG;QAAwB,EAAE,GAAlB,MAAM;QACU,IAAI,GAApB,MAAM;QACU,OAAO,GAAvB,MAAM;KACd,GAAU,MAAM,CA8ClB;IAED;;;;;;;;;OASG;IACH,uBAPW,MAAM,GAAC,MAAM,GAIX,MAAM,CAalB;IAED;;;;;;;;;OASG;IACH,wBAPW,MAAM,GAAC,MAAM,GAIX,MAAM,CAclB;IAED;;;;;;;;;;OAUG;IACH,qBARW,MAAM,GAAC,MAAM,GAKX,MAAM,CA8DlB;IAED;;;;;;;;OAQG;IACH,6BALW,MAAM,WACN,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CAqDzB;IAED;;;;;;;;;OASG;IACH,gCAPW,MAAM,oBAEN,MAAM,OACN,MAAM,GACJ,MAAM,CA6ClB;IAED;;;;;;;;;;OAUG;IACH,+BARW,MAAM,UACN,GAAC,oBAED,MAAM,OACN,MAAM,GACJ,mBAAmB,CA+C/B;IAED;;;;;;;;;;;OAWG;IACH,gCATW,MAAM,8BAEN,GAAC,YACD,OAAO,UACP,KAAK,CAAC,KAAK,CAAC,OACZ,MAAM,OACN,MAAM,QA8BhB;IAED;;;;;;;;;;OAUG;IACH,+BARW,MAAM,SACN,KAAK,UACL,MAAM,oBAEN,MAAM,OACN,MAAM,QA4BhB;IAkLD;;;;;;OAMG;IACH,4CAEC;IA6ID;;;;;;OAMG;IACH,sBAHa,KAAK,CAAC,MAAM,CAAC,CAkBzB;IAED;;;;;;;OAOG;IACH,kCAJW,KAAK,CAAC,MAAM,CAAC,GACX,IAAI,CAWhB;IAED;;;OAGG;IACH,iCAUC;;CACD;;;;;;;;cAt9Ba,OAAO;;;;aACP,GAAC;;8BANe,0CAA0C"}
+{"version":3,"file":"hook-manager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/hook-manager.mjs"],"names":[],"mappings":"AAAsN;IAAwC,gCAAsC;IAA2a,aAA+B;IAAC,oBAA4C;IAAC,oBAAoD;IAAC,0BAA4B;IAAC,6BAA8B;IAAC,qBAAkB;IAAC,0BAAwB;IAAC,gCAA+B;IAAC,sDAAujC;IAAA,4BAA2vB;IAAA,4BAAmI;IAAA,6BAAyK;IAAA;;;;;;;;;MAA46B;IAAA,gDAA+pB;IAAA;;;;;;;;MAAswB;IAAA;;;;;;MAA2pB;IAAA,iJAAqb;IAAA,2FAA2Y;IAAwzB,yDAAyE;IAA8mD;;;;;;;;;QAA2Q;IAAA,sCAAyM;IAAA,0BAA8N;;CAAC;8BAA5+T,0CAA0C"}

package/types/dist/lib/handlers/lifecycle-token.d.mts

@@ -1,49 +1,4 @@
-/**
- * Registers a Slothlet instance and creates its per-instance lifecycle capability token.
- *
- * Safe to call multiple times on the same instance (idempotent) — subsequent calls are
- * silently ignored, preserving the original token. This handles the reload code path where
- * `load()` is called again on the same Slothlet object.
- *
- * @param {object} slothlet - The Slothlet instance to register.
- * @returns {void}
- * @package
- *
- * @example
- * // Called once (or on reload) in Slothlet.load():
- * registerInstance(this);
- */
-export function registerInstance(slothlet: object): void;
-/**
- * Returns the per-instance capability token for the given Slothlet instance.
- *
- * Used internally by `lifecycle.mjs` (emit dispatch) and `modes-processor.mjs`
- * (direct tagSystemMetadata call for folder wrappers). Requires a live registered
- * Slothlet instance — cannot be exploited without one.
- *
- * @param {object} slothlet - A registered Slothlet instance.
- * @returns {symbol|undefined} The instance token, or undefined if not registered.
- * @package
- *
- * @example
- * handler(data, getInstanceToken(this.slothlet));
- */
-export function getInstanceToken(slothlet: object): symbol | undefined;
-/**
- * Verifies that `token` is the registered capability token for the given Slothlet instance.
- *
- * Used by `metadata.mjs` inside `tagSystemMetadata()` to reject calls that did not
- * originate from the internal lifecycle dispatch path.
- *
- * @param {object} slothlet - A registered Slothlet instance.
- * @param {*} token - The token value to verify.
- * @returns {boolean} `true` only if `token` is the exact Symbol registered for `slothlet`.
- * @package
- *
- * @example
- * if (!verifyToken(this.slothlet, token)) {
- *   throw new this.SlothletError("METADATA_LIFECYCLE_BYPASS", ...);
- * }
- */
-export function verifyToken(slothlet: object, token: any): boolean;
+export function getInstanceToken(slothlet: any): any;
+export function registerInstance(slothlet: any): void;
+export function verifyToken(slothlet: any, token: any): boolean;
 //# sourceMappingURL=lifecycle-token.d.mts.map

package/types/dist/lib/handlers/lifecycle-token.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle-token.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/lifecycle-token.mjs"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;GAcG;AACH,2CARW,MAAM,GACJ,IAAI,CAchB;AAED;;;;;;;;;;;;;GAaG;AACH,2CAPW,MAAM,GACJ,MAAM,GAAC,SAAS,CAQ5B;AAED;;;;;;;;;;;;;;;GAeG;AACH,sCAVW,MAAM,SACN,GAAC,GACC,OAAO,CAUnB"}
+{"version":3,"file":"lifecycle-token.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/lifecycle-token.mjs"],"names":[],"mappings":"AAAuL,qDAAwE;AAA9N,sDAAsJ;AAAwE,gEAAiF"}

package/types/dist/lib/handlers/lifecycle.d.mts

@@ -1,90 +1,13 @@
-/**
- * Lifecycle event manager for impl changes
- * @extends ComponentBase
- * @public
- */
 export class Lifecycle extends ComponentBase {
-    /**
-     * Where this component should be mounted on the Slothlet instance
-     * @type {string}
-     */
     static slothletProperty: string;
     subscribers: Map<any, any>;
     eventLog: any[];
     maxLogSize: number;
-    /**
-     * Subscribe to lifecycle event
-     * @param {string} event - Event name (impl:created, impl:changed, impl:removed, materialized:complete, path:collision)
-     * @param {Function} handler - Event handler function(eventData)
-     * @returns {Function} Unsubscribe function
-     * @public
-     *
-     * @description
-     * Subscribe to lifecycle events to react to impl changes.
-     *
-     * @example
-     * const unsubscribe = lifecycle.subscribe("impl:changed", (data) => {
-     *   console.log("Impl changed:", data.apiPath, data.source);
-     * });
-     */
-    public subscribe(event: string, handler: Function): Function;
-    /**
-     * Alias for subscribe() - standard EventEmitter pattern
-     * @param {string} event - Event name
-     * @param {Function} handler - Event handler function
-     * @returns {Function} Unsubscribe function
-     * @public
-     *
-     * @example
-     * lifecycle.on('materialized:complete', (data) => {
-     *   console.log(`${data.total} modules materialized`);
-     * });
-     */
-    public on(event: string, handler: Function): Function;
-    /**
-     * Unsubscribe from lifecycle event - standard EventEmitter pattern
-     * @param {string} event - Event name
-     * @param {Function} handler - Event handler function to remove
-     * @public
-     *
-     * @example
-     * const handler = (data) => console.log(data);
-     * lifecycle.on('impl:changed', handler);
-     * lifecycle.off('impl:changed', handler);
-     */
-    public off(event: string, handler: Function): void;
-    /**
-     * Alias for off() - standard EventEmitter pattern
-     * @param {string} event - Event name
-     * @param {Function} handler - Event handler function to remove
-     * @public
-     */
-    public unsubscribe(event: string, handler: Function): void;
-    /**
-     * Emit lifecycle event
-     * @param {string} event - Event name
-     * @param {object} data - Event data
-     * @private
-     *
-     * @description
-     * Emit event to all subscribers. Event data should include:
-     * - apiPath: API path where impl exists
-     * - impl: The implementation object
-     * - source: Source of event (initial, hot-reload, materialization, etc)
-     * - moduleID: Module identifier (if applicable)
-     * - filePath: File path (if applicable)
-     * - metadata: Additional metadata
-     *
-     * @example
-     * lifecycle.emit("impl:created", {
-     *   apiPath: "math.add",
-     *   impl: addFunction,
-     *   source: "initial",
-     *   moduleID: "base_abc123",
-     *   filePath: "/path/to/math.mjs"
-     * });
-     */
-    private emit;
+    subscribe(event: any, handler: any): () => void;
+    on(event: any, handler: any): () => void;
+    off(event: any, handler: any): void;
+    unsubscribe(event: any, handler: any): void;
+    emit(event: any, data: any): Promise<void>;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=lifecycle.d.mts.map

package/types/dist/lib/handlers/lifecycle.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/lifecycle.mjs"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH;IACC;;;OAGG;IACH,yBAFU,MAAM,CAEsB;IAOrC,2BAA4B;IAC5B,gBAAkB;IAClB,mBAAsB;IAGvB;;;;;;;;;;;;;;OAcG;IACH,wBAbW,MAAM,+BA0BhB;IAED;;;;;;;;;;;OAWG;IACH,iBAVW,MAAM,+BAYhB;IAED;;;;;;;;;;OAUG;IACH,kBATW,MAAM,2BAchB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,2BAMhB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,aAyDC;CAED;8BAtL6B,0CAA0C"}
+{"version":3,"file":"lifecycle.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/lifecycle.mjs"],"names":[],"mappings":"AAA2I;IAAsC,gCAAoC;IAAsC,2BAAwB;IAAC,gBAAgB;IAAC,mBAAmB;IAAC,gDAAqO;IAAA,yCAAuD;IAAA,oCAAqG;IAAA,4CAAmD;IAAA,2CAAg4B;CAAC;8BAArlD,0CAA0C"}

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

@@ -1,75 +1,13 @@
-/**
- * Manager for tracking lazy folder materialization state
- * @class MaterializeManager
- * @extends ComponentBase
- * @package
- *
- * @description
- * Provides access to lazy materialization state via `api.slothlet.materialize`.
- * Tracks count of unmaterialized lazy folders and provides boolean state, statistics,
- * and wait functionality for synchronization.
- *
- * @example
- * const api = await slothlet({ dir: "./api", mode: "lazy" });
- *
- * // Check if fully materialized
- * if (api.slothlet.materialize.materialized) {
- *   console.log("All lazy folders loaded!");
- * }
- *
- * // Get statistics
- * const stats = api.slothlet.materialize.get();
- * console.log(`${stats.percentage}% loaded (${stats.remaining}/${stats.total} remaining)`);
- *
- * // Wait for full materialization
- * await api.slothlet.materialize.wait();
- */
 export class MaterializeManager extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Get materialization state as a boolean
-     * Returns true when all lazy wrappers have been materialized
-     * @returns {boolean} True if fully materialized, false if any lazy folders remain
-     * @public
-     *
-     * @example
-     * if (api.slothlet.materialize.materialized) {
-     *   console.log("API is fully loaded");
-     * }
-     */
-    public get materialized(): boolean;
-    /**
-     * Get detailed materialization statistics
-     * @returns {Object} Statistics object with total, materialized, remaining, percentage
-     * @public
-     *
-     * @example
-     * const stats = api.slothlet.materialize.get();
-     * // { total: 5, materialized: 3, remaining: 2, percentage: 60 }
-     */
-    public get(): any;
-    /**
-     * Wait for full materialization (all lazy folders loaded)
-     * Returns immediately if already fully materialized
-     * @returns {Promise<void>} Resolves when all lazy wrappers have materialized
-     * @public
-     *
-     * @example
-     * // Wait for API to fully load
-     * await api.slothlet.materialize.wait();
-     * console.log("All modules loaded!");
-     *
-     * @example
-     * // Wait with timeout
-     * const timeoutPromise = new Promise((_, reject) =>
-     *   setTimeout(() => reject(new Error("Timeout")), 5000)
-     * );
-     * await Promise.race([
-     *   api.slothlet.materialize.wait(),
-     *   timeoutPromise
-     * ]);
-     */
-    public wait(): Promise<void>;
+    get materialized(): boolean;
+    get(): {
+        total: any;
+        materialized: number;
+        remaining: any;
+        percentage: number;
+    };
+    wait(): Promise<any>;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=materialize-manager.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"materialize-manager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/materialize-manager.mjs"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IACC,gCAAwC;IAWxC;;;;;;;;;;OAUG;IACH,2BARa,OAAO,CAUnB;IAED;;;;;;;;OAQG;IACH,kBAYC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,eAlBa,OAAO,CAAC,IAAI,CAAC,CA4BzB;CACD;8BA9G6B,0CAA0C"}
+{"version":3,"file":"materialize-manager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/materialize-manager.mjs"],"names":[],"mappings":"AAAoE;IAA+C,gCAAsC;IAAsC,4BAAqE;IAAA;;;;;MAA0P;IAAA,qBAAsJ;CAAC;8BAA5nB,0CAA0C"}