@cldmv/slothlet 2.11.0 → 3.0.1

package/types/dist/lib/engine/slothlet_child.d.mts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=slothlet_child.d.mts.map

package/types/dist/lib/engine/slothlet_child.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slothlet_child.d.mts","sourceRoot":"","sources":["../../../../dist/lib/engine/slothlet_child.mjs"],"names":[],"mappings":""}

package/types/dist/lib/engine/slothlet_engine.d.mts

@@ -1,31 +0,0 @@
-/**
- * Sets the shutdown function for the engine.
- * @param {Function} fn - Shutdown function to set
- * @returns {Function} Previously set shutdown function
- * @example
- * const prev = setShutdown(() => console.log("Shutting down"));
- */
-export function setShutdown(fn: Function): Function;
-/**
- * Creates a slothlet engine with the specified mode and options.
- * @param {object} allOptions - Engine configuration options
- * @param {string} allOptions.entry - Entry point for the slothlet module
- * @param {string} [allOptions.mode="vm"] - Engine mode: "vm", "worker", "fork", or "child"
- * @param {object} [allOptions.context] - Context object for modules
- * @param {object} [allOptions.reference] - Reference object for modules
- * @returns {Promise<object>} Engine instance with API and shutdown capabilities
- * @example
- * const engine = await createEngine({
- *   entry: './api/index.mjs',
- *   mode: 'vm',
- *   context: { user: 'alice' }
- * });
- */
-export function createEngine(allOptions: {
-    entry: string;
-    mode?: string;
-    context?: object;
-    reference?: object;
-}): Promise<object>;
-export function makeFacade2(portal: any): () => void;
-//# sourceMappingURL=slothlet_engine.d.mts.map

package/types/dist/lib/engine/slothlet_engine.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slothlet_engine.d.mts","sourceRoot":"","sources":["../../../../dist/lib/engine/slothlet_engine.mjs"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,oDAIC;AAED;;;;;;;;;;;;;;GAcG;AACH,yCAZG;IAA2B,KAAK,EAAxB,MAAM;IACc,IAAI,GAAxB,MAAM;IACc,OAAO,GAA3B,MAAM;IACc,SAAS,GAA7B,MAAM;CACd,GAAU,OAAO,CAAC,MAAM,CAAC,CAgC3B;AAyRD,qDA4BC"}

package/types/dist/lib/engine/slothlet_esm.d.mts

@@ -1,19 +0,0 @@
-/**
- * Minimal custom ESM loader for VM context fallback when SourceTextModule is unavailable.
- * Parses import/export statements, loads dependencies recursively, and evaluates code in context.
- * Limitations: Only supports static imports/exports, no top-level await, no dynamic import, no advanced ESM features.
- * @param {object} context - The VM context.
- * @param {string} fileUrl - The file URL to load.
- * @param {Set<string>} [visited] - Tracks loaded modules to prevent cycles.
- * @returns {Promise<object>} Module namespace object.
- * @example
- * const ns = await loadEsmModuleFallback(context, 'file:///path/to/mod.mjs');
- */
-export function loadEsmModuleFallback(context: object, fileUrl: string, visited?: Set<string>): Promise<object>;
-/**
- * Detects if a file is ESM based on extension or code content.
- * @param {string} fileUrl
- * @returns {Promise<boolean>}
- */
-export function isEsmFile(fileUrl: string): Promise<boolean>;
-//# sourceMappingURL=slothlet_esm.d.mts.map

package/types/dist/lib/engine/slothlet_esm.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slothlet_esm.d.mts","sourceRoot":"","sources":["../../../../dist/lib/engine/slothlet_esm.mjs"],"names":[],"mappings":"AAmBA;;;;;;;;;;GAUG;AACH,+CAPW,MAAM,WACN,MAAM,YACN,GAAG,CAAC,MAAM,CAAC,GACT,OAAO,CAAC,MAAM,CAAC,CAkM3B;AAED;;;;GAIG;AACH,mCAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAW5B"}

package/types/dist/lib/engine/slothlet_helpers.d.mts

