@cldmv/slothlet 2.10.0 → 3.0.0

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

@@ -0,0 +1,35 @@
+/**
+ * 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;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
+//# sourceMappingURL=modes-utils.d.mts.map

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

@@ -0,0 +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"}

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

@@ -1,149 +1,33 @@
 /**
- * @function getStack
+ * Path resolver component
+ * @class Resolver
+ * @extends ComponentBase
  * @package
- * @internal
- * @param {Function} [skipFn] - Function to skip in stack trace via Error.captureStackTrace
- * @returns {Array<CallSite>} Array of V8 CallSite objects with methods like getFileName(), getLineNumber(), etc.
- *
- * @description
- * Get V8 stack trace as CallSite array for debugging and caller detection.
- * Temporarily overrides Error.prepareStackTrace to access raw V8 CallSite objects
- * instead of formatted string stack traces. Provides safe restoration of original handler.
- *
- * @example
- * // Get current call stack for debugging
- * const stack = getStack();
- * console.log(stack[0]?.getFileName?.()); // Current file path
- * console.log(stack[0]?.getLineNumber?.()); // Current line number
- *
- * @example
- * // Skip current function from stack trace
- * function myFunction() {
- *   return getStack(myFunction); // Stack starts from caller of myFunction
- * }
- * const callerStack = myFunction();
- *
- * @example
- * // Stack analysis for caller detection
- * function findCaller() {
- *   const stack = getStack(findCaller);
- *   for (const frame of stack) {
- *     const filename = frame?.getFileName?.();
- *     if (filename && !filename.includes("node_modules")) {
- *       return filename; // First non-dependency file
- *     }
- *   }
- * }
  */
