@cldmv/slothlet 3.2.3 → 3.3.2

package/types/dist/lib/helpers/config.d.mts

@@ -1,128 +1,130 @@
-/**
- * Configuration normalization utilities
- * @class Config
- * @extends ComponentBase
- * @public
- */
 export class Config extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Normalize collision configuration for handling property collisions
-     * @param {string|Object} collision - Collision mode or object with per-context modes
-     * @returns {Object} Normalized collision configuration with initial and api.slothlet.api.add modes
-     * @public
-     *
-     * @description
-     * Normalizes collision handling configuration for both initial load (buildAPI)
-     * and hot reload (api.add) contexts. Supports six collision modes:
-     * - "skip": Silently ignore collision, keep existing value
-     * - "warn": Warn about collision, keep existing value
-     * - "replace": Replace existing value completely
-     * - "merge": Merge properties (preserve original + add new)
-     * - "merge-replace": Merge properties (add new + overwrite existing with new values)
-     * - "error": Throw error on collision
-     *
-     * @example
-     * // String shorthand applies to both contexts
-     * normalizeCollision("merge")
-     * // => { initial: "merge", api: "merge" }
-     *
-     * @example
-     * // Object allows per-context control
-     * normalizeCollision({ initial: "warn", api: "error" })
-     * // => { initial: "warn", api: "error" }
-     */
-    public normalizeCollision(collision: string | any): any;
-    /**
-     * Normalize runtime input to internal standard format
-     * @param {string} runtime - Input runtime type (various formats accepted)
-     * @returns {string} Normalized runtime type ("async" or "live")
-     * @public
-     */
-    public normalizeRuntime(runtime: string): string;
-    /**
-     * Normalize mode input to internal standard format
-     * @param {string} mode - Input mode type (various formats accepted)
-     * @returns {string} Normalized mode type ("eager" or "lazy")
-     * @public
-     */
-    public normalizeMode(mode: string): string;
-    /**
-     * Normalize mutations configuration for API modification control
-     * @param {Object} mutations - Mutations config object with add/remove/reload properties
-     * @returns {Object} Normalized mutations configuration
-     * @public
-     *
-     * @description
-     * Normalizes mutation control configuration for API runtime modifications.
-     * Controls whether api.slothlet.api.add(), api.slothlet.api.remove(), and
-     * api.slothlet.reload() operations are allowed.
-     *
-     * @example
-     * // Allow all mutations (default)
-     * normalizeMutations({ add: true, remove: true, reload: true })
-     * // => { add: true, remove: true, reload: true }
-     *
-     * @example
-     * // Disable all mutations
-     * normalizeMutations({ add: false, remove: false, reload: false })
-     * // => { add: false, remove: false, reload: false }
-     */
-    public normalizeMutations(mutations: any): any;
-    /**
-     * Normalize debug configuration
-     * @param {boolean|Object} debug - Debug flag or object with targeted flags
-     * @returns {Object} Normalized debug object with all flags
-     * @public
-     */
-    public normalizeDebug(debug: boolean | any): any;
-    /**
-     * Transform and validate configuration
-     * @param {Object} config - Raw configuration options
-     * @returns {Object} Normalized configuration
-     * @throws {SlothletError} If configuration is invalid
-     * @public
-     */
-    public transformConfig(config?: any): any;
-    /**
-     * Normalize TypeScript configuration
-     * @param {boolean|string|Object} typescript - TypeScript config (true, "fast", or { mode: "fast"|"strict", ... })
-     * @returns {Object|null} Normalized TypeScript configuration or null if disabled
-     * @public
-     */
-    public normalizeTypeScript(typescript: boolean | string | any): any | null;
-    /**
-     * Normalize env snapshot configuration.
-     *
-     * @description
-     * Validates the `env` option from user config. When `include` is a non-empty
-     * string array, returns `{ include }` (the allowlist used by `_captureEnvSnapshot`).
-     * Any other value — including `undefined`, `null`, `{}`, or an empty `include`
-     * array — is normalised to `null`, meaning the full `process.env` snapshot is used.
-     *
-     * @param {Object|null|undefined} env - Raw env option from user config.
-     * @param {string[]} [env.include] - Allowlist of env variable names to capture.
-     * @returns {{ include: string[] }|null} Normalized env config, or `null` for full snapshot.
-     * @public
-     *
-     * @example
-     * // No restriction — full snapshot
-     * normalizeEnv(undefined); // => null
-     * normalizeEnv(null);      // => null
-     * normalizeEnv({});        // => null
-     *
-     * @example
-     * // Include allowlist
-     * normalizeEnv({ include: ["NODE_ENV", "PORT"] });
-     * // => { include: ["NODE_ENV", "PORT"] }
-     *
-     * @example
-     * // Non-string keys in the include array are filtered out
-     * normalizeEnv({ include: ["NODE_ENV", 42, null] });
-     * // => { include: ["NODE_ENV"] }
-     */
-    public normalizeEnv(env: any | null | undefined): {
-        include: string[];
+    normalizeCollision(collision: any): {
+        initial: string;
+        api: string;
+    };
+    normalizeRuntime(runtime: any): "async" | "live";
+    normalizeMode(mode: any): "eager" | "lazy";
+    normalizeMutations(mutations: any): {
+        add: boolean;
+        remove: boolean;
+        reload: boolean;
+        permissions: boolean;
+    };
+    normalizeDebug(debug: any): {
+        builder: any;
+        api: any;
+        index: any;
+        modes: any;
+        wrapper: any;
+        ownership: any;
+        context: any;
+        initialization: any;
+        materialize: any;
+        versioning: any;
+        permissions: any;
+    };
+    transformConfig(config?: {}): {
+        dir: any;
+        mode: string;
+        runtime: string;
+        apiDepth: any;
+        reference: any;
+        context: any;
+        i18n: {
+            language: any;
+        } | null;
+        debug: {
+            builder: any;
+            api: any;
+            index: any;
+            modes: any;
+            wrapper: any;
+            ownership: any;
+            context: any;
+            initialization: any;
+            materialize: any;
+            versioning: any;
+            permissions: any;
+        };
+        diagnostics: boolean;
+        hook: {
+            enabled: boolean;
+            pattern: string;
+            suppressErrors: boolean;
+        };
+        collision: {
+            initial: string;
+            api: string;
+        };
+        api: {
+            collision: {
+                initial: string;
+                api: string;
+            };
+            mutations: {
+                add: boolean;
+                remove: boolean;
+                reload: boolean;
+                permissions: boolean;
+            } | {
+                add: boolean;
+                remove: boolean;
+                reload: boolean;
+            };
+        };
+        scope: any;
+        tracking: {
+            materialization: boolean;
+        };
+        backgroundMaterialize: boolean;
+        silent: boolean;
+        typescript: {
+            enabled: boolean;
+            mode: string;
+            types?: undefined;
+            target?: undefined;
+            sourcemap?: undefined;
+        } | {
+            enabled: boolean;
+            mode: string;
+            types: any;
+            target: any;
+            sourcemap: any;
+        } | null;
+        env: {
+            include: any;
+        } | null;
+        versionDispatcher: any;
+        permissions: {
+            defaultPolicy: string;
+            enabled: boolean;
+            audit: string;
+            rules: any;
+        } | null;
+    };
+    normalizeTypeScript(typescript: any): {
+        enabled: boolean;
+        mode: string;
+        types?: undefined;
+        target?: undefined;
+        sourcemap?: undefined;
+    } | {
+        enabled: boolean;
+        mode: string;
+        types: any;
+        target: any;
+        sourcemap: any;
+    } | null;
+    normalizeEnv(env: any): {
+        include: any;
+    } | null;
+    normalizePermissions(permissions: any): {
+        defaultPolicy: string;
+        enabled: boolean;
+        audit: string;
+        rules: any;
     } | null;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/types/dist/lib/helpers/config.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/config.mjs"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH;IACC,gCAAmC;IAEnC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,qCAxBW,MAAM,MAAO,OAkDvB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,+CAcC;IAED;;;;;OAKG;IACH,6BAJW,OAAO,MAAO,OAiExB;IAED;;;;;;OAMG;IACH,0CA2IC;IAED;;;;;OAKG;IACH,uCAJW,OAAO,GAAC,MAAM,MAAO,GACnB,MAAO,IAAI,CAsCvB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,yBArBW,MAAO,IAAI,GAAC,SAAS,GAEnB;QAAE,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,GAAC,IAAI,CA4BtC;CACD;8BAxc6B,0CAA0C"}