@@ -1,25 +0,0 @@
-export function normalizeContext(ctx: any): any;
-export function installGlobalsInCurrentRealm(contextMap: any): void;
-export function extendSelfWithReference(self: any, reference: any): void;
-export function installPortalForSelf(): void;
-export function asUrl(p: any): any;
-export function isPlainObject(o: any): boolean;
-export function guessName(v: any): any;
-export function makeNodeishContext(): vm.Context;
-/**
- * Loads a module into a VM context, supporting ESM (mjs), CJS (cjs), or auto-detection.
- * @param {object} context - The VM context.
- * @param {string} fileUrl - The file URL to load.
- * @param {string} [mode='auto'] - 'auto', 'mjs', or 'cjs'.
- * @returns {Promise<object>} Module namespace or SourceTextModule.
- */
-export function loadEsmInVm2(context: object, fileUrl: string, mode?: string, ...args: any[]): Promise<object>;
-export function loadEsmInVm(context: any, fileUrl: any): Promise<any>;
-export function installContextGlobalsVM(context: any, userContext: any): void;
-export function bootSlothletVM(context: any, entryUrl: any, loadConfig: any, ctxRef: any): Promise<void>;
-export function marshalArgsReplaceFunctions(value: any, registerCb: any): any;
-export function reviveArgsReplaceTokens(value: any, invokeCb: any): any;
-export function containsFunction(value: any): boolean;
-export const HAS_STM: boolean;
-import vm from "node:vm";
-//# sourceMappingURL=slothlet_helpers.d.mts.map

package/types/dist/lib/engine/slothlet_helpers.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slothlet_helpers.d.mts","sourceRoot":"","sources":["../../../../dist/lib/engine/slothlet_helpers.mjs"],"names":[],"mappings":"AAuBA,gDAwBC;AAED,oEAGC;AAED,yEAYC;AAED,6CA6BC;AAED,mCAEC;AAED,+CAEC;AAED,uCAOC;AAQD,iDAyBC;AAED;;;;;;GAMG;AACH,sCALW,MAAM,WACN,MAAM,SACN,MAAM,mBACJ,OAAO,CAAC,MAAM,CAAC,CA2L3B;AAGD,sEAsDC;AAED,8EAYC;AAED,yGAmDC;AAID,8EAaC;AAED,wEAaC;AAED,sDAKC;AAhYD,8BAAiE;eA3GlD,SAAS"}

package/types/dist/lib/engine/slothlet_worker.d.mts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=slothlet_worker.d.mts.map

package/types/dist/lib/engine/slothlet_worker.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slothlet_worker.d.mts","sourceRoot":"","sources":["../../../../dist/lib/engine/slothlet_worker.mjs"],"names":[],"mappings":""}

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

@@ -1,56 +0,0 @@
-/**
- * Enable AsyncLocalStorage context propagation for all EventEmitter instances.
- *
- * @function enableAlsForEventEmitters
- * @package
- * @param {AsyncLocalStorage} [als] - The AsyncLocalStorage instance to use (defaults to slothlet's shared instance)
- *
- * @description
- * Patches EventEmitter.prototype to automatically preserve AsyncLocalStorage context
- * in event listeners using AsyncResource. This ensures that event handlers maintain
- * the same context that was active when they were registered.
- *
- * Uses Node.js AsyncResource API for proper context propagation, following
- * official guidance for AsyncLocalStorage across callback boundaries.
- *
- * @example
- * // Enable ALS for all EventEmitters
- * import { enableAlsForEventEmitters } from "./als-eventemitter.mjs";
- * enableAlsForEventEmitters(als);
- */
-export function enableAlsForEventEmitters(als?: AsyncLocalStorage<any>): void;
-/**
- * Disable AsyncLocalStorage context propagation for EventEmitter instances.
- *
- * @function disableAlsForEventEmitters
- * @package
- *
- * @description
- * Restores original EventEmitter methods, removing the AsyncLocalStorage
- * context propagation. This should be called during cleanup to prevent
- * hanging AsyncResource instances that can keep the event loop alive.
- *
- * @example
- * // Disable ALS patching during shutdown
- * disableAlsForEventEmitters();
- */
-/**
- * Clean up ALL listeners that went through slothlet's EventEmitter patching.
- *
- * @function cleanupAllSlothletListeners
- * @package
- *
- * @description
- * Removes all event listeners that were registered through slothlet's patched
- * EventEmitter methods. This includes listeners from third-party libraries
- * that got wrapped with AsyncResource instances. This nuclear cleanup option
- * should be called during shutdown to prevent hanging listeners.
- *
- * @example
- * // Clean up all patched listeners during shutdown
- * cleanupAllSlothletListeners();
- */
-export function cleanupAllSlothletListeners(): void;
-export function disableAlsForEventEmitters(): void;
-import { AsyncLocalStorage } from "node:async_hooks";
-//# sourceMappingURL=als-eventemitter.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"als-eventemitter.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/als-eventemitter.mjs"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8EAiNC;AAED;;;;;;;;;;;;;;GAcG;AACH;;;;;;;;;;;;;;;GAeG;AACH,oDAyBC;AAED,mDAmCC;kCArVgD,kBAAkB"}

