@cldmv/slothlet 2.3.0 → 2.3.2

package/README.md

@@ -33,9 +33,9 @@ The name might suggest we're taking it easy, but don't be fooled. **Slothlet del
 
 ---
 
-## ✨ What's New in v2.0
+## ✨ What's New in v2.x
 
-### 🎯 **Complete Architectural Rewrite**
+### 🎯 **Complete Architectural Rewrite (v2.0)**
 
 v2.0 represents a ground-up rewrite with enterprise-grade features:
 
@@ -67,6 +67,13 @@ v2.0 represents a ground-up rewrite with enterprise-grade features:
 - **Memory**: On-demand loading scales with actual usage
 - **Predictability**: Consistent performance characteristics per mode
 
+### 🔄 **Context Propagation (v2.3)** ⭐ NEW
+
+- **EventEmitter Context Propagation**: Automatic context preservation across EventEmitter callbacks using AsyncResource patterns
+- **Class Instance Context Propagation**: Automatic context preservation across class method calls with transparent wrapping
+- **AsyncResource Integration**: Production-ready context management following Node.js best practices
+- **Zero Configuration**: Works automatically with TCP servers, HTTP servers, and any EventEmitter-based patterns
+
 ---
 
 ## 🚀 Key Features
@@ -332,7 +339,7 @@ Creates and loads an API instance with the specified configuration.
 | `debug`     | `boolean` | `false`       | Enable verbose logging. Can also be set via `--slothletdebug` command line flag or `SLOTHLET_DEBUG=true` environment variable                                                                                                                                                                                                                                                      |
 | `mode`      | `string`  | `"singleton"` | Execution environment mode - `"singleton"`, `"vm"`, `"worker"`, or `"fork"`                                                                                                                                                                                                                                                                                                        |
 | `api_mode`  | `string`  | `"auto"`      | API structure behavior when root-level default functions exist:<br/>• `"auto"`: Automatically detects if root has default function export and creates callable API<br/>• `"function"`: Forces API to be callable (use when you have root-level default function exports)<br/>• `"object"`: Forces API to be object-only (use when you want object interface regardless of exports) |
-| `context`   | `object`  | `{}`          | Context data object injected into live-binding `context` reference. Available to all loaded modules via `import { context } from '@cldmv/slothlet/runtime'`                                                                                                                                                                                                                        |
+| `context`   | `object`  | `{}`          | Context data object injected into live-binding `context` reference. Available to all loaded modules via `import { context } from "@cldmv/slothlet/runtime"`                                                                                                                                                                                                                        |
 | `reference` | `object`  | `{}`          | Reference object merged into the API root level. Properties not conflicting with loaded modules are added directly to the API                                                                                                                                                                                                                                                      |
 | `sanitize`  | `object`  | `{}`          | **🔧 NEW**: Control how filenames become API property names. Supports exact matches, glob patterns (`*json*`), and boundary patterns (`**url**`). Configure `lowerFirst` and `rules` for `leave`, `leaveInsensitive`, `upper`, and `lower` transformations                                                                                                                         |
 