+{"version":3,"file":"config.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/config.mjs"],"names":[],"mappings":"AAAsH;IAAmC,gCAAiC;IAAA;;;MAA2mB;IAAA,iDAA+U;IAAA,2CAA0S;IAAA;;;;;MAAqV;IAAA;;;;;;;;;;;;MAA46B;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAyoH;IAAA;;;;;;;;;;;;aAAyf;IAAA;;aAAiN;IAAA;;;;;aAA2wC;CAAC;8BAAruQ,0CAA0C"}

package/types/dist/lib/helpers/eventemitter-context.d.mts

@@ -1,31 +1,5 @@
-/**
- * Set the context checker callback
- * Called by the runtime to register a way to detect API context
- * @param {Function} checker - Function that returns true if in API context
- * @public
- */
-export function setApiContextChecker(checker: Function): void;
-/**
- * Enable EventEmitter context propagation by patching EventEmitter.prototype.
- * This should be called ONCE globally when the first slothlet instance is created.
- * Subsequent calls will be ignored (patching is global).
- *
- * @public
- */
-export function enableEventEmitterPatching(): void;
-/**
- * Disable EventEmitter context propagation and restore original methods.
- * This should only be called when ALL slothlet instances have been shut down.
- *
- * @public
- */
-export function disableEventEmitterPatching(): void;
-/**
- * Cleanup all tracked EventEmitters created within slothlet API context.
- * This removes all listeners from tracked emitters and clears tracking structures.
- * Should be called during shutdown to prevent memory leaks and hanging processes.
- *
- * @public
- */
 export function cleanupEventEmitterResources(): void;