package/types/dist/lib/helpers/api_builder/add_api.d.mts

@@ -1,102 +0,0 @@
-/**
- * @typedef {Object} AddApiFromFolderParams
- * @property {string} apiPath - Dot-notation path where modules will be added
- * @property {string} folderPath - Path to folder containing modules to load
- * @property {object} instance - Slothlet instance with api, boundapi, config, modes, etc.
- * @property {object} [metadata={}] - Metadata to attach to all loaded functions
- * @property {object} [options={}] - Additional options for module loading
- * @property {boolean} [options.forceOverwrite=false] - Allow overwriting existing APIs (requires Rule 12)
- * @property {string} [options.moduleId] - Module identifier for ownership tracking (required with forceOverwrite)
- */
-/**
- * @description
- * Dynamically adds API modules from a new folder to the existing API at a specified path.
- *
- * @function addApiFromFolder
- * @memberof module:@cldmv/slothlet.lib.helpers.api_builder.add_api
- * @param {AddApiFromFolderParams} params - Configuration object
- * @returns {Promise<void>}
- * @throws {Error} If API not loaded, invalid parameters, folder does not exist, or merge conflicts
- * @package
- *
- * This function enables runtime extension of the API by loading modules from a folder
- * and merging them into a specified location in the API tree. It performs comprehensive
- * validation, supports both relative and absolute paths, handles intermediate object
- * creation, and respects the allowApiOverwrite configuration.
- *
- * The method performs the following steps:
- * 1. Validates that the API is loaded and the folder exists
- * 2. Resolves relative folder paths from the caller location
- * 3. Loads modules from the specified folder using the current loading mode
- * 4. Navigates to the specified API path, creating intermediate objects as needed
- * 5. Merges the new modules into the target location
- * 6. Updates all live bindings to reflect the changes
- *
- * @example
- * // Internal usage
- * import { addApiFromFolder } from "./add_api.mjs";
- *
- * // Add additional modules at runtime.plugins path
- * await addApiFromFolder(
- *   "runtime.plugins",
- *   "./plugins",
- *   slothletInstance
- * );
- *
- * @example
- * // Add modules to root level
- * await addApiFromFolder(
- *   "utilities",
- *   "./utils",
- *   slothletInstance
- * );
- *
- * @example
- * // Add deep nested modules
- * await addApiFromFolder(
- *   "services.external.stripe",
- *   "./services/stripe",
- *   slothletInstance
- * );
- *
- * @example
- * // Add modules with metadata
- * await addApiFromFolder(
- *   "extensions.untrusted",
- *   "./untrusted-plugins",
- *   slothletInstance,
- *   {
- *     trusted: false,
- *     permissions: ["read"],
- *     version: "1.0.0",
- *     author: "external"
- *   }
- * );
- */
-export function addApiFromFolder({ apiPath, folderPath, instance, metadata, options }: AddApiFromFolderParams): Promise<void>;
-export type AddApiFromFolderParams = {
-    /**
-     * - Dot-notation path where modules will be added
-     */
-    apiPath: string;
-    /**
-     * - Path to folder containing modules to load
-     */
-    folderPath: string;
-    /**
-     * - Slothlet instance with api, boundapi, config, modes, etc.
-     */
-    instance: object;
-    /**
-     * - Metadata to attach to all loaded functions
-     */
-    metadata?: object;
-    /**
-     * - Additional options for module loading
-     */
-    options?: {
-        forceOverwrite?: boolean;
-        moduleId?: string;
-    };
-};
-//# sourceMappingURL=add_api.d.mts.map

