@cldmv/slothlet 2.11.0 → 3.0.1

package/dist/lib/handlers/context-async.mjs

@@ -0,0 +1,184 @@
+/*
+	Copyright 2026 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 { AsyncLocalStorage } from "node:async_hooks";
+import { SlothletError } from "@cldmv/slothlet/errors";
+import { runtime_isClassInstance, runtime_wrapClassInstance } from "@cldmv/slothlet/helpers/class-instance-wrapper";
+import { setApiContextChecker } from "@cldmv/slothlet/helpers/eventemitter-context";
+
+
+export class AsyncContextManager {
+	constructor() {
+		this.als = new AsyncLocalStorage();
+		this.instances = new Map(); 
+	}
+
+	
+	registerEventEmitterContextChecker() {
+		setApiContextChecker(() => {
+			const store = this.als.getStore();
+			return store && store.instanceID ? true : false;
+		});
+	}
+
+	
+	initialize(instanceID, config = {}) {
+		if (this.instances.has(instanceID)) {
+			throw new SlothletError("CONTEXT_ALREADY_EXISTS", { instanceID }, null, { validationError: true });
+		}
+
+		const store = {
+			instanceID,
+			self: {},
+			context: {},
+			config: { ...config },
+			createdAt: Date.now()
+		};
+
+		this.instances.set(instanceID, store);
+		return store;
+	}
+
+	
+	runInContext(instanceID, fn, thisArg, args, currentWrapper) {
+		
+		const activeStore = this.als.getStore();
+		let baseStore;
+
+		
+		const isActiveOurInstance = activeStore && (activeStore.instanceID === instanceID || activeStore.parentInstanceID === instanceID);
+
+		if (isActiveOurInstance) {
+			
+			baseStore = activeStore;
+		} else {
+			
+			baseStore = this.instances.get(instanceID);
+			if (!baseStore) {
+				throw new SlothletError("CONTEXT_NOT_FOUND", {
+					instanceID,
+					availableInstances: Array.from(this.instances.keys())
+				});
+			}
+		}
+
+		
+		const executionStore = { ...baseStore };
+		if (currentWrapper) {
+			executionStore.callerWrapper = baseStore.currentWrapper;
+			executionStore.currentWrapper = currentWrapper;
+		}
+
+		
+		if (isActiveOurInstance) {
+			
+			return this.als.run(executionStore, () => {
+				try {
+					const result = fn.apply(thisArg, args);
+					
+					if (runtime_isClassInstance(result)) {
+						const instanceCache = new WeakMap();
+						return runtime_wrapClassInstance(result, this, instanceID, instanceCache);
+					}
+					return result;
+				} catch (error) {
+					throw new SlothletError(
+						"CONTEXT_EXECUTION_FAILED",
+						{
+							instanceID
+						},
+						error
+					);
+				}
+			});
+		}
+
+		
+		return this.als.run(executionStore, () => {
+			try {
+				const result = fn.apply(thisArg, args);
+				
+				if (runtime_isClassInstance(result)) {
+					const instanceCache = new WeakMap();
+					return runtime_wrapClassInstance(result, this, instanceID, instanceCache);
+				}
+				return result;
+			} catch (error) {
+				throw new SlothletError(
+					"CONTEXT_EXECUTION_FAILED",
+					{
+						instanceID
+					},
+					error
+				);
+			}
+		});
+	}
+
+	
+	getContext() {
+		const store = this.als.getStore();
+		if (!store) {
+			throw new SlothletError("NO_ACTIVE_CONTEXT_ASYNC", {}, null, { validationError: true });
+		}
+		return store;
+	}
+
+	
+	tryGetContext() {
+		return this.als.getStore();
+	}
+
+	
+	cleanup(instanceID) {
+		const store = this.instances.get(instanceID);
+		if (!store) {
+			throw new SlothletError(
+				"CONTEXT_NOT_FOUND",
+				{ instanceID, availableInstances: Array.from(this.instances.keys()).join(", ") || "none" },
+				null,
+				{ validationError: true }
+			);
+		}
+
+		
+		store.self = {};
+		store.context = {};
+
+		
+		this.instances.delete(instanceID);
+	}
+
+	
+	getDiagnostics() {
+		return {
+			type: "async",
+			activeStore: this.als.getStore()?.instanceID || null,
+			instances: Array.from(this.instances.entries()).map(([id, store]) => ({
+				id,
+				createdAt: store.createdAt,
+				contextKeys: Object.keys(store.context),
+				selfKeys: Object.keys(store.self)
+			}))
+		};
+	}
+}
+
+
+export const asyncContextManager = new AsyncContextManager();

package/dist/lib/handlers/context-live.mjs

@@ -0,0 +1,184 @@
+/*
+	Copyright 2026 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 { SlothletError } from "@cldmv/slothlet/errors";
+import { setApiContextChecker } from "@cldmv/slothlet/helpers/eventemitter-context";
+
+
+export class LiveContextManager {
+	constructor() {
+		this.instances = new Map(); 
+		this.currentInstanceID = null; 
+	}
+
+	
+	registerEventEmitterContextChecker() {
+		setApiContextChecker(() => {
+			return this.currentInstanceID !== null;
+		});
+	}
+
+	
+	initialize(instanceID, config = {}) {
+		if (this.instances.has(instanceID)) {
+			throw new SlothletError("CONTEXT_ALREADY_EXISTS", { instanceID }, null, { validationError: true });
+		}
+
+		const store = {
+			instanceID,
+			self: {},
+			context: {},
+			config: { ...config },
+			createdAt: Date.now()
+		};
+
+		this.instances.set(instanceID, store);
+
+		
+		if (!this.currentInstanceID) {
+			this.currentInstanceID = instanceID;
+		}
+
+		return store;
+	}
+
+	
+	runInContext(instanceID, fn, thisArg, args, currentWrapper) {
+		
+		const currentID = this.currentInstanceID;
+		let isAlreadyInContext = false;
+
+		if (currentID) {
+			const currentStore = this.instances.get(currentID);
+			isAlreadyInContext =
+				currentID === instanceID || currentStore?.parentInstanceID === instanceID || currentID.startsWith(instanceID + "__run_");
+		}
+
+		
+		const targetInstanceID = isAlreadyInContext ? currentID : instanceID;
+
+		const store = this.instances.get(targetInstanceID);
+		if (!store) {
+			throw new SlothletError("CONTEXT_NOT_FOUND", {
+				instanceID: targetInstanceID,
+				availableInstances: Array.from(this.instances.keys())
+			});
+		}
+
+		
+		const previousInstanceID = this.currentInstanceID;
+		const previousWrapper = store.currentWrapper;
+		const previousCallerWrapper = store.callerWrapper;
+
+		this.currentInstanceID = targetInstanceID;
+		if (currentWrapper) {
+			store.callerWrapper = previousWrapper;
+			store.currentWrapper = currentWrapper;
+		}
+
+		try {
+			return fn.apply(thisArg, args);
+		} catch (error) {
+			throw new SlothletError(
+				"CONTEXT_EXECUTION_FAILED",
+				{
+					instanceID
+				},
+				error
+			);
+		} finally {
+			
+			this.currentInstanceID = previousInstanceID;
+			store.currentWrapper = previousWrapper;
+			store.callerWrapper = previousCallerWrapper;
+		}
+	}
+
+	
+	getContext() {
+		if (!this.currentInstanceID) {
+			throw new SlothletError("NO_ACTIVE_CONTEXT_LIVE", {}, null, { validationError: true });
+		}
+
+		const store = this.instances.get(this.currentInstanceID);
+		if (!store) {
+			throw new SlothletError(
+				"CONTEXT_NOT_FOUND",
+				{
+					instanceID: this.currentInstanceID,
+					availableInstances: Array.from(this.instances.keys()).join(", ") || "none"
+				},
+				null,
+				{ validationError: true }
+			);
+		}
+
+		return store;
+	}
+
+	
+	tryGetContext() {
+		if (!this.currentInstanceID) {
+			return undefined;
+		}
+		return this.instances.get(this.currentInstanceID);
+	}
+
+	
+	cleanup(instanceID) {
+		const store = this.instances.get(instanceID);
+		if (!store) {
+			throw new SlothletError(
+				"CONTEXT_NOT_FOUND",
+				{ instanceID, availableInstances: Array.from(this.instances.keys()).join(", ") || "none" },
+				null,
+				{ validationError: true }
+			);
+		}
+
+		
+		store.self = {};
+		store.context = {};
+
+		
+		this.instances.delete(instanceID);
+
+		
+		if (this.currentInstanceID === instanceID) {
+			this.currentInstanceID = null;
+		}
+	}
+
+	
+	getDiagnostics() {
+		return {
+			type: "live",
+			currentInstanceID: this.currentInstanceID,
+			instances: Array.from(this.instances.entries()).map(([id, store]) => ({
+				id,
+				createdAt: store.createdAt,
+				contextKeys: Object.keys(store.context),
+				selfKeys: Object.keys(store.self)
+			}))
+		};
+	}
+}
+
+
+export const liveContextManager = new LiveContextManager();