@cldmv/slothlet 3.3.0 → 3.4.0

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

@@ -1,229 +1,25 @@
-/**
- * Metadata handler for introspection of function metadata
- * @class Metadata
- * @extends ComponentBase
- * @package
- */
 export class Metadata extends ComponentBase {
     static slothletProperty: string;
-    _instanceId: any;
-    /**
-     * Tag system metadata (SECURE, IMMUTABLE)
-     * Called internally during wrapper/function creation
-     *
-     * The `token` parameter must be the module-private `LIFECYCLE_TOKEN` Symbol exported
-     * from `@cldmv/slothlet/handlers/lifecycle-token`. Because a Symbol is a unique,
-     * non-forgeable value within a Node.js process, and because the token module is not
-     * listed in the package's public `exports` map, user-land code cannot construct a
-     * value that satisfies the `token === LIFECYCLE_TOKEN` check without modifying the
-     * source or importing an undocumented internal path.
-     *
-     * @param {Function|Object} target - Wrapper or function to tag
-     * @param {Object} systemData - System metadata (filePath, apiPath, moduleID, sourceFolder)
-     * @param {symbol} token - Must be `LIFECYCLE_TOKEN` — the unforgeable module-private Symbol
-     * @private
-     */
-    private tagSystemMetadata;
-    /**
-     * Get system metadata only (without user metadata)
-     * @param {Function|Object} target - Wrapper or function
-     * @returns {Object|null} System metadata or null
-     * @package
-     */
-    getSystemMetadata(target: Function | any): any | null;
-    /**
-     * Get metadata for a target (combines system + user)
-     * For wrappers: checks current impl to ensure metadata is current
-     * @param {Function|Object} target - Wrapper or function
-     * @returns {Object} Combined metadata (deeply frozen)
-     * @public
-     */
-    public getMetadata(target: Function | any): any;
-    /**
-     * Set global user metadata (applies to all functions)
-     * @param {string} key - Metadata key
-     * @param {unknown} value - Metadata value
-     * @public
-     */
-    public setGlobalMetadata(key: string, value: unknown): void;
-    /**
-     * Add/update user metadata for specific function
-     * @param {Function} target - Function to tag with metadata
-     * @param {string} key - Metadata key
-     * @param {unknown} value - Metadata value
-     * @public
-     */
-    public setUserMetadata(target: Function, key: string, value: unknown): void;
-    /**
-     * Remove user metadata from specific function
-     * @param {Function} target - Function to remove metadata from
-     * @param {string|string[]|Object<string, string[]>} [key] - Optional key(s) to remove (removes all if omitted). Can be:
-     *   - string: Remove single key
-     *   - string[]: Remove multiple keys (each element must be a string)
-     *   - {key: string[]}: Remove nested keys from object values
-     * @public
-     */
-    public removeUserMetadata(target: Function, key?: string | string[] | {
-        [x: string]: string[];
-    }): void;
-    /**
-     * Register user metadata keyed by an identifier (moduleID or API path)
-     *
-     * @description
-     * Stores user-provided metadata in `#userMetadataStore` under the given
-     * `identifier`. The identifier is treated opaquely — callers pass either a
-     * generated moduleID (e.g. `base_slothlet`) or a dot-notation API path
-     * (e.g. `math`). `getMetadata()` retrieves entries using the same key via
-     * both the moduleID lookup and `collectMetadataFromParents`, so storing
-     * under a single key is sufficient for both cases.
-     *
-     * Multiple calls to the same identifier are merged; later calls override
-     * earlier ones for conflicting keys.
-     *
-     * @param {string} identifier - Module ID or dot-notation API path
-     * @param {Object} metadata - User metadata object to merge
-     * @package
-     */
-    registerUserMetadata(identifier: string, metadata: any): void;
-    /**
-     * Remove all user metadata for an apiPath
-     *
-     * @description
-     * Cleanup method to remove all user metadata associated with an apiPath.
-     * Used during api.remove() or cleanup operations.
-     *
-     * @param {string} apiPath - API path to remove
-     * @package
-     */
-    removeUserMetadataByApiPath(apiPath: string): void;
-    /**
-     * Set metadata for all functions reachable at an API path.
-     *
-     * @description
-     * Stores metadata keyed by `apiPath` so that every function whose system
-     * `apiPath` starts with (or equals) the given path inherits the values via
-     * `collectMetadataFromParents()` in `getMetadata()`.
-     *
-     * Accepts either a single key/value pair or a plain object to merge.
-     * Multiple calls to the same path are merged; later calls override earlier
-     * ones for conflicting keys.
-     *
-     * Priority (lowest → highest): global → setForPath → set() → system.
-     *
-     * @param {string} apiPath - Dot-notation path (e.g. `"math"`, `"math.add"`)
-     * @param {string|Object} keyOrObj - Key string (with `value`) OR metadata object to merge
-     * @param {unknown} [value] - Value when `keyOrObj` is a string key
-     * @public
-     */
-    public setPathMetadata(apiPath: string, keyOrObj: string | any, value?: unknown): void;
-    /**
-     * Get the user metadata collected from the path store for a given API path.
-     *
-     * @description
-     * Traverses from root segment to leaf, merging parent → child metadata — the same
-     * traversal used by `collectMetadataFromParents` inside `getMetadata()`. Does not
-     * include immutable system metadata; only user-supplied path store entries are returned.
-     *
-     * @param {string} apiPath - Dot-notation API path (e.g. `"v1.auth"`, `"math"`).
-     * @returns {Object} Merged user metadata for the path (not frozen).
-     * @public
-     * @example
-     * metadata.getPathMetadata("v1.auth"); // { stable: true, category: "auth" }
-     */
-    public getPathMetadata(apiPath: string): any;
-    /**
-     * Remove metadata keys (or all metadata) for an API path.
-     *
-     * @description
-     * Removes one specific key, multiple keys, or ALL user metadata stored under
-     * the given `apiPath` key in the path store.
-     * Only affects metadata set via `setForPath()` / `registerUserMetadata()` for
-     * this exact path segment - it does not walk descendant paths.
-     *
-     * @param {string} apiPath - Dot-notation path (e.g. `"math"`, `"math.add"`)
-     * @param {string|string[]} [key] - Key(s) to remove. Omit to remove all metadata for the path.
-     * @public
-     */
-    public removePathMetadata(apiPath: string, key?: string | string[]): void;
-    /**
-     * Export user-managed metadata state for preservation across reload.
-     *
-     * @description
-     * Captures `#globalUserMetadata` and all entries in `#userMetadataStore`
-     * so they can be restored to a fresh Metadata instance after reload.
-     * Called by `slothlet.reload()` BEFORE `load()` destroys this instance.
-     *
-     * @returns {{ globalMetadata: Object, userMetadataStore: Map }} Snapshot of user state
-     * @package
-     */
+    _instanceId: null;
+    tagSystemMetadata(target: any, systemData: any, token: any): void;
+    getSystemMetadata(target: any): any;
+    getMetadata(target: any): any;
+    setGlobalMetadata(key: any, value: any): void;
+    setUserMetadata(target: any, key: any, value: any): void;
+    removeUserMetadata(target: any, key: any): void;
+    registerUserMetadata(identifier: any, metadata: any): void;
+    removeUserMetadataByApiPath(apiPath: any): void;
+    setPathMetadata(apiPath: any, keyOrObj: any, value: any): void;
+    getPathMetadata(apiPath: any): {};
+    removePathMetadata(apiPath: any, key: any): void;
     exportUserState(): {
-        globalMetadata: any;
+        globalMetadata: {};
         userMetadataStore: Map<any, any>;
     };
-    /**
-     * Restore user-managed metadata state after a fresh load.
-     *
-     * @description
-     * Merges previously exported state into the new (empty) Metadata instance.
-     * Called by `slothlet.reload()` AFTER `load()` creates the new instance and
-     * BEFORE operation-history replay so that `registerUserMetadata()` from replay
-     * can properly merge over the restored base state.
-     *
-     * Merge priority: existing (from load) > saved state.
-     * This means replay-registered api.add metadata overrides restored values
-     * for the same key, which is the desired behaviour.
-     *
-     * @param {{ globalMetadata: Object, userMetadataStore: Map }} state - Previously exported state
-     * @package
-     */
-    importUserState(state: {
-        globalMetadata: any;
-        userMetadataStore: Map<any, any>;
-    }): void;
-    /**
-     * Get metadata of any function by API path.
-     *
-     * Traverses `this.slothlet.api` using the dot-notation path, materializes
-     * lazy wrappers as needed, then returns the combined metadata for the
-     * resolved target via `getMetadata()`.
-     *
-     * Called by the `api.slothlet.metadata.get()` closure injected in
-     * `slothlet.injectRuntimeMetadataFunctions()`.
-     *
-     * @param {string} path - Dot-notation API path (e.g. `"math.add"`)
-     * @returns {Promise<object|null>} Combined metadata or null
-     * @public
-     */
-    public get(path: string): Promise<object | null>;
-    /**
-     * Get metadata for the currently-executing API function.
-     *
-     * Reads `currentWrapper` from the active context-manager store — the same
-     * fast synchronous path used by the unified wrapper's `apply` trap.
-     * Throws `RUNTIME_NO_ACTIVE_CONTEXT` when called outside of a slothlet
-     * execution context.
-     *
-     * Called by the `api.slothlet.metadata.self()` closure injected in
-     * `slothlet.injectRuntimeMetadataFunctions()`.
-     *
-     * @returns {object} Combined metadata for the current function
-     * @public
-     */
-    public self(): object;
-    /**
-     * Get metadata for the API function that called the current function.
-     *
-     * Reads `callerWrapper` from the active context-manager store.
-     * Returns `null` when there is no caller in context (e.g. the function
-     * was invoked directly from outside the API).
-     *
-     * Called by the `api.slothlet.metadata.caller()` closure injected in
-     * `slothlet.injectRuntimeMetadataFunctions()`.
-     *
-     * @returns {object|null} Combined metadata for the calling function, or null
-     * @public
-     */
-    public caller(): object | null;
+    importUserState(state: any): void;
+    get(path: any): Promise<any>;
+    self(): any;
+    caller(): any;
     #private;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

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

@@ -1 +1 @@
-{"version":3,"file":"metadata.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/metadata.mjs"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH;IACC,gCAAqC;IASrC,iBAAmB;IAkCnB;;;;;;;;;;;;;;;OAeG;IACH,0BAyCC;IAED;;;;;OAKG;IACH,0BAJW,cAAe,GACb,MAAO,IAAI,CAYvB;IAED;;;;;;OAMG;IACH,2BAJW,cAAe,OAoEzB;IAED;;;;;OAKG;IACH,8BAJW,MAAM,SACN,OAAO,QAKjB;IAED;;;;;;OAMG;IACH,8CAJW,MAAM,SACN,OAAO,QA+CjB;IAED;;;;;;;;OAQG;IACH,kDANW,MAAM,GAAC,MAAM,EAAE,GAAC;YAAO,MAAM,GAAE,MAAM,EAAE;KAAC,QAkFlD;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iCAJW,MAAM,uBA2BhB;IAED;;;;;;;;;OASG;IACH,qCAHW,MAAM,QAMhB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,gCALW,MAAM,YACN,MAAM,MAAO,UACb,OAAO,QAyBjB;IAED;;;;;;;;;;;;;OAaG;IACH,gCANW,MAAM,OAoBhB;IAED;;;;;;;;;;;;OAYG;IACH,mCAJW,MAAM,QACN,MAAM,GAAC,MAAM,EAAE,QA+BzB;IAED;;;;;;;;;;OAUG;IACH,mBAHa;QAAE,cAAc,MAAS;QAAC,iBAAiB,gBAAK;KAAE,CAe9D;IAED;;;;;;;;;;;;;;;OAeG;IACH,uBAHW;QAAE,cAAc,MAAS;QAAC,iBAAiB,gBAAK;KAAE,QAgC5D;IAED;;;;;;;;;;;;;OAaG;IACH,iBAJW,MAAM,GACJ,OAAO,CAAC,MAAM,GAAC,IAAI,CAAC,CAkChC;IAED;;;;;;;;;;;;;OAaG;IACH,eAHa,MAAM,CASlB;IAED;;;;;;;;;;;;OAYG;IACH,iBAHa,MAAM,GAAC,IAAI,CAOvB;;CACD;8BA9qB6B,0CAA0C"}
+{"version":3,"file":"metadata.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/metadata.mjs"],"names":[],"mappings":"AAA2M;IAAqC,gCAAmC;IAA8E,kBAAiB;IAA4U,kEAA2zB;IAAA,oCAA4N;IAAA,8BAAgkC;IAAA,8CAAiE;IAAA,yDAA26B;IAAA,gDAA0mD;IAAA,2DAAkd;IAAA,gDAAgG;IAAA,+DAA4kB;IAAA,kCAAyX;IAAA,iDAAijB;IAAA;;;MAA8P;IAAA,kCAA2jB;IAAA,6BAA8kB;IAAA,YAAkO;IAAA,cAAoJ;;CAAC;8BAAxnS,0CAA0C"}

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

@@ -1,170 +1,54 @@
-/**
- * Summary result of an unregister operation.
- * @typedef {Object} UnregisterResult
- * @property {string[]} removed - API paths that were removed.
- * @property {Object[]} rolledBack - Entries that were rolled back to a previous owner.
- */
-/**
- * Tracks which modules own which API paths for hot reload and rollback
- * @class OwnershipManager
- * @extends ComponentBase
- * @public
- */
 export class OwnershipManager extends ComponentBase {
     static slothletProperty: string;
-    constructor(slothlet: any);
     moduleToPath: Map<any, any>;
     pathToModule: Map<any, any>;
     _unregisteredModules: Set<any>;
-    /**
-     * Register module ownership of API path with its value
-     * @param {Object} options - Registration options
-     * @param {string} options.moduleID - Module identifier
-     * @param {string} options.apiPath - API path being registered
-     * @param {*} options.value - The actual function/object being registered
-     * @param {string} [options.source="core"] - Source of registration
-     * @param {string} [options.collisionMode="error"] - Collision mode: skip, warn, error, merge, replace
-     * @param {Object} [options.config] - Config object for silent mode check
-     * @param {string} [options.filePath=null] - File path of the module source (for metadata tracking)
-     * @returns {Object|null} Registration entry or null if skipped
-     * @public
-     */
-    public register({ moduleID, apiPath, value, source, collisionMode, config, filePath }: {
-        moduleID: string;
-        apiPath: string;
+    register({ moduleID, apiPath, value, source, collisionMode, config, filePath }: {
+        moduleID: any;
+        apiPath: any;
         value: any;
-        source?: string;
-        collisionMode?: string;
-        config?: any;
-        filePath?: string;
-    }): any | null;
-    /**
-     * @param {string} moduleID - Module to unregister.
-     * @returns {UnregisterResult} Removal summary.
-     * @public
-     *
-     * @description
-     * Removes all paths owned by the provided moduleID and reports removals and rollbacks.
-     *
-     * @example
-     * const result = ownership.unregister("module-a");
-     */
-    public unregister(moduleID: string): UnregisterResult;
-    /**
-     * @param {string} apiPath - API path to modify.
-     * @param {string|null} [moduleID=null] - Module to remove (defaults to current owner).
-     * @returns {{ action: "delete"|"none"|"restore", removedModuleId: string|null,
-     * restoreModuleId: string|null }} Action taken for the path.
-     * @public
-     *
-     * @description
-     * Removes a module owner from a specific API path. If the current owner is removed and
-     * previous owners exist, the path is restored to the previous owner.
-     *
-     * @example
-     * const result = ownership.removePath("plugins.tools", "module-a");
-     */
-    public removePath(apiPath: string, moduleID?: string | null): {
-        action: "delete" | "none" | "restore";
-        removedModuleId: string | null;
-        restoreModuleId: string | null;
+        source?: string | undefined;
+        collisionMode?: string | undefined;
+        config?: null | undefined;
+        filePath?: null | undefined;
+    }): any;
+    unregister(moduleID: any): {
+        removed: any[];
+        rolledBack: {
+            apiPath: any;
+            restoredTo: any;
+        }[];
     };
-    /**
-     * Get current owner of API path
-     * @param {string} apiPath - API path to check
-     * @returns {Object|null} Current owner entry or null
-     * @public
-     */
-    public getCurrentOwner(apiPath: string): any | null;
-    /**
-     * Get current value for API path
-     * @param {string} apiPath - API path to check
-     * @returns {*} Current value or undefined
-     * @public
-     */
-    public getCurrentValue(apiPath: string): any;
-    /**
-     * Get all paths owned by module
-     * @param {string} moduleID - Module to query
-     * @returns {Array<string>} Array of API paths
-     * @public
-     */
-    public getModulePaths(moduleID: string): Array<string>;
-    /**
-     * Get ownership history for path
-     * @param {string} apiPath - API path to query
-     * @returns {Array<Object>} Ownership history stack
-     * @public
-     */
-    public getPathHistory(apiPath: string): Array<any>;
-    /**
-     * Check if module owns path
-     * @param {string} moduleID - Module to check
-     * @param {string} apiPath - API path to check
-     * @returns {boolean} True if module owns path
-     * @public
-     */
-    public ownsPath(moduleID: string, apiPath: string): boolean;
-    /**
-     * Get diagnostic info about ownership
-     * @returns {Object} Diagnostic information
-     * @public
-     */
-    public getDiagnostics(): any;
-    /**
-     * Get ownership info for a specific API path
-     * @param {string} apiPath - API path to check
-     * @returns {Set<string>|null} Set of moduleIDs that own this path, or null if path not found
-     * @public
-     */
-    public getPathOwnership(apiPath: string): Set<string> | null;
-    /**
-     * Recursively register API subtree with ownership
-     * @param {object} api - API object or subtree
-     * @param {string} moduleID - Module identifier (owner)
-     * @param {string} path - Current API path
-     * @param {WeakSet} [visited] - Visited objects (prevents circular refs)
-     * @returns {void}
-     * @public
-     *
-     * @description
-     * Registers entire API subtree structure with ownership manager.
-     * Used during load, reload, and api.add to establish ownership relationships.
-     *
-     * @example
-     * ownership.registerSubtree(api, "base_abc123", "");
-     */
-    public registerSubtree(api: object, moduleID: string, path: string, visited?: WeakSet<any>): void;
-    /**
-     * Clear all ownership data
-     * @public
-     */
-    public clear(): void;
-    /**
-     * Export ownership state for preservation during reload
-     * @returns {Object} Serializable ownership state
-     * @public
-     */
-    public exportState(): any;
-    /**
-     * Import ownership state from exported data
-     * @param {Object} state - Previously exported state
-     * @public
-     */
-    public importState(state: any): void;
+    removePath(apiPath: any, moduleID?: null): {
+        action: string;
+        removedModuleId: any;
+        restoreModuleId: any;
+    };
+    getCurrentOwner(apiPath: any): any;
+    getCurrentValue(apiPath: any): any;
+    getModulePaths(moduleID: any): any[];
+    getPathHistory(apiPath: any): any;
+    ownsPath(moduleID: any, apiPath: any): any;
+    getDiagnostics(): {
+        totalModules: number;
+        totalPaths: number;
+        modules: {
+            moduleID: any;
+            pathCount: any;
+        }[];
+        conflictedPaths: {
+            apiPath: any;
+            ownerStack: any;
+        }[];
+    };
+    getPathOwnership(apiPath: any): Set<any> | null;
+    registerSubtree(api: any, moduleID: any, path: any, visited?: WeakSet<object>): void;
+    clear(): void;
+    exportState(): {
+        moduleToPath: any[][];
+        pathToModule: [any, any][];
+    };
+    importState(state: any): void;
 }
-/**
- * Summary result of an unregister operation.
- */
-export type UnregisterResult = {
-    /**
-     * - API paths that were removed.
-     */
-    removed: string[];
-    /**
-     * - Entries that were rolled back to a previous owner.
-     */
-    rolledBack: any[];
-};
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=ownership.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ownership.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/ownership.mjs"],"names":[],"mappings":"AAqBA;;;;;GAKG;AAEH;;;;;GAKG;AACH;IACC,gCAAsC;IAEtC,2BAKC;IAHA,4BAA6B;IAC7B,4BAA6B;IAC7B,+BAAqC;IAGtC;;;;;;;;;;;;OAYG;IACH,uFAVG;QAAwB,QAAQ,EAAxB,MAAM;QACU,OAAO,EAAvB,MAAM;QACK,KAAK,EAAhB,GAAC;QACgB,MAAM,GAAvB,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,MAAM;QACN,QAAQ,GAAzB,MAAM;KACd,GAAU,MAAO,IAAI,CAsFvB;IAED;;;;;;;;;;OAUG;IACH,4BAVW,MAAM,GACJ,gBAAgB,CAsC5B;IAED;;;;;;;;;;;;;OAaG;IACH,2BAbW,MAAM,aACN,MAAM,GAAC,IAAI,GACT;QAAE,MAAM,EAAE,QAAQ,GAAC,MAAM,GAAC,SAAS,CAAC;QAAC,eAAe,EAAE,MAAM,GAAC,IAAI,CAAC;QAC5E,eAAe,EAAE,MAAM,GAAC,IAAI,CAAA;KAAE,CA4ChC;IAED;;;;;OAKG;IACH,gCAJW,MAAM,GACJ,MAAO,IAAI,CAOvB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,GACJ,GAAC,CAkBb;IAED;;;;;OAKG;IACH,gCAJW,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CAKzB;IAED;;;;;OAKG;IACH,+BAJW,MAAM,GACJ,KAAK,KAAQ,CAKzB;IAED;;;;;;OAMG;IACH,0BALW,MAAM,WACN,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,6BAeC;IAED;;;;;OAKG;IACH,iCAJW,MAAM,GACJ,GAAG,CAAC,MAAM,CAAC,GAAC,IAAI,CAS5B;IAED;;;;;;;;;;;;;;;OAeG;IACH,4BAdW,MAAM,YACN,MAAM,QACN,MAAM,2BAEJ,IAAI,CAwDhB;IAED;;;OAGG;IACH,qBAIC;IAED;;;;OAIG;IACH,0BAKC;IAED;;;;OAIG;IACH,qCAaC;CACD;;;;;;;;aAlaa,MAAM,EAAE;;;;gBACR,KAAQ;;8BAPQ,0CAA0C"}
+{"version":3,"file":"ownership.d.mts","sourceRoot":"","sources":["../../../../dist/lib/handlers/ownership.mjs"],"names":[],"mappings":"AAAyI;IAA6C,gCAAoC;IAAsC,4BAAyB;IAAC,4BAAyB;IAAC,+BAAiC;IAAC;;;;;;;;YAAqlD;IAAA;;;;;;MAAud;IAAA;;;;MAAszB;IAAA,mCAAyI;IAAA,mCAA+M;IAAA,qCAAgF;IAAA,kCAAkE;IAAA,2CAA6G;IAAA;;;;;;;;;;;MAA6W;IAAA,gDAA+J;IAAA,qFAAstB;IAAA,cAA8F;IAAA;;;MAA0K;IAAA,8BAAkM;CAAC;8BAAn6K,0CAA0C"}

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

@@ -1,150 +1,49 @@
-/**
- * Manages access control rules for API path invocations.
- * Rules are glob-pattern-based (same syntax as hooks: *, **, ?, {a,b}, !negation).
- * Self-calls (same moduleID) always bypass the permission system.
- *
- * @class PermissionManager
- * @extends ComponentBase
- */
 export class PermissionManager extends ComponentBase {
-    /**
-     * Property name for auto-discovery by _initializeComponents.
-     * @type {string}
-     * @static
-     */
     static slothletProperty: string;
-    /**
-     * Add a permission rule.
-     *
-     * @param {object} rule - The rule definition.
-     * @param {string} rule.caller - Glob pattern matching caller API paths.
-     * @param {string} rule.target - Glob pattern matching target API paths.
-     * @param {string} rule.effect - "allow" or "deny".
-     * @param {string|null} [ownerModuleID=null] - Module ID that owns this rule.
-     * @param {string|null} [ruleId=null] - Optional rule ID to reuse (for replay).
-     * @returns {string} The rule ID (generated or reused).
-     * @throws {SlothletError} INVALID_PERMISSION_RULE if rule is malformed.
-     * @example
-     * pm.addRule({ caller: "payments.**", target: "db.write", effect: "allow" }, "mod_abc123");
-     */
-    addRule(rule: {
-        caller: string;
-        target: string;
-        effect: string;
-    }, ownerModuleID?: string | null, ruleId?: string | null): string;
-    /**
-     * Remove a permission rule by ID.
-     * A module cannot remove rules it owns (immutability).
-     *
-     * @param {string} ruleId - The rule ID to remove.
-     * @param {string|null} [callerModuleID=null] - Module ID of the caller attempting removal.
-     * @returns {boolean} True if the rule was removed.
-     * @throws {SlothletError} PERMISSION_SELF_MODIFY if caller owns the rule.
-     * @example
-     * pm.removeRule("perm-3", "mod_other");
-     */
-    removeRule(ruleId: string, callerModuleID?: string | null): boolean;
-    /**
-     * Check whether a caller path is allowed to access a target path.
-     * This is the main enforcement method called from applyTrap.
-     *
-     * @param {string} callerPath - The calling module's API path.
-     * @param {string} targetPath - The target API path being accessed.
-     * @param {string|null} [callerFilePath=null] - Caller's source file path (for self-call bypass).
-     * @param {string|null} [targetFilePath=null] - Target's source file path (for self-call bypass).
-     * @returns {boolean} True if access is allowed.
-     * @example
-     * const allowed = pm.checkAccess("payments.charge", "db.write", "/src/pay.mjs", "/src/db.mjs");
-     */
-    checkAccess(callerPath: string, targetPath: string, callerFilePath?: string | null, targetFilePath?: string | null): boolean;
-    /**
-     * Get all rules that match a given target path.
-     *
-     * @param {string} targetPath - Target API path to check.
-     * @returns {Array<object>} Array of matching rule objects (serialized).
-     * @example
-     * const rules = pm.getRulesForPath("db.write");
-     */
-    getRulesForPath(targetPath: string): Array<object>;
-    /**
-     * Get all rules owned by a given module.
-     *
-     * @param {string} moduleID - Module ID to look up.
-     * @returns {Array<object>} Array of rule objects (serialized).
-     * @example
-     * const rules = pm.getRulesByModule("mod_abc123");
-     */
-    getRulesByModule(moduleID: string): Array<object>;
-    /**
-     * Get all rules where the caller pattern matches a given caller path.
-     * Used by `self.rules()` to show what rules affect the calling module.
-     *
-     * @param {string} callerPath - Caller API path.
-     * @returns {Array<object>} Array of matching rule objects (serialized).
-     * @example
-     * const rules = pm.getRulesForCaller("payments.charge");
-     */
-    getRulesForCaller(callerPath: string): Array<object>;
-    /**
-     * Enable the permission system globally.
-     *
-     * @returns {void}
-     * @example
-     * pm.enable();
-     */
+    addRule(rule: any, ownerModuleID?: null, ruleId?: null): string;
+    removeRule(ruleId: any, callerModuleID?: null): boolean;
+    checkAccess(callerPath: any, targetPath: any, callerFilePath?: null, targetFilePath?: null, runtimeContext?: null): any;
+    getRulesForPath(targetPath: any): {
+        id: any;
+        caller: any;
+        target: any;
+        effect: any;
+        condition: any;
+        ownerModuleID: any;
+        registeredAt: any;
+    }[];
+    getRulesByModule(moduleID: any): {
+        id: any;
+        caller: any;
+        target: any;
+        effect: any;
+        condition: any;
+        ownerModuleID: any;
+        registeredAt: any;
+    }[];
+    getRulesForCaller(callerPath: any): {
+        id: any;
+        caller: any;
+        target: any;
+        effect: any;
+        condition: any;
+        ownerModuleID: any;
+        registeredAt: any;
+    }[];
     enable(): void;
-    /**
-     * Disable the permission system globally (all calls allowed).
-     *
-     * @returns {void}
-     * @example
-     * pm.disable();
-     */
     disable(): void;
-    /**
-     * Whether the permission system is currently enabled.
-     *
-     * @returns {boolean} True if enabled.
-     * @example
-     * if (pm.isEnabled()) { ... }
-     */
     isEnabled(): boolean;
-    /**
-     * Export all registered rules for replay during full reload.
-     *
-     * @returns {Array<object>} Snapshot of all current rules.
-     * @example
-     * const snapshot = pm.exportRules();
-     */
-    exportRules(): Array<object>;
-    /**
-     * Re-register rules exported by {@link exportRules}.
-     * Called after a full reload to restore programmatic rules.
-     *
-     * @param {Array<object>} registrations - Snapshot returned by exportRules().
-     * @returns {void}
-     * @example
-     * pm.importRules(snapshot);
-     */
-    importRules(registrations: Array<object>): void;
-    /**
-     * Cleanup permission manager on shutdown.
-     * Clears all internal state.
-     *
-     * @returns {Promise<void>}
-     * @example
-     * await pm.shutdown();
-     */
+    exportRules(): {
+        rule: {
+            caller: any;
+            target: any;
+            effect: any;
+        };
+        ownerModuleID: any;
+    }[];
+    importRules(registrations: any): void;
     shutdown(): Promise<void>;
-    /**
-     * Emit a debug message. Delegates to slothlet.debug().
-     *
-     * @param {string} category - Debug category.
-     * @param {object} data - Debug data.
-     * @returns {void}
-     * @private
-     */
-    private debug;
+    debug(category: any, data: any): void;
     #private;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";