package/types/dist/lib/helpers/api_builder/add_api.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"add_api.d.mts","sourceRoot":"","sources":["../../../../../dist/lib/helpers/api_builder/add_api.mjs"],"names":[],"mappings":"AAkDA;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,uFA3DW,sBAAsB,GACpB,OAAO,CAAC,IAAI,CAAC,CAskBzB;;;;;aAtlBa,MAAM;;;;gBACN,MAAM;;;;cACN,MAAM;;;;eACN,MAAM;;;;cAEjB;QAA6B,cAAc,GAAhC,OAAO;QACU,QAAQ,GAAzB,MAAM;KACnB"}

package/types/dist/lib/helpers/api_builder/analysis.d.mts

@@ -1,189 +0,0 @@
-/**
- * Helper function to check if a value is likely serializable without calling JSON.stringify.
- * Used by toJSON methods to avoid expensive serialization attempts on complex objects.
- *
- * @internal
- * @private
- * @param {*} val - The value to check for serializability
- * @returns {boolean} True if the value is likely serializable, false otherwise
- */
-export function isLikelySerializable(val: any): boolean;
-/**
- * Analyzes a module and returns processing decisions that both eager and lazy modes can use.
- * This centralizes the module loading logic from _loadSingleModule while allowing each mode
- * to handle the results according to their strategy (immediate materialization vs proxy creation).
- *
- * @function analyzeModule
- * @internal
- * @package
- * @param {string} modulePath - Absolute path to the module file
- * @param {object} options - Analysis options
- * @param {boolean} [options.debug=false] - Enable debug logging
- * @param {object} [options.instance] - Slothlet instance for accessing config and methods
- * @returns {Promise<{
- *   rawModule: object,
- *   processedModule: object,
- *   isFunction: boolean,
- *   hasDefault: boolean,
- *   isCjs: boolean,
- *   exports: Array<[string, any]>,
- *   defaultExportType: 'function'|'object'|null,
- *   shouldWrapAsCallable: boolean,
- *   namedExports: object,
- *   metadata: object
- * }>} Module analysis results
- *
- * @example
- * // Analyze a module file
- * const analysis = await analyzeModule("./api/math.mjs", { instance });
- * // Eager mode: use analysis.processedModule directly
- * // Lazy mode: create proxy based on analysis.isFunction, analysis.exports, etc.
- */
-export function analyzeModule(modulePath: string, options?: {
-    debug?: boolean;
-    instance?: object;
-}): Promise<{
-    rawModule: object;
-    processedModule: object;
-    isFunction: boolean;
-    hasDefault: boolean;
-    isCjs: boolean;
-    exports: Array<[string, any]>;
-    defaultExportType: "function" | "object" | null;
-    shouldWrapAsCallable: boolean;
-    namedExports: object;
-    metadata: object;
-}>;
-/**
- * Processes module analysis results into a final module object using slothlet's established patterns.
- * This centralizes the processing logic while allowing both modes to apply the results differently.
- *
- * @function processModuleFromAnalysis
- * @internal
- * @package
- * @param {object} analysis - Results from analyzeModule
- * @param {object} options - Processing options
- * @param {object} [options.instance] - Slothlet instance for accessing _toapiPathKey method
- * @param {boolean} [options.debug=false] - Enable debug logging
- * @returns {object} Processed module ready for API integration
- *
- * @example
- * // Process analyzed module
- * const analysis = await analyzeModule(modulePath, { instance });
- * const processed = processModuleFromAnalysis(analysis, { instance });
- * // Both modes can use 'processed' but integrate it differently
- */
-export function processModuleFromAnalysis(analysis: object, options?: {
-    instance?: object;
-    debug?: boolean;
-}): object;
-/**
- * Analyzes a directory and returns structural decisions that both eager and lazy modes can use.
- * This provides the decision-making logic for directory handling without implementing the actual
- * loading strategy (allowing lazy mode to create proxies while eager mode materializes).
- *
- * @function analyzeDirectoryStructure
- * @internal
- * @package
- * @param {string} categoryPath - Absolute path to the directory
- * @param {object} options - Analysis options
- * @param {object} options.instance - Slothlet instance for accessing config and methods
- * @param {number} [options.currentDepth=0] - Current traversal depth
- * @param {number} [options.maxDepth=Infinity] - Maximum traversal depth
- * @param {boolean} [options.debug=false] - Enable debug logging
- * @returns {Promise<{
- *   isSingleFile: boolean,
- *   shouldAutoFlatten: boolean,
- *   categoryName: string,
- *   moduleFiles: Array<import('fs').Dirent>,
- *   subDirs: Array<import('fs').Dirent>,
- *   multiDefaultAnalysis: object,
- *   processingStrategy: 'single-file'|'multi-file'|'empty',
- *   flatteningHints: object
- * }>} Directory structure analysis
- *
- * @example
- * // Analyze directory structure
- * const analysis = await analyzeDirectoryStructure(categoryPath, { instance });
- * if (analysis.isSingleFile) {
- *   // Both modes: handle as single file (but differently)
- * } else {
- *   // Both modes: handle as multi-file (but differently)
- * }
- */
-export function analyzeDirectoryStructure(categoryPath: string, options?: {
-    instance: object;
-    currentDepth?: number;
-    maxDepth?: number;
-    debug?: boolean;
-}): Promise<{
-    isSingleFile: boolean;
-    shouldAutoFlatten: boolean;
-    categoryName: string;
-    moduleFiles: Array<import("fs").Dirent>;
-    subDirs: Array<import("fs").Dirent>;
-    multiDefaultAnalysis: object;
-    processingStrategy: "single-file" | "multi-file" | "empty";
-    flatteningHints: object;
-}>;
-/**
- * Returns category building decisions and processed modules that both eager and lazy modes can use.
- * This provides all the structural information needed to build a category but lets each mode
- * implement the actual building strategy (materialization vs proxy creation).
- *
- * @function getCategoryBuildingDecisions
- * @internal
- * @package
- * @param {string} categoryPath - Absolute path to the directory
- * @param {object} options - Building options
- * @param {object} options.instance - Slothlet instance for accessing config and methods
- * @param {number} [options.currentDepth=0] - Current traversal depth
- * @param {number} [options.maxDepth=Infinity] - Maximum traversal depth
- * @param {boolean} [options.debug=false] - Enable debug logging
- * @returns {Promise<{
- *   processingStrategy: 'single-file'|'multi-file'|'empty',
- *   categoryName: string,
- *   shouldFlattenSingle: boolean,
- *   processedModules: Array<{file: import('fs').Dirent, moduleName: string, processedModule: any, flattening: object}>,
- *   subDirectories: Array<{dirEntry: import('fs').Dirent, apiPathKey: string}>,
- *   multiDefaultAnalysis: object,
- *   flatteningDecisions: object,
- *   upwardFlatteningCandidate: {shouldFlatten: boolean, apiPathKey: string}
- * }>} Complete category building information
- *
- * @example
- * // Get category building decisions
- * const decisions = await getCategoryBuildingDecisions(categoryPath, { instance });
- * if (decisions.processingStrategy === "single-file") {
- *   // Both modes: handle single file differently
- *   // Eager: return decisions.processedModules[0].processedModule
- *   // Lazy: create proxy based on decisions.processedModules[0].flattening
- * }
- */
-export function getCategoryBuildingDecisions(categoryPath: string, options?: {
-    instance: object;
-    currentDepth?: number;
-    maxDepth?: number;
-    debug?: boolean;
-}): Promise<{
-    processingStrategy: "single-file" | "multi-file" | "empty";
-    categoryName: string;
-    shouldFlattenSingle: boolean;
-    processedModules: Array<{
-        file: import("fs").Dirent;
-        moduleName: string;
-        processedModule: any;
-        flattening: object;
-    }>;
-    subDirectories: Array<{
-        dirEntry: import("fs").Dirent;
-        apiPathKey: string;
-    }>;
-    multiDefaultAnalysis: object;
-    flatteningDecisions: object;
-    upwardFlatteningCandidate: {
-        shouldFlatten: boolean;
-        apiPathKey: string;
-    };
-}>;
-//# sourceMappingURL=analysis.d.mts.map