+export function disableEventEmitterPatching(): void;
+export function enableEventEmitterPatching(): void;
+export function setApiContextChecker(checker: any): void;
 //# sourceMappingURL=eventemitter-context.d.mts.map

package/types/dist/lib/helpers/eventemitter-context.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eventemitter-context.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/eventemitter-context.mjs"],"names":[],"mappings":"AAsCA;;;;;GAKG;AACH,8DAEC;AAyWD;;;;;;GAMG;AACH,mDAeC;AAED;;;;;GAKG;AACH,oDAmBC;AAED;;;;;;GAMG;AACH,qDAcC"}
+{"version":3,"file":"eventemitter-context.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/eventemitter-context.mjs"],"names":[],"mappings":"AAAu2M,qDAAmL;AAAtjB,oDAAmY;AAAroB,mDAAkQ;AAA13L,yDAA8D"}

package/types/dist/lib/helpers/hint-detector.d.mts

@@ -1,20 +1,7 @@
-/**
- * Hint detection for providing helpful error hints
- * @class HintDetector
- * @extends ComponentBase
- * @package
- */
 export class HintDetector extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Detect appropriate hint key based on error
-     * @param {Error} error - The original error
-     * @param {string} errorCode - The SlothletError code
-     * @returns {string|undefined} Hint key for i18n translation, or undefined
-     * @public
-     */
-    public detectHint(error: Error, errorCode: string): string | undefined;
+    detectHint(error: any, errorCode: any): string;
 }
-export const detectHint: any;
+export function detectHint(error: any, errorCode: any): string;
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=hint-detector.d.mts.map