-export function getStack(skipFn?: Function): Array<CallSite>;
-/**
- * @function resolvePathFromCaller
- * @package
- * @internal
- * @param {string} rel - Relative path to resolve (e.g., "../config.json", "./data/file.txt")
- * @returns {string} Absolute filesystem path with platform-specific separators
- * @throws {TypeError} When rel parameter is not a string
- *
- * @description
- * Resolve a relative path from the caller's context to an absolute filesystem path.
- * Primary public API for filesystem path resolution with intelligent caller detection.
- * Uses sophisticated stack trace analysis to determine the appropriate base directory.
- *
- * Resolution behavior:
- * - file:// URLs: Converted to filesystem paths via fileURLToPath()
- * - Absolute paths: Returned unchanged (already absolute)
- * - Relative paths: Resolved using caller detection algorithm
- *
- * Caller detection process:
- * 1. Primary: Use sophisticated slothlet.mjs-aware stack analysis
- * 2. Fallback: Use first non-helper frame if primary fails
- * 3. Existence check: Prefer primary if target exists, otherwise use fallback
- *
- * @example
- * // From a file at /project/src/modules/math.mjs
- * const configPath = resolvePathFromCaller("../config.json");
- * // Returns: /project/config.json (absolute filesystem path)
- *
- * @example
- * // Short-circuit cases
- * resolvePathFromCaller("file:///absolute/path.txt");
- * // Returns: /absolute/path.txt (converted from URL)
- *
- * resolvePathFromCaller("/already/absolute/path.txt");
- * // Returns: /already/absolute/path.txt (unchanged)
- *
- * @example
- * // Relative resolution from different contexts
- * // If called from /project/src/lib/utils.mjs:
- * resolvePathFromCaller("./helpers/format.js");
- * // Returns: /project/src/lib/helpers/format.js
- *
- * resolvePathFromCaller("../../config/settings.json");
- * // Returns: /project/config/settings.json
- */
-export function resolvePathFromCaller(rel: string): string;
-/**
- * @function resolveUrlFromCaller
- * @package
- * @internal
- * @param {string} rel - Relative path to resolve (e.g., "../config.json", "./data/file.txt")
- * @returns {string} Absolute file:// URL suitable for dynamic imports and URL operations
- * @throws {TypeError} When rel parameter is not a string
- *
- * @description
- * Resolve a relative path from the caller's context to a file:// URL.
- * Companion API to resolvePathFromCaller that returns file:// URLs instead of filesystem paths.
- * Uses identical caller detection algorithm but outputs URL format for ESM imports.
- *
- * Resolution behavior:
- * - file:// URLs: Returned unchanged (already in URL format)
- * - Absolute paths: Converted to file:// URLs via pathToFileURL()
- * - Relative paths: Resolved using caller detection, then converted to URL
- *
- * Caller detection uses the same sophisticated algorithm as resolvePathFromCaller,
- * but the final result is converted to a file:// URL for compatibility with
- * ESM dynamic imports and other URL-based operations.
- *
- * @example
- * // From a file at /project/src/modules/math.mjs
- * const configUrl = resolveUrlFromCaller("../config.json");
- * // Returns: file:///project/config.json (absolute file:// URL)
- *
- * @example
- * // Short-circuit cases
- * resolveUrlFromCaller("file:///absolute/path.txt");
- * // Returns: file:///absolute/path.txt (unchanged)
- *
- * resolveUrlFromCaller("/already/absolute/path.txt");
- * // Returns: file:///already/absolute/path.txt (converted to URL)
- *
- * @example
- * // Dynamic ESM import usage
- * const modulePath = resolveUrlFromCaller("./dynamic-module.mjs");
- * const dynamicModule = await import(modulePath);
- * // Works seamlessly with ESM import() which expects URLs
- *
- * @example
- * // Cross-platform URL handling
- * // Unix: resolveUrlFromCaller("../config.json") → file:///project/config.json
- * // Windows: resolveUrlFromCaller("../config.json") → file:///C:/project/config.json
- */
-export function resolveUrlFromCaller(rel: string): string;
-export function toFsPath(v: any): string | null;
-export type CallSite = {
-    getFileName: () => string | undefined;
-    getLineNumber: () => number | undefined;
-    getFunctionName: () => string | undefined;
-    getTypeName: () => string | undefined;
-    getMethodName: () => string | undefined;
-    getScriptNameOrSourceURL: () => string | undefined;
-    getColumnNumber: () => number | undefined;
-    isNative: () => boolean | undefined;
-    isEval: () => boolean | undefined;
-    isConstructor: () => boolean | undefined;
-    isToplevel: () => boolean | undefined;
-    isAsync: () => boolean | undefined;
-    isPromiseAll: () => boolean | undefined;
-    getPromiseIndex: () => number | undefined;
-};
+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;
+    #private;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=resolve-from-caller.d.mts.map

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":"AAqFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,6CAhCa,KAAK,CAAC,QAAQ,CAAC,CA0C3B;AAqKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,2CAzCW,MAAM,GACJ,MAAM,CAsDlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,0CA1CW,MAAM,GACJ,MAAM,CAuDlB;AA/UM,4BAvBI,GAAG,GACD,MAAM,GAAC,IAAI,CAsB+F;;iBAmVzG,MAAY,MAAM,GAAC,SAAS;mBAC5B,MAAY,MAAM,GAAC,SAAS;qBAC5B,MAAY,MAAM,GAAC,SAAS;iBAC5B,MAAY,MAAM,GAAC,SAAS;mBAC5B,MAAY,MAAM,GAAC,SAAS;8BAC5B,MAAY,MAAM,GAAC,SAAS;qBAC5B,MAAY,MAAM,GAAC,SAAS;cAC5B,MAAY,OAAO,GAAC,SAAS;YAC7B,MAAY,OAAO,GAAC,SAAS;mBAC7B,MAAY,OAAO,GAAC,SAAS;gBAC7B,MAAY,OAAO,GAAC,SAAS;aAC7B,MAAY,OAAO,GAAC,SAAS;kBAC7B,MAAY,OAAO,GAAC,SAAS;qBAC7B,MAAY,MAAM,GAAC,SAAS"}
+{"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;IA4FD;;;;;OAKG;IACH,kCAJW,MAAM,GACJ,MAAM,CAsClB;;CACD;8BApM6B,0CAA0C"}

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