package/types/dist/lib/helpers/api_builder/analysis.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analysis.d.mts","sourceRoot":"","sources":["../../../../../dist/lib/helpers/api_builder/analysis.mjs"],"names":[],"mappings":"AA0CA;;;;;;;;GAQG;AACH,0CAHW,GAAC,GACC,OAAO,CAcnB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,0CAvBW,MAAM,YAEd;IAA0B,KAAK,GAAvB,OAAO;IACU,QAAQ,GAAzB,MAAM;CACd,GAAU,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAC9B,iBAAiB,EAAE,UAAU,GAAC,QAAQ,GAAC,IAAI,CAAC;IAC5C,oBAAoB,EAAE,OAAO,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAC,CA4GJ;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,oDAZW,MAAM,YAEd;IAAyB,QAAQ,GAAzB,MAAM;IACY,KAAK,GAAvB,OAAO;CACf,GAAU,MAAM,CA4NlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wDA1BW,MAAM,YAEd;IAAwB,QAAQ,EAAxB,MAAM;IACW,YAAY,GAA7B,MAAM;IACW,QAAQ,GAAzB,MAAM;IACY,KAAK,GAAvB,OAAO;CACf,GAAU,OAAO,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;IACtB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,KAAK,CAAC,OAAO,IAAI,EAAE,MAAM,CAAC,CAAC;IACxC,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,EAAE,MAAM,CAAC,CAAC;IACpC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,kBAAkB,EAAE,aAAa,GAAC,YAAY,GAAC,OAAO,CAAC;IACvD,eAAe,EAAE,MAAM,CAAA;CACxB,CAAC,CAkEJ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,2DA1BW,MAAM,YAEd;IAAwB,QAAQ,EAAxB,MAAM;IACW,YAAY,GAA7B,MAAM;IACW,QAAQ,GAAzB,MAAM;IACY,KAAK,GAAvB,OAAO;CACf,GAAU,OAAO,CAAC;IAChB,kBAAkB,EAAE,aAAa,GAAC,YAAY,GAAC,OAAO,CAAC;IACvD,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,gBAAgB,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,OAAO,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,GAAG,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IACnH,cAAc,EAAE,KAAK,CAAC;QAAC,QAAQ,EAAE,OAAO,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAC3E,oBAAoB,EAAE,MAAM,CAAC;IAC7B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,yBAAyB,EAAE;QAAC,aAAa,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAA;CACxE,CAAC,CAmHJ"}

