@cldmv/slothlet 2.5.6 → 2.6.0

package/dist/lib/runtime/runtime.mjs

@@ -14,422 +14,214 @@
 	limitations under the License.
 */
 
+
 
 
 
+import { detectCurrentInstanceId, getInstanceData } from "../helpers/instance-manager.mjs";
 
-import { AsyncLocalStorage } from "node:async_hooks";
-import util from "node:util";
-import { enableAlsForEventEmitters } from "@cldmv/slothlet/helpers/als-eventemitter";
 
-const als = new AsyncLocalStorage();
+const asyncRuntime = await import("./runtime-asynclocalstorage.mjs");
+const liveBindingsRuntime = await import("./runtime-livebindings.mjs");
 
 
-export const sharedALS = new AsyncLocalStorage();
-
-
-enableAlsForEventEmitters(als);
-
-
-export const runWithCtx = (ctx, fn, thisArg, args) => {
+function detectRuntimeType() {
 	
-	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"]);
+	const instanceId = detectCurrentInstanceId();
 
+	if (instanceId) {
+		const instanceData = getInstanceData(instanceId);
+		if (instanceData && instanceData.config && instanceData.config.runtime) {
+			return instanceData.config.runtime;
+		}
+	}
 
-function runtime_shouldWrapMethod(value, prop) {
-	return (
-		typeof value === "function" &&
-		typeof prop === "string" && 
-		prop !== "constructor" &&
-		!(prop in Object.prototype) &&
-		!prop.startsWith("__")
-	);
+	
+	return "async";
 }
 
 
-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 getCurrentRuntime() {
+	const runtimeType = detectRuntimeType();
+	return runtimeType === "live" ? liveBindingsRuntime : asyncRuntime;
 }
 
 
-function runtime_wrapClassInstance(instance, ctx, wrapFn, instanceCache) {
-	if (instanceCache.has(instance)) {
-		return instanceCache.get(instance);
-	}
+export const self = new Proxy(
+	function runtime_selfProxy() {}, 
+	{
+		get(_, prop) {
+			const runtime = getCurrentRuntime();
+			return runtime.self[prop];
+		},
+		ownKeys(target) {
+			const runtime = getCurrentRuntime();
+			const runtimeKeys = Reflect.ownKeys(runtime.self);
+			const targetKeys = Reflect.ownKeys(target);
 
-	
-	const methodCache = new Map();
+			
+			const allKeys = new Set([...runtimeKeys, ...targetKeys]);
+			return Array.from(allKeys);
+		},
+		has(_, prop) {
+			const runtime = getCurrentRuntime();
+			return prop in runtime.self;
+		},
+		getOwnPropertyDescriptor(target, prop) {
+			const runtime = getCurrentRuntime();
+			const descriptor = Reflect.getOwnPropertyDescriptor(runtime.self, prop);
 
-	const wrappedInstance = new Proxy(instance, {
-		get(target, prop, receiver) {
 			
-			if (methodCache.has(prop)) {
-				return methodCache.get(prop);
+			if (!descriptor) {
+				return Reflect.getOwnPropertyDescriptor(target, prop);
 			}
 
-			const value = Reflect.get(target, prop, receiver);
-
 			
 			
-			if (runtime_shouldWrapMethod(value, prop)) {
-				
+			const targetDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+			if (!targetDescriptor && descriptor && descriptor.configurable === false) {
 				
-				const runtime_contextPreservingMethod = function (...args) {
-					const result = runWithCtx(ctx, value, target, args);
-					
-					return wrapFn(result);
-				};
-
 				
-				methodCache.set(prop, runtime_contextPreservingMethod);
-				return runtime_contextPreservingMethod;
+				return undefined;
 			}
 
-			
-			return wrapFn(value);
+			return descriptor;
 		},
-
-		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;
+		getPrototypeOf() {
+			const runtime = getCurrentRuntime();
+			return Reflect.getPrototypeOf(runtime.self);
+		},
+		isExtensible() {
+			const runtime = getCurrentRuntime();
+			return Reflect.isExtensible(runtime.self);
 		}
 	}
-}
-
-
-function runtime_createLiveBinding(contextKey) {
-	
-	
-	function runtime_liveBindingTarget() {}
-	const liveBinding = runtime_liveBindingTarget;
-
-	
-	const runtime_syncWithContext = () => runtime_mutateLiveBinding(liveBinding, contextKey);
+);
+
+export const context = new Proxy(
+	{}, 
+	{
+		get(_, prop) {
+			const runtime = getCurrentRuntime();
+			return runtime.context[prop];
+		},
+		ownKeys(target) {
+			const runtime = getCurrentRuntime();
+			const runtimeKeys = Reflect.ownKeys(runtime.context);
+			const targetKeys = Reflect.ownKeys(target);
 
-	
-	
-	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;
+			const allKeys = new Set([...runtimeKeys, ...targetKeys]);
+			return Array.from(allKeys);
 		},
-		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`);
+		has(_, prop) {
+			const runtime = getCurrentRuntime();
+			return prop in runtime.context;
 		},
+		getOwnPropertyDescriptor(target, prop) {
+			const runtime = getCurrentRuntime();
+			const descriptor = Reflect.getOwnPropertyDescriptor(runtime.context, prop);
 
-		get(target, prop) {
 			
-			if (prop === "nonExistentTestProperty") {
-				
-				
-				
-				return undefined;
+			if (!descriptor) {
+				return Reflect.getOwnPropertyDescriptor(target, prop);
 			}
 
 			
-			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 targetDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+			if (!targetDescriptor && descriptor && descriptor.configurable === false) {
+				
 				
-				const runtime_toPrimitiveHandler = (hint) => {
-					const v = getCtx()?.[contextKey];
-					return hint === "string" ? String(v) : v;
-				};
-				return runtime_toPrimitiveHandler;
+				return undefined;
 			}
 
-			
-			
+			return descriptor;
+		},
+		getPrototypeOf() {
+			const runtime = getCurrentRuntime();
+			return Reflect.getPrototypeOf(runtime.context);
+		},
+		isExtensible() {
+			const runtime = getCurrentRuntime();
+			return Reflect.isExtensible(runtime.context);
+		}
+	}
+);
+
+export const reference = new Proxy(
+	{}, 
+	{
+		get(_, prop) {
+			const runtime = getCurrentRuntime();
+			return runtime.reference[prop];
+		},
+		ownKeys(target) {
+			const runtime = getCurrentRuntime();
+			const runtimeKeys = Reflect.ownKeys(runtime.reference);
+			const targetKeys = Reflect.ownKeys(target);
 
 			
-			runtime_syncWithContext();
-			return target[prop];
+			const allKeys = new Set([...runtimeKeys, ...targetKeys]);
+			return Array.from(allKeys);
 		},
+		has(_, prop) {
+			const runtime = getCurrentRuntime();
+			return prop in runtime.reference;
+		},
+		getOwnPropertyDescriptor(target, prop) {
+			const runtime = getCurrentRuntime();
+			const descriptor = Reflect.getOwnPropertyDescriptor(runtime.reference, prop);
 
-		set(target, prop, value) {
-			runtime_syncWithContext();
-			target[prop] = value;
+			
+			if (!descriptor) {
+				return Reflect.getOwnPropertyDescriptor(target, prop);
+			}
 
 			
-			const ctx = getCtx();
-			if (ctx && ctx[contextKey] && typeof ctx[contextKey] === "object") {
-				ctx[contextKey][prop] = value;
+			
+			const targetDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+			if (!targetDescriptor && descriptor && descriptor.configurable === false) {
+				
+				
+				return undefined;
 			}
-			return true;
-		},
 
-		has(target, prop) {
-			runtime_syncWithContext();
-			return prop in target;
+			return descriptor;
 		},
-
-		ownKeys(target) {
-			runtime_syncWithContext();
-			return Reflect.ownKeys(target);
+		getPrototypeOf() {
+			const runtime = getCurrentRuntime();
+			return Reflect.getPrototypeOf(runtime.reference);
 		},
-
-		getOwnPropertyDescriptor(target, prop) {
-			runtime_syncWithContext();
-			return Object.getOwnPropertyDescriptor(target, prop);
+		isExtensible() {
+			const runtime = getCurrentRuntime();
+			return Reflect.isExtensible(runtime.reference);
 		}
-	});
-
-	
-	
-	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 function runWithCtx(ctx, fn, thisArg, args) {
+	const runtime = getCurrentRuntime();
+	return runtime.runWithCtx(ctx, fn, thisArg, args);
 }
 
+export function makeWrapper(ctx) {
+	const runtime = getCurrentRuntime();
+	return runtime.makeWrapper(ctx);
+}
 
+export function getCtx() {
+	const runtime = getCurrentRuntime();
+	return (runtime.getCtx || runtime.getContext)();
+}
 
+export const instanceId = (() => {
+	const runtimeType = detectRuntimeType();
+	if (runtimeType === "async") {
+		return null;
+	}
+	const runtime = getCurrentRuntime();
+	return runtime.instanceId;
+})();
 
-export const self = runtime_createLiveBinding("self");
-
-
-export const context = runtime_createLiveBinding("context");
-
-
-export const reference = runtime_createLiveBinding("reference");
-
-
+export const sharedALS = getCurrentRuntime().sharedALS;