@cldmv/slothlet 2.11.0 → 3.0.1

package/types/dist/lib/modes/eager.d.mts

@@ -0,0 +1,36 @@
+/**
+ * Eager mode component - builds APIs by loading all modules immediately.
+ * @class EagerMode
+ * @extends ComponentBase
+ * @package
+ */
+export class EagerMode extends ComponentBase {
+    static slothletProperty: string;
+    /**
+     * Build API in eager mode (load all modules immediately).
+     * @param {Object} options - Build options
+     * @param {string} options.dir - Directory path to load from
+     * @param {string} [options.apiPathPrefix=""] - Prefix for API paths
+     * @param {string} [options.collisionContext="initial"] - Collision context
+     * @param {string} [options.moduleID] - Module ID
+     * @param {number} [options.apiDepth=Infinity] - Maximum directory depth
+     * @param {string|null} [options.cacheBust=null] - Cache-busting value
+     * @param {Function|null} [options.fileFilter=null] - Optional filter (fileName) => boolean
+     * @returns {Promise<Object>} Built API object
+     * @public
+     *
+     * @example
+     * const api = await slothlet.modes.eager.buildAPI({ dir: "./api", moduleID: "base" });
+     */
+    public buildAPI({ dir, apiPathPrefix, collisionContext, moduleID, apiDepth, cacheBust, fileFilter }: {
+        dir: string;
+        apiPathPrefix?: string;
+        collisionContext?: string;
+        moduleID?: string;
+        apiDepth?: number;
+        cacheBust?: string | null;
+        fileFilter?: Function | null;
+    }): Promise<any>;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
+//# sourceMappingURL=eager.d.mts.map

package/types/dist/lib/modes/eager.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/modes/eager.mjs"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH;IACC,gCAAkC;IAWlC;;;;;;;;;;;;;;;OAeG;IACH,qGAbG;QAAwB,GAAG,EAAnB,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,gBAAgB,GAAjC,MAAM;QACW,QAAQ,GAAzB,MAAM;QACW,QAAQ,GAAzB,MAAM;QACgB,SAAS,GAA/B,MAAM,GAAC,IAAI;QACa,UAAU,GAAlC,WAAS,IAAI;KACrB,GAAU,OAAO,KAAQ,CAgD3B;CACD;8BA/E6B,0CAA0C"}

package/types/dist/lib/modes/lazy.d.mts

@@ -0,0 +1,49 @@
+/**
+ * Lazy mode component - builds APIs with deferred (on-demand) loading.
+ * @class LazyMode
+ * @extends ComponentBase
+ * @package
+ */
+export class LazyMode extends ComponentBase {
+    static slothletProperty: string;
+    /**
+     * Create a named async materialization function for lazy subdirectories.
+     * @param {string} apiPath - API path to derive the function name from.
+     * @param {Function} handler - Async handler that performs materialization.
+     * @returns {Function} Named async materialization function.
+     * @public
+     *
+     * @example
+     * const fn = lazyMode.createNamedMaterializeFunc('api.math', async () => ({ add: (a,b) => a+b }));
+     */
+    public createNamedMaterializeFunc(apiPath: string, handler: Function): Function;
+    /**
+     * Build API in lazy mode (proxy-based deferred loading).
+     * @param {Object} options - Build options
+     * @param {string} options.dir - Directory to build from
+     * @param {string} [options.apiPathPrefix=""] - Prefix for API paths
+     * @param {string} [options.collisionContext="initial"] - Collision context
+     * @param {string|null} [options.collisionMode=null] - Collision mode override from api.add()
+     * @param {string} [options.moduleID] - Module ID
+     * @param {number} [options.apiDepth=Infinity] - Maximum directory depth
+     * @param {string|null} [options.cacheBust=null] - Cache-busting value
+     * @param {Function|null} [options.fileFilter=null] - Optional filter (fileName) => boolean
+     * @returns {Promise<Object>} Built API object with lazy proxies
+     * @public
+     *
+     * @example
+     * const api = await slothlet.modes.lazy.buildAPI({ dir: "./api", moduleID: "base" });
+     */
+    public buildAPI({ dir, apiPathPrefix, collisionContext, collisionMode, moduleID, apiDepth, cacheBust, fileFilter }: {
+        dir: string;
+        apiPathPrefix?: string;
+        collisionContext?: string;
+        collisionMode?: string | null;
+        moduleID?: string;
+        apiDepth?: number;
+        cacheBust?: string | null;
+        fileFilter?: Function | null;
+    }): Promise<any>;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
+//# sourceMappingURL=lazy.d.mts.map

package/types/dist/lib/modes/lazy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.mts","sourceRoot":"","sources":["../../../../dist/lib/modes/lazy.mjs"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH;IACC,gCAAiC;IAWjC;;;;;;;;;OASG;IACH,2CARW,MAAM,+BAmBhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,oHAdG;QAAwB,GAAG,EAAnB,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,gBAAgB,GAAjC,MAAM;QACgB,aAAa,GAAnC,MAAM,GAAC,IAAI;QACM,QAAQ,GAAzB,MAAM;QACW,QAAQ,GAAzB,MAAM;QACgB,SAAS,GAA/B,MAAM,GAAC,IAAI;QACa,UAAU,GAAlC,WAAS,IAAI;KACrB,GAAU,OAAO,KAAQ,CAwD3B;CACD;8BA/G6B,0CAA0C"}