package/types/dist/lib/helpers/hint-detector.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"hint-detector.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/hint-detector.mjs"],"names":[],"mappings":"AAwCA;;;;;GAKG;AACH;IACC,gCAAyC;IAEzC;;;;;;OAMG;IACH,yBALW,KAAK,aACL,MAAM,GACJ,MAAM,GAAC,SAAS,CAiB5B;CACD;AAID,6BAA2G;8BAxD7E,0CAA0C"}
+{"version":3,"file":"hint-detector.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/hint-detector.mjs"],"names":[],"mappings":"AAA4S;IAAyC,gCAAuC;IAAA,+CAA2M;CAAC;AAA5M,+DAA2M;8BAA9iB,0CAA0C"}

package/types/dist/lib/helpers/modes-utils.d.mts

@@ -1,35 +1,8 @@
-/**
- * Mode processing utilities component class
- * @extends ComponentBase
- */
 export class ModesUtils extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Create a named wrapper for default export functions when they are anonymous.
-     * NOTE: This function is now a pass-through since UnifiedWrapper handles name/length/toString
-     * through its proxy get trap. Wrapping is no longer needed and causes toString mismatches.
-     * @param {Function} fn - Original function.
-     * @param {string} nameHint - Name to apply if fn is anonymous or named "default" (unused).
-     * @returns {Function} Original function unmodified.
-     * @public
-     */
-    public ensureNamedExportFunction(fn: Function, ____nameHint: any): Function;
-    /**
-     * Clone eager-mode module exports to avoid mutating import cache objects.
-     * @param {unknown} value - Value to clone for wrapping
-     * @param {string} mode - Current mode ("eager" or "lazy")
-     * @returns {unknown} Cloned value for eager mode, original otherwise
-     * @public
-     */
-    public cloneWrapperImpl(value: unknown, mode: string): unknown;
-    /**
-     * Helper to determine collision mode for ownership conflicts
-     * @param {Object} config - Slothlet configuration
-     * @param {string} collisionContext - Either 'initial' or 'api'
-     * @returns {string} Collision mode from config
-     * @public
-     */
-    public getOwnershipCollisionMode(config: any, collisionContext?: string): string;
+    ensureNamedExportFunction(fn: any, ____nameHint: any): any;
+    cloneWrapperImpl(value: any, mode: any): any;
+    getOwnershipCollisionMode(config: any, collisionContext?: string): any;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=modes-utils.d.mts.map

package/types/dist/lib/helpers/modes-utils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"modes-utils.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/modes-utils.mjs"],"names":[],"mappings":"AAqBA;;;GAGG;AACH;IACC,gCAAuC;IAEvC;;;;;;;;OAQG;IACH,4EAIC;IAED;;;;;;OAMG;IACH,+BALW,OAAO,QACP,MAAM,GACJ,OAAO,CAenB;IAED;;;;;;OAMG;IACH,iEAJW,MAAM,GACJ,MAAM,CAKlB;CACD;8BAvD6B,0CAA0C"}
+{"version":3,"file":"modes-utils.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/modes-utils.mjs"],"names":[],"mappings":"AAAoE;IAAuC,gCAAqC;IAAA,2DAAqD;IAAA,6CAAqR;IAAA,uEAAkH;CAAC;8BAApjB,0CAA0C"}

package/types/dist/lib/helpers/pattern-matcher.d.mts

@@ -0,0 +1,4 @@
+export function compilePattern(pattern: any, options?: {}): any;
+export function expandBraces(pattern: any, depth?: number, maxDepth?: number, options?: {}): any;
+export function splitBraceAlternatives(content: any): string[];
+//# sourceMappingURL=pattern-matcher.d.mts.map

package/types/dist/lib/helpers/pattern-matcher.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-matcher.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/pattern-matcher.mjs"],"names":[],"mappings":"AAAkD,gEAA+oB;AAAA,iGAA44B;AAAA,+DAAqX"}

package/types/dist/lib/helpers/resolve-from-caller.d.mts