@@ -1,97 +1,98 @@
 /**
- * @function sanitizePathName
- * @package
- * @internal
- * @param {string} input - The input string to sanitize (e.g., file name, path segment)
- * @param {Object} [opts={}] - Sanitization configuration options
- * @param {boolean} [opts.lowerFirst=true] - Lowercase the first character of the first segment for camelCase convention
- * @param {boolean} [opts.preserveAllUpper=false] - Automatically preserve any identifier that is already in all-uppercase format
- * @param {boolean} [opts.preserveAllLower=false] - Automatically preserve any identifier that is already in all-lowercase format
- * @param {Object} [opts.rules={}] - Advanced segment transformation rules (supports glob patterns: *, ?, **STRING**)
- * @param {string[]} [opts.rules.leave=[]] - Segments to preserve exactly as-is (case-sensitive, supports globs)
- * @param {string[]} [opts.rules.leaveInsensitive=[]] - Segments to preserve exactly as-is (case-insensitive, supports globs)
- * @param {string[]} [opts.rules.upper=[]] - Segments to force to UPPERCASE (supports globs and **STRING** boundary patterns)
- * @param {string[]} [opts.rules.lower=[]] - Segments to force to lowercase (supports globs and **STRING** boundary patterns)
- * @returns {string} Valid JavaScript identifier safe for dot-notation property access
- * @throws {TypeError} When input parameter is not a string
- *
- * @description
- * Sanitize a string into a JS identifier suitable for dot-path usage.
- * Advanced sanitization function that applies rules intelligently before splitting while
- * maintaining proper camelCase transformation. Uses sophisticated tracking to ensure
- * rule-matched segments are preserved correctly through the transformation process.
- *
- * @example
- * // Basic sanitization (already valid identifiers unchanged)
- * sanitizePathName("autoIP");                // "autoIP"  (no change needed)
- * sanitizePathName("validIdentifier");       // "validIdentifier" (no change needed)
- * sanitizePathName("auto_ip");               // "auto_ip" (valid identifier preserved)
- *
- * @example
- * // Standard camelCase conversion
- * sanitizePathName("auto-ip");               // "autoIp" (dash becomes camelCase)
- * sanitizePathName("my file!.mjs");          // "myFileMjs" (spaces and special chars removed)
- * sanitizePathName("foo-bar-baz");           // "fooBarBaz" (multi-segment camelCase)
- *
- * @example
- * // Pre-split pattern matching (matches original filename patterns)
- * sanitizePathName("auto-ip", {
- *   rules: {
- *     upper: ["*-ip"]  // Matches before splitting
- *   }
- * }); // Result: "autoIP" (ip becomes IP due to *-ip pattern)
- *
- * @example
- * // Complex pattern matching with intelligent tracking
- * sanitizePathName("get-api-status", {
- *   rules: {
- *     upper: ["*-api-*"]  // Matches api in middle of filename
- *   }
- * }); // Result: "getAPIStatus" (api becomes API due to pattern)
- *
- * @example
- * // Automatic case preservation
- * sanitizePathName("COMMON_APPS", { preserveAllUpper: true });      // "COMMON_APPS" (preserved)
- * sanitizePathName("cOMMON_APPS", { preserveAllUpper: true });      // "cOMMON_APPS" (not all-uppercase, transformed)
- * sanitizePathName("common_apps", { preserveAllLower: true });      // "common_apps" (preserved)
- * sanitizePathName("Common_apps", { preserveAllLower: true });      // "commonApps" (not all-lowercase, transformed)
- *
- * @example
- * // Combining preserve options with other rules
- * sanitizePathName("parse-XML-data", {
- *   preserveAllUpper: true,
- *   rules: { upper: ["xml"] }
- * }); // "parseXMLData" (XML preserved by preserveAllUpper)
- *
- * @example
- * // Boundary-requiring patterns with **STRING** syntax
- * sanitizePathName("buildUrlWithParams", {
- *   rules: {
- *     upper: ["**url**"]  // Only matches "url" when surrounded by other characters
- *   }
- * }); // Result: "buildURLWithParams" (url becomes URL, surrounded by other chars)
- *
- * sanitizePathName("url", {
- *   rules: {
- *     upper: ["**url**"]  // Does NOT match standalone "url" (no surrounding chars)
- *   }
- * }); // Result: "url" (unchanged - no surrounding characters)
- *
- * sanitizePathName("parseJsonData", {
- *   rules: {
- *     upper: ["**json**"]  // Matches "json" surrounded by other characters
- *   }
- * }); // Result: "parseJSONData" (json becomes JSON)
+ * 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 sanitizePathName(input: string, opts?: {
-    lowerFirst?: boolean;
-    preserveAllUpper?: boolean;
-    preserveAllLower?: boolean;
-    rules?: {
-        leave?: string[];
-        leaveInsensitive?: string[];
-        upper?: string[];
-        lower?: string[];
-    };
-}): string;
+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;
+    #private;
+}
+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":"AAgFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,wCAjFW,MAAM,SAEd;IAAuB,UAAU,GAAzB,OAAO;IACQ,gBAAgB,GAA/B,OAAO;IACQ,gBAAgB,GAA/B,OAAO;IACO,KAAK,GAC3B;QAA8B,KAAK,GAA3B,MAAM,EAAE;QACc,gBAAgB,GAAtC,MAAM,EAAE;QACc,KAAK,GAA3B,MAAM,EAAE;QACc,KAAK,GAA3B,MAAM,EAAE;KAChB;CAAA,GAAU,MAAM,CAuSlB"}
+{"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"}

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

@@ -1,120 +1,57 @@
 /**
- *	@Project: @cldmv/slothlet
- *	@Filename: /src/lib/helpers/utilities.mjs
- *	@Date: 2025-12-30 08:44:44 -08:00 (1767113084)
- *	@Author: Nate Hyson <CLDMV>
- *	@Email: <Shinrai@users.noreply.github.com>
- *	-----
- *	@Last modified by: Nate Hyson <CLDMV> (Shinrai@users.noreply.github.com)
- *	@Last modified time: 2025-12-30 08:54:56 -08:00 (1767113696)
- *	-----
- *	@Copyright: Copyright (c) 2013-2025 Catalyzed Motivation Inc. All rights reserved.
- */
-/**
- * @fileoverview Utility functions for property manipulation and object operations.
- * @module @cldmv/slothlet/lib/helpers/utilities
- * @memberof module:@cldmv/slothlet.lib.helpers
- * @internal
- * @private
- *
- * @description
- * Provides general-purpose utility functions for safe property definition, deep object merging,
- * and live-binding variable mutation. These utilities are used throughout slothlet for
- * object manipulation, property management, and live-binding operations.
- *
- * Exported Functions:
- * - safeDefine: Safe property definition handling non-configurable properties
- * - deepMerge: Recursive deep merge for object combining
- * - mutateLiveBindingFunction: Live-binding variable mutation preserving references
- *
- * @example
- * // Internal usage in slothlet
- * import { safeDefine, deepMerge, mutateLiveBindingFunction } from "./utilities.mjs";
- *
- * safeDefine(api, "shutdown", shutdownFunction, false);
- * const merged = deepMerge(target, source);
- * mutateLiveBindingFunction(boundapi, newApi);
- */
-/**
- * Safely defines a property on an object, handling non-configurable properties.
- *
- * @function safeDefine
- * @memberof module:@cldmv/slothlet.lib.helpers.utilities
- * @param {object} obj - Target object
- * @param {string} key - Property key
- * @param {*} value - Property value
- * @param {boolean} [enumerable=false] - Whether the property should be enumerable (default: false for management methods)
- * @param {object} [config=null] - Optional configuration object with debug flag
- * @package
- *
- * @description
- * Attempts to define a property on an object with the specified configuration.
- * Handles cases where the property is non-configurable by logging a warning
- * instead of throwing an error. Used for safely attaching management methods
- * like shutdown, addApi, and describe to API objects.
- *
- * @example
- * // Internal usage
- * import { safeDefine } from "./utilities.mjs";
- *
- * safeDefine(api, "shutdown", shutdownFunction, false, { debug: true });
- */
-export function safeDefine(obj: object, key: string, value: any, enumerable?: boolean, config?: object): void;
-/**
- * Deep merge two objects recursively.
- *
- * @function deepMerge
- * @memberof module:@cldmv/slothlet.lib.helpers.utilities
- * @param {object} target - Target object to merge into
- * @param {object} source - Source object to merge from
- * @returns {object} Merged object (mutates target)
- * @package
- *
- * @description
- * Performs a recursive deep merge of two objects, combining nested structures.
- * Arrays are treated as primitive values and replaced rather than merged.
- * Used for context merging in scope operations.
- *
- * **Security Note**: This function explicitly blocks the `__proto__`, `prototype`, and
- * `constructor` keys to prevent prototype pollution attacks. Any attempt to merge
- * these dangerous keys will be silently ignored.
- *
- * @example
- * // Internal usage
- * import { deepMerge } from "./utilities.mjs";
- *
- * const target = { a: 1, b: { c: 2 } };
- * const source = { b: { d: 3 }, e: 4 };
- * const merged = deepMerge(target, source);
- * // Result: { a: 1, b: { c: 2, d: 3 }, e: 4 }
- */
-export function deepMerge(target: object, source: object): object;
-/**
- * Mutates a live-binding variable (object or function) to match a new value, preserving reference.
- *
- * @function mutateLiveBindingFunction
- * @memberof module:@cldmv/slothlet.lib.helpers.utilities
- * @param {function|object} target - The variable to mutate (object or function)
- * @param {function|object} source - The new value to copy from (object or function)
+ * General utility functions
+ * @class Utilities
+ * @extends ComponentBase
  * @package
- *
- * @description
- * Mutates an existing live-binding variable to match a new structure while
- * preserving the original reference. This is critical for maintaining live
- * bindings in modules that have imported self, context, or reference.
- *
- * For functions: Sets _impl to call source, removes old properties (except _impl and __ctx),
- * and attaches new properties from source.
- *
- * For objects: Removes old properties (except _impl and __ctx), attaches new properties,
- * and manually copies management methods (shutdown, addApi, describe).
- *
- * @example
- * // Internal usage
- * import { mutateLiveBindingFunction } from "./utilities.mjs";
- *
- * mutateLiveBindingFunction(self, newSelf);
- * mutateLiveBindingFunction(boundapi, newApi);
  */
-export function mutateLiveBindingFunction(target: Function | object, source: Function | object): void;
+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;
+}
+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":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,gCAnBW,MAAM,OACN,MAAM,SACN,GAAC,eACD,OAAO,WACP,MAAM,QAkChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,kCAvBW,MAAM,UACN,MAAM,GACJ,MAAM,CAkDlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,kDAtBW,WAAS,MAAM,UACf,WAAS,MAAM,QAkEzB"}
+{"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"}

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

@@ -0,0 +1,39 @@
+/**
+ * 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;
+//# sourceMappingURL=translations.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"translations.d.mts","sourceRoot":"","sources":["../../../../dist/lib/i18n/translations.mjs"],"names":[],"mappings":"AAqFA;;;;;GAKG;AACH,kCAHW,MAAM,QAsBhB;AAED;;;;GAIG;AACH,+BAHa,MAAM,CAKlB;AAED;;;;;;GAMG;AACH,qCALW,MAAM,iBAEJ,MAAM,CAyBlB;AAED;;;;;GAKG;AACH,mCAHG;IAAyB,QAAQ,GAAzB,MAAM;CACd,QAiBF;AApDD;;;;;;GAMG;AACH,6BALW,MAAM,iBAEJ,MAAM,CAyBlB"}