package/types/dist/lib/processors/flatten.d.mts

@@ -0,0 +1,114 @@
+/**
+ * Flattening decision processor
+ * @class Flatten
+ * @extends ComponentBase
+ * @package
+ */
+export class Flatten extends ComponentBase {
+    static slothletProperty: string;
+    /**
+     * Core flattening decision function.
+     * Implements conditions C01-C07 from getFlatteningDecision().
+     * @param {object} options - Decision options
+     * @param {object} options.mod - Module exports
+     * @param {string} options.moduleName - Sanitized module name
+     * @param {string} options.categoryName - Category/folder name
+     * @param {object} options.analysis - Export analysis
+     * @param {boolean} options.hasMultipleDefaults - Multiple defaults in folder
+     * @param {array} options.moduleKeys - Keys from module
+     * @param {function} options.t - Translation function
+     * @returns {Promise<object>} Flattening decision
+     * @public
+     */
+    public getFlatteningDecision(options: {
+        mod: object;
+        moduleName: string;
+        categoryName: string;
+        analysis: object;
+        hasMultipleDefaults: boolean;
+        moduleKeys: any[];
+        t: Function;
+    }): Promise<object>;
+    /**
+     * Build module content for API assignment.
+     *
+     * Canonical implementation of the C08-C09b content-building rules, including
+     * AddApi detection and collision handling. Previously this logic was inlined
+     * inside modes-processor.mjs; it now lives here so the processor stays focused
+     * on wrapping and assignment concerns only.
+     *
+     * Collision config, modesUtils helpers, and SlothletWarning are accessed
+     * directly through {@link this.slothlet} / {@link this.slothlet.config} — no caller
+     * plumbing required.
+     *
+     * @param {object}   options                              - Processing options.
+     * @param {object}   options.mod                         - Module exports.
+     * @param {object}   options.decision                    - Flattening decision from getFlatteningDecision.
+     * @param {string}   options.moduleName                  - Sanitized module name (used for C08 auto-flatten key lookup).
+     * @param {string}   options.propertyName                - Resolved preferred name (decision.preferredName || moduleName).
+     * @param {string[]} options.moduleKeys                  - Named export keys (excluding "default").
+     * @param {object}   options.analysis                    - { hasDefault, hasNamed, defaultExportType }.
+     * @param {object}   [options.file=null]                 - File descriptor for AddApi detection via file.name / file.fullName.
+     * @param {string}   [options.collisionContext="initial"] - Collision context ("initial" | "api").
+     * @param {string}   [options.apiPathPrefix=""]          - API path prefix for collision error messages.
+     * @returns {{ moduleContent: object|Function }} Built module content ready for wrapping/assignment.
+     * @public
+     */
+    public processModuleForAPI(options: {
+        mod: object;
+        decision: object;
+        moduleName: string;
+        propertyName: string;
+        moduleKeys: string[];
+        analysis: object;
+        file?: object;
+        collisionContext?: string;
+        apiPathPrefix?: string;
+    }): {
+        moduleContent: object | Function;
+    };
+    /**
+     * Build category-level flattening decisions.
+     * Implements conditions C10-C33 from buildCategoryDecisions().
+     * @param {object} options - Category options
+     * @param {string} options.categoryName - Category name
+     * @param {object} options.mod - Module exports
+     * @param {string} options.moduleName - Module name
+     * @param {string} options.fileBaseName - File base name
+     * @param {object} options.analysis - Export analysis
+     * @param {array} options.moduleKeys - Module keys
+     * @param {number} options.currentDepth - Current depth
+     * @param {array} options.moduleFiles - Files in category
+     * @param {function} options.t - Translation function
+     * @returns {Promise<object>} Category decision
+     * @public
+     */
+    public buildCategoryDecisions(options: {
+        categoryName: string;
+        mod: object;
+        moduleName: string;
+        fileBaseName: string;
+        analysis: object;
+        moduleKeys: any[];
+        currentDepth: number;
+        moduleFiles: any[];
+        t: Function;
+    }): Promise<object>;
+    /**
+     * Decide whether a named export should be attached to a callable default export.
+     *
+     * Returns false when the named export is the same reference as the default (re-export
+     * pattern), or when the export key matches the function name (self-referential export).
+     *
+     * @param {string} key - Named export key.
+     * @param {unknown} value - Named export value.
+     * @param {Function} defaultFunc - Wrapped callable default export.
+     * @param {Function} originalDefault - Original default export.
+     * @returns {boolean} True if the export should be attached.
+     * @public
+     */
+    public shouldAttachNamedExport(key: string, value: unknown, defaultFunc: Function, originalDefault: Function): boolean;
+    #private;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
+//# sourceMappingURL=flatten.d.mts.map

package/types/dist/lib/processors/flatten.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/flatten.mjs"],"names":[],"mappings":"AA8BA;;;;;GAKG;AACH;IACC,gCAAoC;IAgEpC;;;;;;;;;;;;;OAaG;IACH,sCAVG;QAAwB,GAAG,EAAnB,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,QAAQ,EAAxB,MAAM;QACW,mBAAmB,EAApC,OAAO;QACQ,UAAU;QACP,CAAC;KAC3B,GAAU,OAAO,CAAC,MAAM,CAAC,CAiG3B;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,oCAZG;QAA0B,GAAG,EAArB,MAAM;QACY,QAAQ,EAA1B,MAAM;QACY,UAAU,EAA5B,MAAM;QACY,YAAY,EAA9B,MAAM;QACY,UAAU,EAA5B,MAAM,EAAE;QACU,QAAQ,EAA1B,MAAM;QACa,IAAI,GAAvB,MAAM;QACa,gBAAgB,GAAnC,MAAM;QACa,aAAa,GAAhC,MAAM;KACd,GAAU;QAAE,aAAa,EAAE,MAAM,WAAS,CAAA;KAAE,CAqI9C;IAED;;;;;;;;;;;;;;;OAeG;IACH,uCAZG;QAAwB,YAAY,EAA5B,MAAM;QACU,GAAG,EAAnB,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,QAAQ,EAAxB,MAAM;QACS,UAAU;QACT,YAAY,EAA5B,MAAM;QACS,WAAW;QACR,CAAC;KAC3B,GAAU,OAAO,CAAC,MAAM,CAAC,CAiJ3B;IAED;;;;;;;;;;;;OAYG;IACH,oCAPW,MAAM,SACN,OAAO,qDAGL,OAAO,CAiBnB;;CACD;8BAhhB6B,0CAA0C"}

package/types/dist/lib/processors/loader.d.mts

@@ -0,0 +1,47 @@
+/**
+ * Loader component for module loading, directory scanning, and API merging
+ * @class Loader
+ * @extends ComponentBase
+ * @package
+ */
+export class Loader extends ComponentBase {
+    static slothletProperty: string;
+    constructor(slothlet: any);
+    /**
+     * Load a single module
+     * @param {string} filePath - Path to module file
+     * @param {string} [instanceID] - Slothlet instance ID for cache busting
+     * @param {string} [moduleID] - Module ID for additional cache busting (used in api.slothlet.api.add)
+     * @param {number|null} [cacheBust=null] - Timestamp for reload cache busting (forces fresh import)
+     * @returns {Promise<Object>} Loaded module
+     * @public
+     */
+    public loadModule(filePath: string, instanceID?: string, moduleID?: string, cacheBust?: number | null): Promise<any>;
+    /**
+     * Scan directory for module files
+     * @param {string} dir - Directory to scan
+     * @param {Object} [options={}] - Scan options
+     * @param {boolean} [options.isRootScan=true] - Whether this is the root directory scan (shows empty dir warning)
+     * @param {number} [options.currentDepth=0] - Current traversal depth
+     * @param {number} [options.maxDepth=Infinity] - Maximum traversal depth
+     * @param {Function|null} [options.fileFilter=null] - Optional filter function (fileName) => boolean to load specific files only
+     * @returns {Promise<Object>} Directory structure
+     * @public
+     */
+    public scanDirectory(dir: string, options?: {
+        isRootScan?: boolean;
+        currentDepth?: number;
+        maxDepth?: number;
+        fileFilter?: Function | null;
+    }): Promise<any>;
+    /**
+     * Extract exports from module
+     * @param {Object} module - Loaded module
+     * @returns {Object} Extracted exports
+     * @public
+     */
+    public extractExports(module: any): any;
+    #private;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
+//# sourceMappingURL=loader.d.mts.map

package/types/dist/lib/processors/loader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/loader.mjs"],"names":[],"mappings":"AA8BA;;;;;GAKG;AACH;IACC,gCAAmC;IAEnC,2BAEC;IAED;;;;;;;;OAQG;IACH,4BAPW,MAAM,eACN,MAAM,aACN,MAAM,cACN,MAAM,GAAC,IAAI,GACT,OAAO,KAAQ,CAwK3B;IAuCD;;;;;;;;;;OAUG;IACH,0BATW,MAAM,YAEd;QAA0B,UAAU,GAA5B,OAAO;QACU,YAAY,GAA7B,MAAM;QACW,QAAQ,GAAzB,MAAM;QACkB,UAAU,GAAlC,WAAS,IAAI;KACrB,GAAU,OAAO,KAAQ,CA0F3B;IAED;;;;;OAKG;IACH,wCAoCC;;CACD;8BAnX6B,0CAA0C"}

package/types/dist/lib/processors/type-generator.d.mts

@@ -0,0 +1,19 @@
+/**
+ * Generate TypeScript declaration file for a Slothlet API
+ * @param {object} api - The loaded Slothlet API
+ * @param {object} options - Generation options
+ * @param {string} options.output - Output file path for .d.ts
+ * @param {string} options.interfaceName - Name of the interface to generate
+ * @param {boolean} [options.includeDocumentation=true] - Include JSDoc comments
+ * @returns {Promise<{output: string, filePath: string}>} Generated declaration and output path
+ * @public
+ */
+export function generateTypes(api: object, options: {
+    output: string;
+    interfaceName: string;
+    includeDocumentation?: boolean;
+}): Promise<{
+    output: string;
+    filePath: string;
+}>;
+//# sourceMappingURL=type-generator.d.mts.map

package/types/dist/lib/processors/type-generator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-generator.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/type-generator.mjs"],"names":[],"mappings":"AA8CA;;;;;;;;;GASG;AACH,mCARW,MAAM,WAEd;IAAwB,MAAM,EAAtB,MAAM;IACU,aAAa,EAA7B,MAAM;IACY,oBAAoB,GAAtC,OAAO;CACf,GAAU,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAAC,CAqDvD"}

package/types/dist/lib/processors/typescript.d.mts

@@ -0,0 +1,55 @@
+/**
+ * Transform TypeScript code to JavaScript using esbuild
+ * @param {string} filePath - Path to the TypeScript file
+ * @param {object} [options={}] - esbuild transform options
+ * @param {string} [options.target] - ECMAScript target version (default: "es2020")
+ * @param {string} [options.format] - Module format (default: "esm")
+ * @param {boolean} [options.sourcemap] - Generate source maps (default: false)
+ * @returns {Promise<string>} Transformed JavaScript code
+ * @throws {SlothletError} If transformation fails
+ * @public
+ */
+export function transformTypeScript(filePath: string, options?: {
+    target?: string;
+    format?: string;
+    sourcemap?: boolean;
+}): Promise<string>;
+/**
+ * Create a data URL for dynamic import with cache busting
+ * @param {string} code - JavaScript code to encode
+ * @returns {string} Data URL suitable for dynamic import
+ * @public
+ */
+export function createDataUrl(code: string): string;
+/**
+ * Transform TypeScript code to JavaScript using tsc with type checking
+ * @param {string} filePath - Path to the TypeScript file
+ * @param {object} [options={}] - TypeScript compiler options
+ * @param {string} [options.target] - ECMAScript target version (default: "ES2020")
+ * @param {string} [options.module] - Module format (default: "ESNext")
+ * @param {boolean} [options.strict] - Enable strict type checking (default: true)
+ * @param {boolean} [options.skipTypeCheck] - Skip type checking and only transform (default: false)
+ * @param {string} [options.typeDefinitionPath] - Path to .d.ts file for type checking
+ * @returns {Promise<{code: string, diagnostics: object[]}>} Transformed code and type diagnostics
+ * @throws {SlothletError} If transformation fails
+ * @public
+ */
+export function transformTypeScriptStrict(filePath: string, options?: {
+    target?: string;
+    module?: string;
+    strict?: boolean;
+    skipTypeCheck?: boolean;
+    typeDefinitionPath?: string;
+}): Promise<{
+    code: string;
+    diagnostics: object[];
+}>;
+/**
+ * Format TypeScript diagnostics into readable error messages
+ * @param {object[]} diagnostics - TypeScript diagnostic objects
+ * @param {object} ts - TypeScript module instance
+ * @returns {string[]} Array of formatted error messages
+ * @private
+ */
+export function formatDiagnostics(diagnostics: object[], ts: object): string[];
+//# sourceMappingURL=typescript.d.mts.map

package/types/dist/lib/processors/typescript.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/typescript.mjs"],"names":[],"mappings":"AAqEA;;;;;;;;;;GAUG;AACH,8CATW,MAAM,YAEd;IAAyB,MAAM,GAAvB,MAAM;IACW,MAAM,GAAvB,MAAM;IACY,SAAS,GAA3B,OAAO;CACf,GAAU,OAAO,CAAC,MAAM,CAAC,CAiB3B;AAED;;;;;GAKG;AACH,oCAJW,MAAM,GACJ,MAAM,CAQlB;AAED;;;;;;;;;;;;GAYG;AACH,oDAXW,MAAM,YAEd;IAAyB,MAAM,GAAvB,MAAM;IACW,MAAM,GAAvB,MAAM;IACY,MAAM,GAAxB,OAAO;IACW,aAAa,GAA/B,OAAO;IACU,kBAAkB,GAAnC,MAAM;CACd,GAAU,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAC,CAAC,CA6F1D;AAED;;;;;;GAMG;AACH,+CALW,MAAM,EAAE,MACR,MAAM,GACJ,MAAM,EAAE,CAapB"}

package/types/dist/lib/runtime/runtime-asynclocalstorage.d.mts

@@ -1,67 +1,72 @@
 /**
- * Shared AsyncLocalStorage instance for all slothlet instances.
- * Provides unified context management across all EventEmitter wrappers.
- * @type {AsyncLocalStorageType}
- * @public
- */
-export const sharedALS: AsyncLocalStorageType;
-/**
- * Per-request AsyncLocalStorage instance for request-scoped context.
- * Stores temporary context data that merges with instance context.
- * @type {AsyncLocalStorageType}
+ * Live binding to the current API (self-reference)
+ * @type {Proxy}
  * @public
+ *
+ * @description
+ * A proxy that provides access to the full API object within the current context.
+ * Automatically resolves to the correct instance's API in AsyncLocalStorage context.
+ *
+ * @example
+ * import { self } from "@cldmv/slothlet/runtime/async";
+ *
+ * export function callOtherFunction() {
+ *   // Call another function in the same API
+ *   return self.otherFunction();
+ * }
  */
-export const requestALS: AsyncLocalStorageType;
-export function runWithCtx(ctx: object, fn: Function, thisArg: any, args: any[]): any;
-export function getCtx(): object | null;
-export function makeWrapper(ctx: object): Function;
+export const self: ProxyConstructor;
 /**
- * @constant self
- * @memberof module:@cldmv/slothlet/runtime
- * @export module:@cldmv/slothlet/runtime
+ * User-provided context object
+ * @type {Proxy}
  * @public
- * @type {function|object}
  *
  * @description
- * Live binding to the current instance's 'self' reference from AsyncLocalStorage context.
+ * A proxy that provides access to user-provided context data (e.g., request data, user info).
+ * Can be set via `slothlet.run()` or `slothlet.scope()`.
  *
  * @example
- * // Access current instance self
- * console.log(self); // Current slothlet instance
+ * import { context } from "@cldmv/slothlet/runtime/async";
+ *
+ * export function getUserInfo() {
+ *   // Access user-provided context
+ *   return {
+ *     userId: context.userId,
+ *     userName: context.userName
+ *   };
+ * }
  */
-export const self: Function | object;
+export const context: ProxyConstructor;
 /**
- * @constant context
- * @memberof module:@cldmv/slothlet/runtime
- * @export module:@cldmv/slothlet/runtime
+ * Reference to initialization reference object
+ * @type {Proxy}
  * @public
- * @type {object}
  *
  * @description
- * Live binding to the current instance's 'context' data from AsyncLocalStorage context.
+ * The reference object is merged directly into the API at initialization using the add API system.
+ * It is NOT available as a runtime export. Access it directly from the API or via api.slothlet.diag.reference().
  *
  * @example
- * // Access current context data
- * console.log(context); // Current context object
+ * // Reference merged into API - access directly:
+ * export function useReferenceData() {
+ *   return self.myData; // if reference had myData property
+ * }
  */
-export const context: object;
 /**
- * @constant reference
- * @memberof module:@cldmv/slothlet/runtime
- * @export module:@cldmv/slothlet/runtime
+ * Current instance ID
+ * @type {Proxy}
  * @public
- * @type {object}
  *
  * @description
- * Live binding to the current instance's 'reference' object from AsyncLocalStorage context.
+ * A proxy that provides access to the current slothlet instance ID.
+ * Useful for debugging and tracking which instance is handling a request.
  *
  * @example
- * // Access current reference object
- * console.log(reference); // Current reference data
+ * import { instanceID } from "@cldmv/slothlet/runtime/async";
+ *
+ * export function getInstanceInfo() {
+ *   return { instanceID };
+ * }
  */
-export const reference: object;
-export { metadataAPI };
-export type AsyncLocalStorageType = AsyncLocalStorage<any>;
-import { metadataAPI } from "@cldmv/slothlet/helpers/metadata-api";
-import { AsyncLocalStorage } from "node:async_hooks";
+export const instanceID: ProxyConstructor;
 //# sourceMappingURL=runtime-asynclocalstorage.d.mts.map

package/types/dist/lib/runtime/runtime-asynclocalstorage.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-asynclocalstorage.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-asynclocalstorage.mjs"],"names":[],"mappings":"AAwCA;;;;;GAKG;AACH,wBAHU,qBAAqB,CAGkB;AAEjD;;;;;GAKG;AACH,yBAHU,qBAAqB,CAGmB;AAsB3C,gCAdI,MAAM,yBAEN,GAAG,gBAED,GAAG,CAwGf;AAiBM,0BAZM,MAAM,GAAC,IAAI,CAY0B;AAkN3C,iCAjBI,MAAM,YAiJhB;AA2TD;;;;;;;;;;;;;GAaG;AACH,mBATU,WAAS,MAAM,CAS6B;AAEtD;;;;;;;;;;;;;GAaG;AACH,sBATU,MAAM,CAS4C;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBATU,MAAM,CASgD;;;4BAl1BpC,sCAAsC;kCAHhC,kBAAkB"}
+{"version":3,"file":"runtime-asynclocalstorage.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-asynclocalstorage.mjs"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;;;GAgBG;AACH,oCAgCE;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uCAkCE;AAEF;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,0CAqBE"}

package/types/dist/lib/runtime/runtime-livebindings.d.mts

@@ -1,69 +1,38 @@
 /**
- * Context-aware function execution with temporary active instance override.
- * Sets the active instance based on the context before calling the function,
- * ensuring CJS runtime imports detect the correct instance.
- * @param {object} ctx - Context object containing instanceId
- * @param {Function} fn - Function to execute
- * @param {any} thisArg - The this argument
- * @param {Array} args - The function arguments
- * @returns {any} The function result
- */
-export function runWithCtx(ctx: object, fn: Function, thisArg: any, args: any[]): any;
-/**
- * Create a wrapper function that sets __slothletPath on API functions.
- * Required for hook pattern matching to work correctly.
- * @internal
- * @param {object} ctx - The context to bind
- * @returns {function} A wrapper function that proxies the API
- */
-export function makeWrapper(ctx: object): Function;
-/**
- * Legacy context management functions - kept for backwards compatibility
- * but may not be needed with instance detection approach.
- */
-export function getContext(): any;
-export function setContext(newContext: any): void;
-/**
- * Per-request AsyncLocalStorage instance for request-scoped context.
- * Works alongside live bindings to provide per-request context isolation.
- * @type {AsyncLocalStorage}
- * @public
- */
-export const requestALS: AsyncLocalStorage<any>;
-/**
- * Live-binding reference to the current API instance.
- * Automatically resolves to the appropriate instance based on calling context.
- * @type {object}
+ * Live binding to the current API (self-reference)
+ * @type {Proxy}
  * @public
- */
-export const self: object;
-/**
- * Live-binding reference for contextual data.
- * Automatically resolves to the appropriate instance context.
- * @type {object}
- * @public
- */
-export const context: object;
-/**
- * Live-binding reference for reference data.
- * Automatically resolves to the appropriate instance reference.
- * @type {object}
+ *
+ * @description
+ * A proxy that provides direct access to the current instance's API.
+ * In live mode, this directly references the active instance without AsyncLocalStorage.
+ *
+ * @example
+ * import { self } from "@cldmv/slothlet/runtime/live";
+ *
+ * export function callOtherFunction() {
+ *   return self.otherFunction();
+ * }
+ */
+export const self: ProxyConstructor;
+/**
+ * User-provided context object
+ * @type {Proxy}
  * @public
- */
-export const reference: object;
-/**
- * Live-binding reference to the current instance ID.
- * Automatically resolves to the current instance identifier.
- * @type {string}
- * @public
- */
-export const instanceId: string;
-export namespace contextManager {
-    export { getContext as get };
-    export { setContext as set };
-    export { runWithCtx };
-}
-export { metadataAPI };
-import { AsyncLocalStorage } from "node:async_hooks";
-import { metadataAPI } from "@cldmv/slothlet/helpers/metadata-api";
+ *
+ * @description
+ * A proxy that provides access to user-provided context data.
+ * In live mode, this directly accesses the current instance's context.
+ *
+ * @example
+ * import { context } from "@cldmv/slothlet/runtime/live";
+ *
+ * export function getUserInfo() {
+ *   return {
+ *     userId: context.userId,
+ *     userName: context.userName
+ *   };
+ * }
+ */
+export const context: ProxyConstructor;
 //# sourceMappingURL=runtime-livebindings.d.mts.map

package/types/dist/lib/runtime/runtime-livebindings.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-livebindings.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-livebindings.mjs"],"names":[],"mappings":"AAgTA;;;;;;;;;GASG;AACH,gCANW,MAAM,yBAEN,GAAG,gBAED,GAAG,CAoFf;AAED;;;;;;GAMG;AACH,iCAHW,MAAM,YAiEhB;AAID;;;GAGG;AAEH,kCAEC;AAED,kDASC;AA/bD;;;;;GAKG;AACH,gDAAkD;AA8ClD;;;;;GAKG;AACH,mBAHU,MAAM,CAmDd;AAEF;;;;;GAKG;AACH,sBAHU,MAAM,CA0Dd;AAEF;;;;;GAKG;AACH,wBAHU,MAAM,CA+Cd;AAEF;;;;;GAKG;AACH,yBAHU,MAAM,CAkCd;;;;;;;kCA7QgC,kBAAkB;4BAOxB,sCAAsC"}
+{"version":3,"file":"runtime-livebindings.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-livebindings.mjs"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;GAeG;AACH,oCAgCE;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,uCAkCE"}

package/types/dist/lib/runtime/runtime.d.mts

@@ -1,10 +1,40 @@
-export function runWithCtx(ctx: any, fn: any, thisArg: any, args: any): any;
-export function makeWrapper(ctx: any): Function;
-export function getCtx(): any;
-export function self(): void;
-export const context: {};
-export const reference: {};
-export const instanceId: any;
-export const sharedALS: any;
-export const metadataAPI: {};
+/**
+ * Live binding to the current API instance. Resolves to the running Slothlet proxy,
+ * giving API modules access to all other API methods without import cycles.
+ *
+ * @memberof module:@cldmv/slothlet/runtime
+ * @type {object}
+ * @example
+ * import { self } from "@cldmv/slothlet/runtime";
+ * // Inside an API function:
+ * const result = await self.math.add(1, 2);
+ */
+export const self: object;
+/**
+ * The current ambient context object. Seeded at instance startup via `config.context` and
+ * persists for the lifetime of the instance. `api.slothlet.context.run()` and `.scope()` can
+ * temporarily override it for the duration of a single call, after which the previous context
+ * is restored. Readable and writable.
+ *
+ * @memberof module:@cldmv/slothlet/runtime
+ * @type {object}
+ * @example
+ * import { context } from "@cldmv/slothlet/runtime";
+ * // Read the ambient context set via config.context or written by a previous call:
+ * const userId = context.userId;
+ * // context.run() overrides it only for the duration of that one call:
+ * await api.slothlet.context.run({ userId: 42 }, myFn);
+ */
+export const context: object;
+/**
+ * Current Slothlet instance identifier. Unique per `slothlet()` call; useful when
+ * multiple Slothlet instances coexist and you need to identify which one is active.
+ *
+ * @memberof module:@cldmv/slothlet/runtime
+ * @type {string}
+ * @example
+ * import { instanceID } from "@cldmv/slothlet/runtime";
+ * console.log(instanceID); // e.g. "slothlet-1"
+ */
+export const instanceID: string;
 //# sourceMappingURL=runtime.d.mts.map

package/types/dist/lib/runtime/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime.mjs"],"names":[],"mappings":"AAoMA,4EAGC;AAED,gDAGC;AAED,8BAGC;AArKA,6BAA+B;AAkDhC,yBAiDE;AAEF,2BAiDE;AAiBF,6BAOK;AAEL,4BAAuD;AAGvD,6BAQE"}
+{"version":3,"file":"runtime.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime.mjs"],"names":[],"mappings":"AAkEA;;;;;;;;;;GAUG;AACH,mBANU,MAAM,CAgCd;AAEF;;;;;;;;;;;;;;GAcG;AACH,sBARU,MAAM,CAiCd;AAEF;;;;;;;;;GASG;AACH,yBALU,MAAM,CAiBd"}