package/types/dist/lib/helpers/api_builder/construction.d.mts

@@ -1,107 +0,0 @@
-/**
- * Converts a filename or folder name to camelCase for API property.
- * Extracted from slothlet._toapiPathKey for use in API building functions.
- *
- * @function toapiPathKey
- * @internal
- * @package
- * @param {string} name - The name to convert
- * @param {object} [sanitizeConfig={}] - Sanitization configuration
- * @returns {string} The camelCase version of the name
- *
- * @example
- * toapiPathKey('root-math') // 'rootMath'
- * toapiPathKey('auto-ip') // 'autoIP' (with proper config)
- */
-export function toapiPathKey(name: string, sanitizeConfig?: object): string;
-/**
- * Filters out files that should not be loaded by slothlet.
- * Extracted from slothlet._shouldIncludeFile for use in API building functions.
- *
- * @function shouldIncludeFile
- * @internal
- * @package
- * @param {object} entry - The directory entry to check
- * @returns {boolean} True if the file should be included, false if it should be excluded
- *
- * @example
- * const entries = await fs.readdir(dir, { withFileTypes: true });
- * const moduleFiles = entries.filter(e => shouldIncludeFile(e));
- */
-export function shouldIncludeFile(entry: object): boolean;
-/**
- * Comprehensive category/directory building function that replaces _buildCategory.
- * Handles complete directory structure processing with all flattening rules.
- *
- * @function buildCategoryStructure
- * @internal
- * @package
- * @async
- * @param {string} categoryPath - Absolute path to the category directory
- * @param {object} options - Building options
- * @param {number} [options.currentDepth=0] - Current recursion depth
- * @param {number} [options.maxDepth=Infinity] - Maximum recursion depth
- * @param {string} [options.mode="eager"] - Loading mode ("eager" or "lazy")
- * @param {function} [options.subdirHandler] - Custom subdirectory handler for lazy mode
- * @param {object} options.instance - Slothlet instance for access to helper methods
- * @returns {Promise<object>} Complete category API structure
- *
- * @description
- * Complete directory structure building pipeline that handles:
- * - Single-file vs multi-file directory processing
- * - Auto-flattening decisions for single files matching directory names
- * - Multi-default export detection and processing
- * - Self-referential export handling
- * - Recursive subdirectory traversal with depth control
- * - Function name preference over sanitized names
- * - All established slothlet flattening rules and conventions
- *
- * @example
- * // Internal usage - build complete category structure
- * const categoryApi = await buildCategoryStructure("/path/to/category", {
- *   currentDepth: 0, maxDepth: 3, mode: "eager", instance: slothletInstance
- * });
- */
-export function buildCategoryStructure(categoryPath: string, options?: {
-    currentDepth?: number;
-    maxDepth?: number;
-    mode?: string;
-    subdirHandler?: Function;
-    instance: object;
-}): Promise<object>;
-/**
- * Comprehensive root API building function that replaces eager/lazy create methods.
- * Handles complete root-level API construction with mode-specific optimizations.
- *
- * @function buildRootAPI
- * @internal
- * @package
- * @async
- * @param {string} dir - Root directory path to build API from
- * @param {object} options - Building options
- * @param {boolean} [options.lazy=false] - Whether to use lazy loading mode
- * @param {number} [options.maxDepth=Infinity] - Maximum recursion depth
- * @param {object} options.instance - Slothlet instance for access to helper methods
- * @returns {Promise<object|function>} Complete root API (object or function with properties)
- *
- * @description
- * Complete root API building pipeline that handles:
- * - Root-level module processing with multi-default detection
- * - Root contributor pattern (default function becomes callable API)
- * - Named export merging and flattening decisions
- * - Recursive directory structure building via buildCategoryStructure
- * - Mode-specific optimizations (eager vs lazy)
- * - All established slothlet API construction patterns
- *
- * @example
- * // Internal usage - build complete root API
- * const rootApi = await buildRootAPI("/path/to/api", {
- *   lazy: false, maxDepth: 3, instance: slothletInstance
- * });
- */
-export function buildRootAPI(dir: string, options?: {
-    lazy?: boolean;
-    maxDepth?: number;
-    instance: object;
-}): Promise<object | Function>;
-//# sourceMappingURL=construction.d.mts.map

package/types/dist/lib/helpers/api_builder/construction.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"construction.d.mts","sourceRoot":"","sources":["../../../../../dist/lib/helpers/api_builder/construction.mjs"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;GAcG;AACH,mCARW,MAAM,mBACN,MAAM,GACJ,MAAM,CAQlB;AAED;;;;;;;;;;;;;GAaG;AACH,yCAPW,MAAM,GACJ,OAAO,CAgBnB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qDAzBW,MAAM,YAEd;IAAyB,YAAY,GAA7B,MAAM;IACW,QAAQ,GAAzB,MAAM;IACW,IAAI,GAArB,MAAM;IACa,aAAa;IAChB,QAAQ,EAAxB,MAAM;CACd,GAAU,OAAO,CAAC,MAAM,CAAC,CA+U3B;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,kCAtBW,MAAM,YAEd;IAA0B,IAAI,GAAtB,OAAO;IACU,QAAQ,GAAzB,MAAM;IACU,QAAQ,EAAxB,MAAM;CACd,GAAU,OAAO,CAAC,MAAM,WAAS,CAAC,CAoIpC"}