@@ -1,32 +1,8 @@
-/**
- * Path resolver component
- * @class Resolver
- * @extends ComponentBase
- * @package
- */
 export class Resolver extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Get V8 stack trace as CallSite array.
-     * @param {Function} [skipFn] - Optional function to skip from stack trace
-     * @returns {Array} Array of CallSite objects
-     * @public
-     */
-    public getStack(skipFn?: Function): any[];
-    /**
-     * Convert file:// URL to filesystem path or return as-is.
-     * @param {any} v - Value to convert
-     * @returns {string|null} Filesystem path or null
-     * @public
-     */
-    public toFsPath(v: any): string | null;
-    /**
-     * Resolve relative path from caller's context.
-     * @param {string} rel - Relative path to resolve
-     * @returns {string} Absolute filesystem path
-     * @public
-     */
-    public resolvePathFromCaller(rel: string): string;
+    getStack(skipFn: any): string | undefined;
+    toFsPath(v: any): any;
+    resolvePathFromCaller(rel: any): any;
     #private;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/types/dist/lib/helpers/resolve-from-caller.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-from-caller.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/resolve-from-caller.mjs"],"names":[],"mappings":"AAqCA;;;;;GAKG;AACH;IACC,gCAAqC;IAErC;;;;;OAKG;IACH,0CAUC;IAeD;;;;;OAKG;IACH,mBAJW,GAAG,GACD,MAAM,GAAC,IAAI,CAOvB;IA+FD;;;;;OAKG;IACH,kCAJW,MAAM,GACJ,MAAM,CAsClB;;CACD;8BAvM6B,0CAA0C"}
+{"version":3,"file":"resolve-from-caller.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/resolve-from-caller.mjs"],"names":[],"mappings":"AAAwX;IAAqC,gCAAmC;IAAA,0CAA2N;IAA0L,sBAA0G;IAAm5B,qCAA0c;;CAAC;8BAA5qE,0CAA0C"}

package/types/dist/lib/helpers/sanitize.d.mts

@@ -1,98 +1,10 @@
-/**
- * Standalone sanitizePropertyName function for backward compatibility
- * @param {string} input - Input string to sanitize
- * @param {object} options - Sanitization options
- * @returns {string} Sanitized property name
- * @public
- */
-export function sanitizePropertyName(input: string, options?: object): string;
-/**
- * Advanced filename sanitization with rule-based transformation
- * @extends ComponentBase
- * @public
- */
 export class Sanitize extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Advanced sanitization function with configurable rule-based transformation
