@cldmv/slothlet 2.5.6 → 2.6.0

package/dist/lib/runtime/runtime-asynclocalstorage.mjs

@@ -0,0 +1,435 @@
+/*
+	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 { 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 = () => {
+		const result = Reflect.apply(fn, thisArg, args);
+		return result;
+	};
+	return als.run(ctx, runtime_runInALS);
+};
+
+
+export const getCtx = () => als.getStore() || null;
+
+
+const EXCLUDED_CONSTRUCTORS = new Set([Object, Array, Promise, Date, RegExp, Error]);
+
+
+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" &&
+		typeof prop === "string" && 
+		prop !== "constructor" &&
+		!(prop in Object.prototype) &&
+		!prop.startsWith("__")
+	);
+}
+
+
+function runtime_isClassInstance(val) {
+	if (
+		val == null ||
+		typeof val !== "object" ||
+		!val.constructor ||
+		typeof val.constructor !== "function" ||
+		EXCLUDED_CONSTRUCTORS.has(val.constructor)
+	) {
+		return false;
+	}
+
+	for (const cls of EXCLUDED_INSTANCEOF_CLASSES) {
+		if (typeof cls === "function" && val instanceof cls) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+function runtime_wrapClassInstance(instance, ctx, wrapFn, instanceCache) {
+	if (instanceCache.has(instance)) {
+		return instanceCache.get(instance);
+	}
+
+	
+	const methodCache = new Map();
+
+	const wrappedInstance = new Proxy(instance, {
+		get(target, prop, receiver) {
+			
+			if (methodCache.has(prop)) {
+				return methodCache.get(prop);
+			}
+
+			const value = Reflect.get(target, prop, receiver);
+
+			
+			
+			if (runtime_shouldWrapMethod(value, prop)) {
+				
+				
+				const runtime_contextPreservingMethod = function (...args) {
+					const result = runWithCtx(ctx, value, target, args);
+					
+					return wrapFn(result);
+				};
+
+				
+				methodCache.set(prop, runtime_contextPreservingMethod);
+				return runtime_contextPreservingMethod;
+			}
+
+			
+			return wrapFn(value);
+		},
+
+		set(target, prop, value, receiver) {
+			
+			if (methodCache.has(prop)) {
+				methodCache.delete(prop);
+			}
+			return Reflect.set(target, prop, value, receiver);
+		}
+	});
+
+	instanceCache.set(instance, wrappedInstance);
+	return wrappedInstance;
+}
+
+
+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);
+
+		const proxied = new Proxy(val, {
+			apply(target, thisArg, args) {
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+
+				const result = runWithCtx(ctx, target, thisArg, args);
+
+				
+				if (runtime_isClassInstance(result)) {
+					return runtime_wrapClassInstance(result, ctx, wrap, instanceCache);
+				}
+
+				return result;
+			},
+			construct(target, args, newTarget) {
+				
+				const result = runWithCtx(ctx, Reflect.construct, undefined, [target, args, newTarget]);
+
+				
+				if (runtime_isClassInstance(result)) {
+					return runtime_wrapClassInstance(result, ctx, wrap, instanceCache);
+				}
+
+				return result;
+			},
+			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);
+			},
+			defineProperty: Reflect.defineProperty,
+			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
+		});
+
+		cache.set(val, proxied);
+		return proxied;
+	};
+	return wrap;
+};
+
+function runtime_mutateLiveBinding(target, contextKey) {
+	const ctx = getCtx();
+	const source = ctx?.[contextKey];
+
+	
+	if (!source) {
+		for (const key of Object.keys(target)) {
+			if (key !== "_impl") delete target[key];
+		}
+		return;
+	}
+
+	if (typeof source === "function") {
+		
+		
+		const runtime_forwardToSource = (...args) => source(...args);
+		target._impl = runtime_forwardToSource;
+
+		
+		for (const key of Object.keys(target)) {
+			if (key !== "_impl") delete target[key];
+		}
+		for (const key of Object.getOwnPropertyNames(source)) {
+			if (key !== "length" && key !== "name" && key !== "prototype" && key !== "_impl") {
+				try {
+					target[key] = source[key];
+				} catch {
+					
+				}
+			}
+		}
+	} else if (typeof source === "object" && source !== null) {
+		
+		for (const key of Object.keys(target)) {
+			if (key !== "_impl") delete target[key];
+		}
+		for (const [key, value] of Object.entries(source)) {
+			try {
+				target[key] = value;
+			} catch (error) {
+				
+				
+				
+				if (error instanceof TypeError && error.message.includes("read only")) {
+					continue;
+				}
+				
+				throw error;
+			}
+		}
+		if (typeof source._impl === "function") {
+			target._impl = source._impl;
+		}
+	}
+}
+
+
+function runtime_createLiveBinding(contextKey) {
+	
+	
+	function runtime_liveBindingTarget() {}
+	const liveBinding = runtime_liveBindingTarget;
+
+	
+	const runtime_syncWithContext = () => runtime_mutateLiveBinding(liveBinding, contextKey);
+
+	
+	
+	const runtime_renderSnapshot = (val) => {
+		if (typeof val === "function") {
+			const name = val.name || "anonymous";
+			const props = {};
+			for (const k of Object.keys(val)) props[k] = val[k];
+			
+			return { [`[Function: ${name}]`]: true, ...props };
+		}
+		return val;
+	};
+
+	const proxy = new Proxy(liveBinding, {
+		
+		apply(_t, thisArg, args) {
+			const cur = getCtx()?.[contextKey];
+			if (typeof cur === "function") {
+				return Reflect.apply(cur, thisArg, args);
+			}
+			
+			return cur;
+		},
+		construct(_t, args, newTarget) {
+			const cur = getCtx()?.[contextKey];
+			if (typeof cur === "function") {
+				return Reflect.construct(cur, args, newTarget);
+			}
+			throw new TypeError(`${contextKey} is not a constructor`);
+		},
+
+		get(target, prop) {
+			
+			if (prop === "nonExistentTestProperty") {
+				
+				
+				
+				return undefined;
+			}
+
+			
+			if (prop === util.inspect.custom) return runtime_inspectHandler;
+			if (prop === "toJSON") return runtime_toJSONHandler;
+			if (prop === "$value") return runtime_toJSONHandler;
+			if (prop === Symbol.toPrimitive) {
+				
+				const runtime_toPrimitiveHandler = (hint) => {
+					const v = getCtx()?.[contextKey];
+					return hint === "string" ? String(v) : v;
+				};
+				return runtime_toPrimitiveHandler;
+			}
+
+			
+			
+
+			
+			runtime_syncWithContext();
+			return target[prop];
+		},
+
+		set(target, prop, value) {
+			runtime_syncWithContext();
+			target[prop] = value;
+
+			
+			const ctx = getCtx();
+			if (ctx && ctx[contextKey] && typeof ctx[contextKey] === "object") {
+				ctx[contextKey][prop] = value;
+			}
+			return true;
+		},
+
+		has(target, prop) {
+			runtime_syncWithContext();
+			return prop in target;
+		},
+
+		ownKeys(target) {
+			runtime_syncWithContext();
+			return Reflect.ownKeys(target);
+		},
+
+		getOwnPropertyDescriptor(target, prop) {
+			runtime_syncWithContext();
+			return Object.getOwnPropertyDescriptor(target, prop);
+		}
+	});
+
+	
+	
+	const runtime_inspectHandler = () => runtime_renderSnapshot(getCtx()?.[contextKey]);
+
+	
+	const runtime_toJSONHandler = () => getCtx()?.[contextKey];
+
+	Object.defineProperty(liveBinding, util.inspect.custom, { value: runtime_inspectHandler, enumerable: false });
+	Object.defineProperty(liveBinding, "toJSON", { value: runtime_toJSONHandler, enumerable: false });
+
+	
+	
+	
+
+	return proxy;
+}
+
+
+
+
+export const self = runtime_createLiveBinding("self");
+
+
+export const context = runtime_createLiveBinding("context");
+
+
+export const reference = runtime_createLiveBinding("reference");
+
+

package/dist/lib/runtime/runtime-livebindings.mjs

@@ -0,0 +1,298 @@
+/*
+	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 {
+	detectCurrentInstanceId,
+	getInstanceData,
+	setActiveInstance,
+	getCurrentActiveInstanceId
+} from "@cldmv/slothlet/helpers/instance-manager";
+
+
+function getCurrentInstanceContext() {
+	
+	
+	
+	
+	
+	
+	
+	
+	
+
+	
+	const instanceId = detectCurrentInstanceId();
+
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+
+	if (instanceId) {
+		const instanceData = getInstanceData(instanceId);
+		if (instanceData) {
+			return instanceData;
+		}
+	}
+
+	
+	
+	
+	return null;
+}
+
+
+export const self = new Proxy(
+	{},
+	{
+		get(target, prop) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.self) {
+				return ctx.self[prop];
+			}
+			return undefined;
+		},
+
+		set(target, prop, value) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.self) {
+				ctx.self[prop] = value;
+				return true;
+			}
+			return false;
+		},
+
+		ownKeys(_) {
+			
+			
+			
+			
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.self) {
+				return Reflect.ownKeys(ctx.self);
+			}
+			return [];
+		},
+
+		has(target, prop) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.self) {
+				return prop in ctx.self;
+			}
+			return false;
+		},
+
+		getOwnPropertyDescriptor(target, prop) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.self) {
+				return Reflect.getOwnPropertyDescriptor(ctx.self, prop);
+			}
+			return undefined;
+		}
+	}
+);
+
+
+export const context = new Proxy(
+	{},
+	{
+		get(target, prop) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.context) {
+				return ctx.context[prop];
+			}
+			return undefined;
+		},
+
+		set(target, prop, value) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.context) {
+				ctx.context[prop] = value;
+				return true;
+			}
+			return false;
+		},
+
+		ownKeys(_) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.context) {
+				return Reflect.ownKeys(ctx.context);
+			}
+			return [];
+		},
+
+		has(target, prop) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.context) {
+				return prop in ctx.context;
+			}
+			return false;
+		},
+
+		getOwnPropertyDescriptor(target, prop) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.context) {
+				return Reflect.getOwnPropertyDescriptor(ctx.context, prop);
+			}
+			return undefined;
+		}
+	}
+);
+
+
+export const reference = new Proxy(
+	{},
+	{
+		get(target, prop) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.reference) {
+				return ctx.reference[prop];
+			}
+			return undefined;
+		},
+
+		set(target, prop, value) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.reference) {
+				ctx.reference[prop] = value;
+				return true;
+			}
+			return false;
+		},
+
+		ownKeys(_) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.reference) {
+				return Reflect.ownKeys(ctx.reference);
+			}
+			return [];
+		},
+
+		has(target, prop) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.reference) {
+				return prop in ctx.reference;
+			}
+			return false;
+		},
+
+		getOwnPropertyDescriptor(target, prop) {
+			const ctx = getCurrentInstanceContext();
+			if (ctx && ctx.reference) {
+				return Reflect.getOwnPropertyDescriptor(ctx.reference, prop);
+			}
+			return undefined;
+		}
+	}
+);
+
+
+export const instanceId = new Proxy(
+	{},
+	{
+		get(target, prop) {
+			if (prop === "valueOf" || prop === "toString" || prop === Symbol.toPrimitive) {
+				const currentId = detectCurrentInstanceId();
+				return () => currentId || "unknown";
+			}
+			return detectCurrentInstanceId() || "unknown";
+		},
+
+		ownKeys(_) {
+			return ["valueOf", "toString"];
+		},
+
+		has(target, prop) {
+			return prop === "valueOf" || prop === "toString" || prop === Symbol.toPrimitive;
+		},
+
+		getOwnPropertyDescriptor(target, prop) {
+			if (prop === "valueOf" || prop === "toString" || prop === Symbol.toPrimitive) {
+				return {
+					configurable: true,
+					enumerable: false,
+					writable: false,
+					value: () => detectCurrentInstanceId() || "unknown"
+				};
+			}
+			return undefined;
+		}
+	}
+);
+
+
+export function runWithCtx(ctx, fn, thisArg, args) {
+	
+	const previousActiveInstance = getCurrentActiveInstanceId();
+
+	
+	if (ctx && ctx.instanceId) {
+		setActiveInstance(ctx.instanceId);
+	}
+
+	try {
+		
+		return Reflect.apply(fn, thisArg, args);
+	} finally {
+		
+		setActiveInstance(previousActiveInstance);
+	}
+}
+
+
+export function makeWrapper(_) {
+	return function wrapperFunction(obj) {
+		
+		
+		return obj;
+	};
+}
+
+
+
+
+
+export function getContext() {
+	return getCurrentInstanceContext();
+}
+
+export function setContext(newContext) {
+	
+	
+	const ctx = getCurrentInstanceContext();
+	if (ctx) {
+		
+		Object.assign(ctx, newContext);
+	}
+	
+}
+
+export const contextManager = {
+	get: getContext,
+	set: setContext,
+	runWithCtx
+};