@@ -419,6 +426,142 @@ function cjsFunction(data) {
 module.exports = { cjsFunction };
 ```
 
+### EventEmitter Context Propagation
+
+Slothlet automatically preserves AsyncLocalStorage context across all EventEmitter callbacks using Node.js AsyncResource patterns. This ensures your API modules maintain full context access in event handlers without any configuration.
+
+```javascript
+// api/tcp-server.mjs - Your API module
+import { self, context } from "@cldmv/slothlet/runtime";
+import net from "node:net";
+
+export function createTcpServer() {
+	const server = net.createServer();
+
+	// Connection handler maintains full context automatically
+	server.on("connection", (socket) => {
+		console.log(`User: ${context.user}`); // ✅ Context preserved
+		console.log(`API keys: ${Object.keys(self).length}`); // ✅ Full API access
+
+		// Socket data handler also maintains context automatically
+		socket.on("data", (data) => {
+			console.log(`Session: ${context.session}`); // ✅ Context preserved
+			console.log(`Processing for: ${context.user}`); // ✅ Context preserved
+
+			// Full API access in nested event handlers
+			const processed = self.dataProcessor.handle(data.toString());
+			socket.write(processed);
+		});
+
+		socket.on("error", (err) => {
+			// Error handlers also maintain context
+			self.logger.error(`Error for user ${context.user}: ${err.message}`);
+		});
+	});
+
+	return server;
+}
+
+export function startServer(port = 3000) {
+	const server = createTcpServer();
+	server.listen(port);
+	return server;
+}
+```
+
+```javascript
+// Usage in your application
+import slothlet from "@cldmv/slothlet";
+
+const api = await slothlet({
+	dir: "./api",
+	context: { user: "alice", session: "tcp-session" }
+});
+
+// Start the server - all event handlers will have full context
+const server = api.startServer(8080);
+console.log("TCP server started with context preservation");
+```
+
+**Key Benefits:**
+
+- ✅ **Automatic**: No configuration needed - works transparently in all API modules
+- ✅ **Complete Context**: Full `context` object and `self` API access in all event handlers
+- ✅ **Nested Events**: Works with any depth of EventEmitter nesting (server → socket → custom emitters)
+- ✅ **Universal Support**: All EventEmitter methods (`on`, `once`, `addListener`) are automatically context-aware
+- ✅ **Production Ready**: Uses Node.js AsyncResource patterns for reliable context propagation
+- ✅ **Zero Overhead**: Only wraps listeners when context is active, minimal performance impact
+
+> [!TIP]  
+> **Automatic Context Propagation**: EventEmitter context propagation works automatically in both lazy and eager modes. TCP servers, HTTP servers, custom EventEmitters, and any other event-driven patterns in your API modules will maintain full slothlet context and API access without any code changes.
+
+### Class Instance Context Propagation
+
+Slothlet automatically preserves AsyncLocalStorage context across all class instance method calls. When your API functions return class instances, slothlet wraps them transparently to ensure all method calls maintain full context access.
+
+```javascript
+// api/data-processor.mjs - Your API module
+import { self, context } from "@cldmv/slothlet/runtime";
+
+class DataProcessor {
+	constructor(config) {
+		this.config = config;
+	}
+
+	process(data) {
+		// Context automatically available in all methods
+		console.log(`Processing for user: ${context.user}`); // ✅ Context preserved
+		console.log(`Request ID: ${context.requestId}`); // ✅ Context preserved
+
+		// Full API access in class methods
+		const validated = self.validator.check(data);
+		return this.transform(validated);
+	}
+
+	transform(data) {
+		// Context preserved in nested method calls
+		console.log(`Transforming for: ${context.user}`); // ✅ Context preserved
+
+		// Call other API modules from class methods
+		return self.utils.format(data);
+	}
+}
+
+export function createProcessor(config) {
+	// Return class instance - slothlet automatically wraps it
+	return new DataProcessor(config);
+}
+```
+
+```javascript
+// Usage in your application
+import slothlet from "@cldmv/slothlet";
+
+const api = await slothlet({
+	dir: "./api",
+	context: { user: "alice", requestId: "req-123" }
+});
+
+// Create processor instance - all methods will have full context
+const processor = api.createProcessor({ format: "json" });
+
+// All method calls maintain context automatically
+const result = processor.process({ data: "test" });
+console.log("Processing completed with context preservation");
+```
+
+**Key Benefits:**
+
+- ✅ **Automatic**: Class instances returned from API functions are automatically context-aware
+- ✅ **Transparent**: No code changes needed - works with existing class patterns
+- ✅ **Complete Context**: Full `context` object and `self` API access in all class methods
+- ✅ **Nested Methods**: Context preserved across method chains and internal calls
+- ✅ **Constructor Support**: Context preserved for both function calls and `new` constructor usage
+- ✅ **Performance Optimized**: Method wrapping is cached to avoid overhead on repeated calls
+
+> [!TIP]  
+> **Universal Class Support**: Any class instance returned from your API functions automatically maintains slothlet context. This includes database models, service classes, utility classes, and any other object-oriented patterns in your codebase.
+
 ### API Mode Configuration
 
 The `api_mode` option controls how slothlet handles root-level default function exports:

package/dist/lib/engine/slothlet_child.mjs

@@ -15,6 +15,7 @@
 */
 
 
+
 import { installGlobalsInCurrentRealm, extendSelfWithReference, installPortalForSelf } from "./slothlet_helpers.mjs";
 
 let initialized = false;

package/dist/lib/engine/slothlet_engine.mjs

@@ -15,6 +15,7 @@
 */
 
 
+
 import { Worker } from "node:worker_threads";
 import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";

package/dist/lib/engine/slothlet_esm.mjs

@@ -15,6 +15,7 @@
 */
 
 
+
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";

package/dist/lib/engine/slothlet_helpers.mjs

@@ -15,6 +15,7 @@
 */
 
 
+
 import vm from "node:vm";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -389,7 +390,7 @@ export async function bootSlothletVM(context, entryUrl, loadConfig, ctxRef) {
 				const ret = await globalThis.slothlet.load(__loadConfig, __ctxRef);
 				globalThis.self = global.self = ret;
 				const ref = __ctxRef?.reference;
-				if (ref && typeof ref === 'object') {
+				if (ref && typeof ref === "object") {
 					for (const k of Object.keys(ref)) if (!(k in globalThis.self)) {
 						try { globalThis.self[k] = global.self[k] = ref[k]; } catch {}
 					}

package/dist/lib/engine/slothlet_worker.mjs

@@ -15,6 +15,7 @@
 */
 
 
+
 import { parentPort, workerData } from "node:worker_threads";
 import {
 	installGlobalsInCurrentRealm,

package/dist/lib/helpers/als-eventemitter.mjs

@@ -0,0 +1,119 @@
+/*
+	Copyright 2025 CLDMV/Shinrai
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+*/
+
+
+
+
+
+import { AsyncResource } from "node:async_hooks";
+import { EventEmitter } from "node:events";
+import { sharedALS } from "../runtime/runtime.mjs";
+
+
+export function enableAlsForEventEmitters(als = sharedALS) {
+	
+	const kPatched = Symbol.for("slothlet.als.patched");
+
+	if (EventEmitter.prototype[kPatched]) return;
+	EventEmitter.prototype[kPatched] = true;
+
+	
+	const kMap = Symbol("slothlet.als.listenerMap");
+
+	
+	function runtime_ensureMap(emitter) {
+		if (!emitter[kMap]) emitter[kMap] = new WeakMap();
+		return emitter[kMap];
+	}
+
+	
+	function runtime_wrapListener(listener) {
+		
+		const store = als.getStore();
+		if (!store) return listener;
+
+		
+		const resource = new AsyncResource("slothlet-als-listener");
+
+		
+		const runtime_wrappedListener = function (...args) {
+			return resource.runInAsyncScope(
+				() => {
+					return listener.apply(this, args);
+				},
+				this,
+				...args
+			);
+		};
+
+		return runtime_wrappedListener;
+	}
+
+	const proto = EventEmitter.prototype;
+
+	
+	const origOn = proto.on;
+	const origOnce = proto.once;
+	const origAdd = proto.addListener;
+	const origPre = proto.prependListener;
+	const origPreO = proto.prependOnceListener;
+	const origOff = proto.off ?? proto.removeListener;
+	const origRem = proto.removeListener;
+
+	
+	function runtime_installWrapper(addFnName, orig) {
+		proto[addFnName] = function (event, listener) {
+			const map = runtime_ensureMap(this);
+			const wrapped = runtime_wrapListener(listener);
+			if (wrapped !== listener) map.set(listener, wrapped);
+			return orig.call(this, event, wrapped);
+		};
+	}
+
+	
+	runtime_installWrapper("on", origOn);
+	runtime_installWrapper("once", origOnce);
+	runtime_installWrapper("addListener", origAdd);
+	if (origPre) runtime_installWrapper("prependListener", origPre);
+	if (origPreO) runtime_installWrapper("prependOnceListener", origPreO);
+
+	
+	function runtime_createRemoveWrapper(method) {
+		
+		const runtime_removeWrapper = function (event, listener) {
+			const map = runtime_ensureMap(this);
+			const wrapped = map.get(listener) || listener;
+			map.delete(listener);
+			return method.call(this, event, wrapped);
+		};
+
+		return runtime_removeWrapper;
+	}
+
+	
+	if (proto.off) proto.off = runtime_createRemoveWrapper(origOff);
+	proto.removeListener = runtime_createRemoveWrapper(origRem);
+
+	
+	const origRemoveAll = proto.removeAllListeners;
+	proto.removeAllListeners = function (event) {
+		const res = origRemoveAll.call(this, event);
+		if (this[kMap]) this[kMap] = new WeakMap();
+		return res;
+	};
+}
+
+

package/dist/lib/helpers/auto-wrap.mjs

@@ -0,0 +1,60 @@
+/*
+	Copyright 2025 CLDMV/Shinrai
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+*/
+
+
+
+
+
+
+export async function autoWrapEventEmitters(nodeModule) {
+	
+	try {
+		const { self } = await import("@cldmv/slothlet/runtime");
+		if (!self?.__ctx) {
+			
+			return nodeModule;
+		}
+
+		const { makeWrapper } = await import("../runtime/runtime.mjs");
+		const wrapper = makeWrapper(self.__ctx);
+
+		
+		const wrappedModule = { ...nodeModule };
+
+		
+		if (typeof nodeModule.createServer === "function") {
+			const originalCreateServer = nodeModule.createServer;
+			wrappedModule.createServer = function (...args) {
+				const server = originalCreateServer.apply(this, args);
+				return wrapper(server);
+			};
+		}
+
+		return wrappedModule;
+	} catch (err) {
+		
+		console.error("autoWrapEventEmitters error:", err);
+		return nodeModule;
+	}
+}
+
+
+export async function getNet() {
+	const originalNet = await import("node:net");
+	return autoWrapEventEmitters(originalNet.default || originalNet);
+}
+
+

package/dist/lib/helpers/resolve-from-caller.mjs

@@ -17,6 +17,7 @@
 
 
 
+
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";

package/dist/lib/helpers/sanitize.mjs

@@ -17,6 +17,8 @@
 
 
 
+
+
 function globToRegex(pattern, caseSensitive = true) {
 	try {
 		

package/dist/lib/modes/slothlet_eager.mjs

@@ -18,8 +18,10 @@
 
 
 
-import fs from "fs/promises";
-import path from "path";
+
+
+import fs from "node:fs/promises";
+import path from "node:path";
 
 
 

package/dist/lib/modes/slothlet_lazy.mjs

@@ -15,8 +15,10 @@
 */
 
 
-import fs from "fs/promises";
-import path from "path";
+
+
+import fs from "node:fs/promises";
+import path from "node:path";
 import { runWithCtx } from "@cldmv/slothlet/runtime";
 
 

package/dist/lib/runtime/runtime.mjs

@@ -16,12 +16,21 @@
 
 
 
+
+
 import { AsyncLocalStorage } from "node:async_hooks";
 import util from "node:util";
+import { enableAlsForEventEmitters } from "@cldmv/slothlet/helpers/als-eventemitter";
 
 const als = new AsyncLocalStorage();
 
 
+export const sharedALS = new AsyncLocalStorage();
+
+
+enableAlsForEventEmitters(als);
+
+
 export const runWithCtx = (ctx, fn, thisArg, args) => {
 	
 	const runtime_runInALS = () => {
@@ -41,6 +50,9 @@ const EXCLUDED_CONSTRUCTORS = new Set([Object, Array, Promise, Date, RegExp, Err
 const EXCLUDED_INSTANCEOF_CLASSES = [ArrayBuffer, Map, Set, WeakMap, WeakSet];
 
 
+const PROMISE_METHODS = new Set(["then", "catch", "finally"]);
+
+
 function runtime_shouldWrapMethod(value, prop) {
 	return (
 		typeof value === "function" &&
@@ -127,6 +139,7 @@ function runtime_wrapClassInstance(instance, ctx, wrapFn, instanceCache) {
 export const makeWrapper = (ctx) => {
 	const cache = new WeakMap();
 	const instanceCache = new WeakMap();
+	const promiseMethodCache = new WeakMap(); 
 	const wrap = (val) => {
 		if (val == null || (typeof val !== "object" && typeof val !== "function")) return val;
 		if (cache.has(val)) return cache.get(val);
@@ -165,11 +178,66 @@ export const makeWrapper = (ctx) => {
 				return result;
 			},
 			get(target, prop, receiver) {
-				return wrap(Reflect.get(target, prop, receiver));
+				const value = Reflect.get(target, prop, receiver);
+
+				
+				
+				const isPromiseMethod = typeof value === "function" && PROMISE_METHODS.has(prop);
+				const isNativePromise = util.types.isPromise(target);
+				const hasThen = typeof target?.then === "function";
+
+				if (isPromiseMethod && (isNativePromise || hasThen)) {
+					
+					let targetMethodCache = promiseMethodCache.get(target);
+					if (!targetMethodCache) {
+						targetMethodCache = new Map();
+						promiseMethodCache.set(target, targetMethodCache);
+					}
+
+					if (targetMethodCache.has(prop)) {
+						return targetMethodCache.get(prop);
+					}
+
+					const wrappedMethod = function (...args) {
+						
+						const wrappedArgs = args.map((arg) => {
+							if (typeof arg === "function") {
+								return function (...callbackArgs) {
+									return runWithCtx(ctx, arg, undefined, callbackArgs);
+								};
+							}
+							return arg;
+						});
+
+						
+						const result = Reflect.apply(value, target, wrappedArgs);
+						
+						return wrap(result);
+					};
+
+					targetMethodCache.set(prop, wrappedMethod);
+					return wrappedMethod;
+				}
+
+				return wrap(value);
+			},
+			set(target, prop, value, receiver) {
+				
+				const methodCache = promiseMethodCache.get(target);
+				if (methodCache && methodCache.has(prop)) {
+					methodCache.delete(prop);
+				}
+				return Reflect.set(target, prop, value, receiver);
 			},
-			set: Reflect.set,
 			defineProperty: Reflect.defineProperty,
-			deleteProperty: Reflect.deleteProperty,
+			deleteProperty(target, prop) {
+				
+				const methodCache = promiseMethodCache.get(target);
+				if (methodCache && methodCache.has(prop)) {
+					methodCache.delete(prop);
+				}
+				return Reflect.deleteProperty(target, prop);
+			},
 			ownKeys: Reflect.ownKeys,
 			getOwnPropertyDescriptor: Reflect.getOwnPropertyDescriptor,
 			has: Reflect.has
@@ -352,3 +420,5 @@ export const context = runtime_createLiveBinding("context");
 
 
 export const reference = runtime_createLiveBinding("reference");
+
+

package/dist/slothlet.mjs

@@ -15,9 +15,11 @@
 */
 
 
-import fs from "fs/promises";
-import path from "path";
-import { fileURLToPath, pathToFileURL } from "url";
+
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 import { resolvePathFromCaller } from "@cldmv/slothlet/helpers/resolve-from-caller";
 import { sanitizePathName } from "@cldmv/slothlet/helpers/sanitize";
@@ -38,12 +40,6 @@ let DEBUG = process.argv.includes("--slothletdebug")
 		: false;
 
 
-export let _slothlet = new URL(import.meta.url).searchParams.get("_slothlet") || "";
-
-
-
-
-
 export const self = {};
 
 
@@ -152,7 +148,7 @@ const slothletObject = {
 					
 					
 					
-					
+
 					const imported = await import(modeUrl);
 					if (imported && typeof imported === "object") {
 						this.modes[modeName] = imported.default || imported;
@@ -167,9 +163,6 @@ const slothletObject = {
 		
 		const { entry = import.meta.url, mode = "singleton", api_mode = "auto" } = options ?? {};
 
-		_slothlet = new URL(import.meta.url).searchParams.get("_slothlet") || "";
-		
-
 		
 		
 		
@@ -244,8 +237,6 @@ const slothletObject = {
 			
 		}
 
-		
-
 		if (this.loaded) return this.api;
 		if (this.config.lazy) {
 			this.api = await this.modes.lazy.create.call(this, apiDir, true, this.config.apiDepth || Infinity, 0);
@@ -284,8 +275,6 @@ const slothletObject = {
 		
 		const _boundapi = this.createBoundApi(l_ctxRef.reference);
 
-		
-
 		mutateLiveBindingFunction(this.boundapi, _boundapi);
 
 		this.updateBindings(this.context, this.reference, this.boundapi);
@@ -609,8 +598,7 @@ const slothletObject = {
 	
 	async _loadSingleModule(modulePath, rootLevel = false) {
 		const moduleUrl = pathToFileURL(modulePath).href;
-		
-		
+
 		
 		const module = await import(moduleUrl);
 
@@ -619,7 +607,6 @@ const slothletObject = {
 
 		
 
-		
 		if (this.config.debug) console.log("module: ", module);
 		
 		if (typeof module.default === "function") {

package/index.cjs

@@ -33,8 +33,8 @@ const modPromise = import("@cldmv/slothlet/slothlet");
  * @returns {Promise<function|object>} The bound API object with live-binding context
  *
  * @example // CJS
- * const slothlet = require('@cldmv/slothlet');
- * const api = await slothlet({ dir: './api', context: { user: 'alice' } });
+ * const slothlet = require("@cldmv/slothlet");
+ * const api = await slothlet({ dir: "./api", context: { user: "alice" } });
  * console.log(api.config.username); // Access configuration
  */
 async function slothlet(options = {}) {
@@ -75,7 +75,7 @@ module.exports = slothlet;
  * @type {Function}
  *
  * @example // CJS named destructuring
- * const { slothlet } = require('@cldmv/slothlet');
- * const api = await slothlet({ dir: './api' });
+ * const { slothlet } = require("@cldmv/slothlet");
+ * const api = await slothlet({ dir: "./api" });
  */
 module.exports.slothlet = slothlet; // optional named alias

package/index.mjs

@@ -30,7 +30,7 @@
  * @returns {Promise<function|object>} The bound API object with live-binding context
  *
  * @example // ESM
- * import slothlet from '@cldmv/slothlet';
+ * import slothlet from "@cldmv/slothlet";
  * const api = await slothlet({ dir: './api', lazy: true });
  * const result = await api.math.add(2, 3); // 5
  *
@@ -69,7 +69,7 @@ export default async function slothlet(options = {}) {
  * @type {Function}
  *
  * @example // ESM named import
- * import { slothlet } from '@cldmv/slothlet';
+ * import { slothlet } from "@cldmv/slothlet";
  * const api = await slothlet({ dir: './api' });
  */
 // Optional named alias

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cldmv/slothlet",
-	"version": "2.3.0",
+	"version": "2.3.2",
 	"moduleVersions": {
 		"lazy": "1.0.0",
 		"eager": "1.0.0"
@@ -139,6 +139,7 @@
 		"@eslint/markdown": "^7.2.0",
 		"@html-eslint/eslint-plugin": "^0.45.0",
 		"@html-eslint/parser": "^0.45.0",
+		"@types/node": "^24.9.1",
 		"chalk": "^5.6.0",
 		"dmd": "^7.1.1",
 		"eslint": "^9.33.0",

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

@@ -3,7 +3,7 @@
  * @param {Function} fn - Shutdown function to set
  * @returns {Function} Previously set shutdown function
  * @example
- * const prev = setShutdown(() => console.log('Shutting down'));
+ * const prev = setShutdown(() => console.log("Shutting down"));
  */
 export function setShutdown(fn: Function): Function;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"slothlet_engine.d.mts","sourceRoot":"","sources":["../../../../dist/lib/engine/slothlet_engine.mjs"],"names":[],"mappings":"AAoBA;;;;;;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"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"slothlet_esm.d.mts","sourceRoot":"","sources":["../../../../dist/lib/engine/slothlet_esm.mjs"],"names":[],"mappings":"AAOA;;;;;;;;;;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"}
+{"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

@@ -5,7 +5,7 @@ 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(): 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.
@@ -21,4 +21,5 @@ 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 +1 @@
-{"version":3,"file":"slothlet_helpers.d.mts","sourceRoot":"","sources":["../../../../dist/lib/engine/slothlet_helpers.mjs"],"names":[],"mappings":"AAWA,gDAwBC;AAED,oEAGC;AAED,yEAYC;AAED,6CA6BC;AAED,mCAEC;AAED,+CAEC;AAED,uCAOC;AAQD,0CAyBC;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"}
+{"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/helpers/als-eventemitter.d.mts

@@ -0,0 +1,23 @@
+/**
+ * Enable AsyncLocalStorage context propagation for all EventEmitter instances.
+ *
+ * @function enableAlsForEventEmitters
+ * @package
+ * @param {AsyncLocalStorage} [als=sharedALS] - 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): void;
+export type AsyncLocalStorage = import("async_hooks").AsyncLocalStorage<any>;
+//# sourceMappingURL=als-eventemitter.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"als-eventemitter.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/als-eventemitter.mjs"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gDAfW,iBAAiB,QAoK3B"}

package/types/dist/lib/helpers/auto-wrap.d.mts

@@ -0,0 +1,49 @@
+/**
+ *	@Project: @cldmv/slothlet
+ *	@Filename: /src/lib/helpers/auto-wrap.mjs
+ *	@Date: 2025-10-21 13:32:36 -07:00 (1761078756)
+ *	@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-10-22 06:59:17 -07:00 (1761141557)
+ *	-----
+ *	@Copyright: Copyright (c) 2013-2025 Catalyzed Motivation Inc. All rights reserved.
+ */
+/**
+ * @fileoverview Helper for automatically wrapping Node.js EventEmitter instances within API modules.
+ * Internal file (not exported in package.json).
+ * @module @cldmv/slothlet/src/lib/helpers/auto-wrap
+ */
+/**
+ * Automatically wrap Node.js EventEmitter constructors when called within slothlet API context.
+ * This ensures that EventEmitter instances created inside API modules preserve AsyncLocalStorage context.
+ * @function autoWrapEventEmitters
+ * @package
+ * @param {NetModule} nodeModule - The Node.js module to wrap (e.g., require("node:net"))
+ * @returns {NetModule} Wrapped module with auto-wrapping constructors
+ *
+ * @description
+ * Wraps Node.js module functions that return EventEmitter instances so they automatically
+ * return wrapped instances when called within slothlet API context.
+ *
+ * @example
+ * // Usage in API modules:
+ * import { autoWrapEventEmitters } from "@cldmv/slothlet/src/lib/helpers/auto-wrap";
+ * import originalNet from "node:net";
+ * const net = autoWrapEventEmitters(originalNet);
+ * // Now net.createServer() returns wrapped instances automatically
+ */
+export function autoWrapEventEmitters(nodeModule: NetModule): NetModule;
+/**
+ * Lazily get the pre-wrapped net module for convenient use in API modules.
+ * @function getNet
+ * @package
+ * @returns {Promise<NetModule>} Promise resolving to the wrapped net module
+ * @example
+ * const net = await getNet();
+ */
+export function getNet(): Promise<NetModule>;
+export type NetModule = typeof import("node:net");
+export type NetServer = import("node:net").Server;
+//# sourceMappingURL=auto-wrap.d.mts.map

package/types/dist/lib/helpers/auto-wrap.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-wrap.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/auto-wrap.mjs"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,kDAdW,SAAS,GACP,SAAS,CA2CrB;AAED;;;;;;;GAOG;AACH,0BAJa,OAAO,CAAC,SAAS,CAAC,CAO9B;wBAGY,cAAc,UAAU,CAAC;wBACzB,OAAO,UAAU,EAAE,MAAM"}

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

@@ -29,7 +29,7 @@
  *   const stack = getStack(findCaller);
  *   for (const frame of stack) {
  *     const filename = frame?.getFileName?.();
- *     if (filename && !filename.includes('node_modules')) {
+ *     if (filename && !filename.includes("node_modules")) {
  *       return filename; // First non-dependency file
  *     }
  *   }
@@ -40,7 +40,7 @@ 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')
+ * @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
  *
@@ -61,24 +61,24 @@ export function getStack(skipFn?: Function): Array<CallSite>;
  *
  * @example
  * // From a file at /project/src/modules/math.mjs
- * const configPath = resolvePathFromCaller('../config.json');
+ * const configPath = resolvePathFromCaller("../config.json");
  * // Returns: /project/config.json (absolute filesystem path)
  *
  * @example
  * // Short-circuit cases
- * resolvePathFromCaller('file:///absolute/path.txt');
+ * resolvePathFromCaller("file:///absolute/path.txt");
  * // Returns: /absolute/path.txt (converted from URL)
  *
- * resolvePathFromCaller('/already/absolute/path.txt');
+ * 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');
+ * resolvePathFromCaller("./helpers/format.js");
  * // Returns: /project/src/lib/helpers/format.js
  *
- * resolvePathFromCaller('../../config/settings.json');
+ * resolvePathFromCaller("../../config/settings.json");
  * // Returns: /project/config/settings.json
  */
 export function resolvePathFromCaller(rel: string): string;
@@ -86,7 +86,7 @@ export function resolvePathFromCaller(rel: string): string;
  * @function resolveUrlFromCaller
  * @package
  * @internal
- * @param {string} rel - Relative path to resolve (e.g., '../config.json', './data/file.txt')
+ * @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
  *
@@ -106,27 +106,27 @@ export function resolvePathFromCaller(rel: string): string;
  *
  * @example
  * // From a file at /project/src/modules/math.mjs
- * const configUrl = resolveUrlFromCaller('../config.json');
+ * const configUrl = resolveUrlFromCaller("../config.json");
  * // Returns: file:///project/config.json (absolute file:// URL)
  *
  * @example
  * // Short-circuit cases
- * resolveUrlFromCaller('file:///absolute/path.txt');
+ * resolveUrlFromCaller("file:///absolute/path.txt");
  * // Returns: file:///absolute/path.txt (unchanged)
  *
- * resolveUrlFromCaller('/already/absolute/path.txt');
+ * 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 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
+ * // 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;

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":"AAyEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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":"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"}

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":"AAmEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"slothlet_eager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/modes/slothlet_eager.mjs"],"names":[],"mappings":"AA8HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAsDH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BAtBW,MAAM,cACN,OAAO,aACP,MAAM,iBACN,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAqE3B"}
+{"version":3,"file":"slothlet_eager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/modes/slothlet_eager.mjs"],"names":[],"mappings":"AA2IA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAsDH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BAtBW,MAAM,cACN,OAAO,aACP,MAAM,iBACN,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAqE3B"}

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

@@ -1 +1 @@
-{"version":3,"file":"slothlet_lazy.d.mts","sourceRoot":"","sources":["../../../../dist/lib/modes/slothlet_lazy.mjs"],"names":[],"mappings":"AAgJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,4BAvBW,MAAM,cACN,OAAO,aACP,MAAM,iBACN,MAAM,GACJ,OAAO,CAAC,WAAS,MAAM,CAAC,CAwEpC"}
+{"version":3,"file":"slothlet_lazy.d.mts","sourceRoot":"","sources":["../../../../dist/lib/modes/slothlet_lazy.mjs"],"names":[],"mappings":"AA6JA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,4BAvBW,MAAM,cACN,OAAO,aACP,MAAM,iBACN,MAAM,GACJ,OAAO,CAAC,WAAS,MAAM,CAAC,CAwEpC"}

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

@@ -1,3 +1,10 @@
+/**
+ * Shared AsyncLocalStorage instance for all slothlet instances.
+ * Provides unified context management across all EventEmitter wrappers.
+ * @type {AsyncLocalStorageType}
+ * @public
+ */
+export const sharedALS: AsyncLocalStorageType;
 export function runWithCtx(ctx: object, fn: Function, thisArg: any, args: any[]): any;
 export function getCtx(): object | null;
 export function makeWrapper(ctx: object): Function;
@@ -46,4 +53,6 @@ export const context: object;
  * console.log(reference); // Current reference data
  */
 export const reference: object;
+export type AsyncLocalStorageType = AsyncLocalStorage<any>;
+import { AsyncLocalStorage } from "node:async_hooks";
 //# 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":"AA0CO,gCAdI,MAAM,yBAEN,GAAG,gBAED,GAAG,CA6Bf;AAiBM,0BAZM,MAAM,GAAC,IAAI,CAY0B;AA8K3C,iCAjBI,MAAM,YAwEhB;AA4RD;;;;;;;;;;;;;GAaG;AACH,mBATU,WAAS,MAAM,CAS6B;AAEtD;;;;;;;;;;;;;GAaG;AACH,sBATU,MAAM,CAS4C;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBATU,MAAM,CASgD"}
+{"version":3,"file":"runtime.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime.mjs"],"names":[],"mappings":"AAuCA;;;;;GAKG;AACH,wBAHU,qBAAqB,CAGkB;AAsB1C,gCAdI,MAAM,yBAEN,GAAG,gBAED,GAAG,CA6Bf;AAiBM,0BAZM,MAAM,GAAC,IAAI,CAY0B;AAiL3C,iCAjBI,MAAM,YAgIhB;AA4RD;;;;;;;;;;;;;GAaG;AACH,mBATU,WAAS,MAAM,CAS6B;AAEtD;;;;;;;;;;;;;GAaG;AACH,sBATU,MAAM,CAS4C;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBATU,MAAM,CASgD;;kCAhrB9B,kBAAkB"}

package/types/dist/slothlet.d.mts

@@ -9,13 +9,6 @@
  * mutateLiveBindingFunction(boundapi, newApi);
  */
 export function mutateLiveBindingFunction(target: Function | object, source: Function | object): void;
-/**
- * The shared _slothlet parameter for live binding coordination.
- * @type {string}
- * @private
- * @internal
- */
-export let _slothlet: string;
 /**
  * Live-binding reference to the current API instance.
  * This is updated whenever a new API instance is created.
@@ -86,7 +79,7 @@ export type SlothletOptions = {
     api_mode?: string;
     /**
      * - Context data object injected into live-binding `context` reference.
-     * - Available to all loaded modules via `import { context } from '@cldmv/slothlet/runtime'`. Useful for request data,
+     * - Available to all loaded modules via `import { context } from "@cldmv/slothlet/runtime"`. Useful for request data,
      * - user sessions, environment configs, etc.
      */
     context?: object;

package/types/dist/slothlet.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"slothlet.d.mts","sourceRoot":"","sources":["../../dist/slothlet.mjs"],"names":[],"mappings":"AAi5CA;;;;;;;;;GASG;AACH,kDARW,WAAS,MAAM,UACf,WAAS,MAAM,QAwCzB;AAzzCD;;;;;GAKG;AACH,sBAJU,MAAM,CAIoE;AAKpF;;;;;;;GAOG;AACH,mBAJU,MAAM,CAIO;AAEvB;;;;;GAKG;AACH,sBAJU,MAAM,CAIU;AAE1B;;;;;GAKG;AACH,wBAJU,MAAM,CAIY;;;;;;;;;UAiyCd,MAAM;;;;;;WAIN,OAAO;;;;;;;eAGP,MAAM;;;;;;;;YAIN,OAAO;;;;;;;;WAKP,MAAM;;;;;;;eAKN,MAAM;;;;;;cAIN,MAAM;;;;;;gBAGN,MAAM;;;;;;eAMjB;QAA8B,UAAU,GAA7B,OAAO;QACY,gBAAgB,GAAnC,OAAO;QACY,gBAAgB,GAAnC,OAAO;QACW,KAAK,GAClC;YAAqC,KAAK,GAA/B,MAAM,EAAE;YACkB,gBAAgB,GAA1C,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;SACrB;KAAA;;AAz0CD;;;;;;;;GAQG;AACH,mCAJW,eAAe,GACb,OAAO,CAAC,WAAS,MAAM,CAAC,CAiCpC"}
+{"version":3,"file":"slothlet.d.mts","sourceRoot":"","sources":["../../dist/slothlet.mjs"],"names":[],"mappings":"AA04CA;;;;;;;;;GASG;AACH,kDARW,WAAS,MAAM,UACf,WAAS,MAAM,QAwCzB;AAryCD;;;;;;;GAOG;AACH,mBAJU,MAAM,CAIO;AAEvB;;;;;GAKG;AACH,sBAJU,MAAM,CAIU;AAE1B;;;;;GAKG;AACH,wBAJU,MAAM,CAIY;;;;;;;;;UAwxCd,MAAM;;;;;;WAIN,OAAO;;;;;;;eAGP,MAAM;;;;;;;;YAIN,OAAO;;;;;;;;WAKP,MAAM;;;;;;;eAKN,MAAM;;;;;;cAIN,MAAM;;;;;;gBAGN,MAAM;;;;;;eAMjB;QAA8B,UAAU,GAA7B,OAAO;QACY,gBAAgB,GAAnC,OAAO;QACY,gBAAgB,GAAnC,OAAO;QACW,KAAK,GAClC;YAAqC,KAAK,GAA/B,MAAM,EAAE;YACkB,gBAAgB,GAA1C,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;SACrB;KAAA;;AAh0CD;;;;;;;;GAQG;AACH,mCAJW,eAAe,GACb,OAAO,CAAC,WAAS,MAAM,CAAC,CAiCpC"}

package/types/index.d.mts

@@ -11,7 +11,6 @@ export type * from "./dist/slothlet.d.mts";
 export * from "./dist/slothlet.mts";
 
 // Auto-generated named export declarations (these override the re-export above)
-export const _slothlet: any;
 export const context: any;
 export const mutateLiveBindingFunction: any;
 export const reference: any;