-     *
-     * @description
-     * Converts arbitrary strings (filenames, path segments) into valid JavaScript identifiers
-     * suitable for dot-notation property access. Supports sophisticated rule-based transformation
-     * with glob patterns, case preservation, and intelligent segment handling.
-     *
-     * @param {string} input - String to sanitize
-     * @param {Object} [options={}] - Sanitization configuration
-     * @param {boolean} [options.lowerFirst=true] - Lowercase first character of first segment
-     * @param {boolean} [options.preserveAllUpper=false] - Preserve all-uppercase identifiers
-     * @param {boolean} [options.preserveAllLower=false] - Preserve all-lowercase identifiers
-     * @param {Object} [options.rules={}] - Transformation rules
-     * @param {string[]} [options.rules.leave=[]] - Preserve exactly (case-sensitive, supports globs)
-     * @param {string[]} [options.rules.leaveInsensitive=[]] - Preserve exactly (case-insensitive, supports globs)
-     * @param {string[]} [options.rules.upper=[]] - Force UPPERCASE (supports globs and **STRING**)
-     * @param {string[]} [options.rules.lower=[]] - Force lowercase (supports globs and **STRING**)
-     * @returns {string} Valid JavaScript identifier
-     * @public
-     *
-     * @example
-     * // Basic usage
-     * sanitizePropertyName("auto-ip"); // "autoIp"
-     * sanitizePropertyName("root-math"); // "rootMath"
-     *
-     * @example
-     * // Rule-based transformation
-     * sanitizePropertyName("auto-ip", {
-     *   rules: { upper: ["*-ip"] }
-     * }); // "autoIP"
-     *
-     * @example
-     * // Boundary-requiring patterns
-     * sanitizePropertyName("parseJsonData", {
-     *   rules: { upper: ["**json**"] }
-     * }); // "parseJSONData"
-     *
-     * @example
-     * // Case preservation
-     * sanitizePropertyName("COMMON_APPS", {
-     *   preserveAllUpper: true
-     * }); // "COMMON_APPS"
-     *
-     * @example
-     * // Multiple rules
-     * sanitizePropertyName("get-api-status", {
-     *   rules: {
-     *     upper: ["*-api-*", "http"],
-     *     lower: ["xml"]
-     *   }
-     * }); // "getAPIStatus"
-     */
-    public sanitizePropertyName(input: string, options?: {
-        lowerFirst?: boolean;
-        preserveAllUpper?: boolean;
-        preserveAllLower?: boolean;
-        rules?: {
-            leave?: string[];
-            leaveInsensitive?: string[];
-            upper?: string[];
-            lower?: string[];
-        };
-    }): string;
-    /**
-     * Get module ID from file path
-     * @param {string} filePath - Full file path
-     * @param {string} baseDir - Base directory
-     * @returns {string} Module ID
-     * @public
-     */
-    public getModuleId(filePath: string, baseDir: string): string;
-    /**
-     * Check if filename represents a special function name that should preserve case
-     * @param {string} name - Name to check
-     * @returns {boolean} True if special case should be preserved
-     * @public
-     */
-    public shouldPreserveFunctionCase(name: string): boolean;
+    sanitizePropertyName(input: any, options?: {}): string;
+    getModuleId(filePath: any, baseDir: any): any;
+    shouldPreserveFunctionCase(name: any): boolean;
     #private;
 }
+export function sanitizePropertyName(input: any, options?: {}): string;
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=sanitize.d.mts.map

package/types/dist/lib/helpers/sanitize.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sanitize.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/sanitize.mjs"],"names":[],"mappings":"AAkcA;;;;;;GAMG;AACH,4CALW,MAAM,YACN,MAAM,GACJ,MAAM,CAMlB;AAnbD;;;;GAIG;AACH;IACC,gCAAqC;IA6LrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACH,mCA7CW,MAAM,YAEd;QAA0B,UAAU,GAA5B,OAAO;QACW,gBAAgB,GAAlC,OAAO;QACW,gBAAgB,GAAlC,OAAO;QACU,KAAK,GAC9B;YAAiC,KAAK,GAA9B,MAAM,EAAE;YACiB,gBAAgB,GAAzC,MAAM,EAAE;YACiB,KAAK,GAA9B,MAAM,EAAE;YACiB,KAAK,GAA9B,MAAM,EAAE;SAChB;KAAA,GAAU,MAAM,CA8KlB;IAED;;;;;;OAMG;IACH,6BALW,MAAM,WACN,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,GACJ,OAAO,CAUnB;;CACD;8BAza6B,0CAA0C"}
+{"version":3,"file":"sanitize.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/sanitize.mjs"],"names":[],"mappings":"AAAoE;IAAqC,gCAAmC;IAAg6G,uDAA4qG;IAAA,8CAA+L;IAAA,+CAA8I;;CAAC;AAAA,uEAAwI;8BAArpO,0CAA0C"}

package/types/dist/lib/helpers/utilities.d.mts

@@ -1,57 +1,9 @@
-/**
- * General utility functions
- * @class Utilities
- * @extends ComponentBase
- * @package
- */
 export class Utilities extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Check if value is a plain object
-     * @param {*} obj - Value to check
-     * @returns {boolean} True if plain object
-     * @public
-     */
-    public isPlainObject(obj: any): boolean;
-    /**
-     * Deep merge two plain objects recursively.
-     *
-     * Differences from a simple spread:
-     * - Recursively merges nested plain objects rather than replacing them.
-     * - Uses `hasOwnProperty` to skip prototype-chain keys (no prototype pollution).
-     * - Non-plain values (arrays, class instances, primitives) are always copied by
-     *   value from `source`, never merged.
-     * - When `source[key]` is a plain object but `target[key]` is not (or absent),
-     *   the merge starts from `{}` so the returned sub-tree is always a fresh copy.
-     * - If either top-level argument is not a plain object, returns `source` as-is.
-     *
-     * @param {Object} target - Base object (not mutated).
-     * @param {Object} source - Source object whose keys are merged in.
-     * @returns {Object} New merged object.
-     * @public
-     */
-    public deepMerge(target: any, source: any): any;
-    /**
-     * Deep clone a value, handling Proxy objects and functions that `structuredClone`
-     * cannot serialise.
-     *
-     * Strategy:
-     * 1. Try `structuredClone` — fast and spec-correct for plain data.
-     * 2. Fall back to a manual recursive copy for Proxies, callables, and other
-     *    non-serialisable objects; errors on individual property clones are swallowed
-     *    and the original reference is retained for that key.
-     *
-     * @param {unknown} obj - Value to clone.
-     * @returns {unknown} Deep clone of `obj`.
-     * @public
-     */
-    public deepClone(obj: unknown): unknown;
-    /**
-     * Generate unique ID
-     * @returns {string} Unique identifier
-     * @public
-     */
-    public generateId(): string;
+    isPlainObject(obj: any): boolean;
+    deepMerge(target: any, source: any): any;
+    deepClone(obj: any): any;
+    generateId(): string;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=utilities.d.mts.map

package/types/dist/lib/helpers/utilities.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"utilities.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/utilities.mjs"],"names":[],"mappings":"AAsBA;;;;;GAKG;AACH;IACC,gCAAsC;IAEtC;;;;;OAKG;IACH,0BAJW,GAAC,GACC,OAAO,CAOnB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,gDAoBC;IAED;;;;;;;;;;;;;OAaG;IACH,sBAJW,OAAO,GACL,OAAO,CAyBnB;IAED;;;;OAIG;IACH,qBAHa,MAAM,CAKlB;CACD;8BA5G6B,0CAA0C"}
+{"version":3,"file":"utilities.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/utilities.mjs"],"names":[],"mappings":"AAAoE;IAAsC,gCAAoC;IAAA,iCAA0J;IAAA,yCAAmX;IAAA,yBAA+Y;IAAA,qBAAsF;CAAC;8BAAxmC,0CAA0C"}

package/types/dist/lib/i18n/translations.d.mts

@@ -1,39 +1,6 @@
-/**
- * Set current language (synchronous)
- * Merges requested language translations over default English translations
- * @param {string} lang - Language code
- * @public
- */
-export function setLanguage(lang: string): void;
-/**
- * Get current language
- * @returns {string} Language code
- * @public
- */
 export function getLanguage(): string;
-/**
- * Translate error message with interpolation
- * @param {string} errorCode - Error code
- * @param {Object} params - Parameters for interpolation
- * @returns {string} Translated message
- * @public
- */
-export function translate(errorCode: string, params?: any): string;
-/**
- * Initialize i18n system (synchronous)
- * @param {Object} options - Options
- * @param {string} [options.language] - Language code (auto-detect if not provided)
- * @public
- */
-export function initI18n(options?: {
-    language?: string;
-}): void;
-/**
- * Translate error message with interpolation
- * @param {string} errorCode - Error code
- * @param {Object} params - Parameters for interpolation
- * @returns {string} Translated message
- * @public
- */
-export function t(errorCode: string, params?: any): string;
+export function initI18n(options?: {}): void;
+export function setLanguage(lang: any): void;
+export function t(errorCode: any, params?: {}): any;
+export function translate(errorCode: any, params?: {}): any;
 //# sourceMappingURL=translations.d.mts.map