@cldmv/slothlet 2.8.0 → 2.10.0

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

@@ -1,5 +1,5 @@
 /*
-	Copyright 2025 CLDMV/Shinrai
+	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.

package/dist/lib/helpers/hooks.mjs

@@ -1,5 +1,5 @@
 /*
-	Copyright 2025 CLDMV/Shinrai
+	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.

package/dist/lib/helpers/instance-manager.mjs

@@ -1,5 +1,5 @@
 /*
-	Copyright 2025 CLDMV/Shinrai
+	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.

package/dist/lib/helpers/metadata-api.mjs

@@ -0,0 +1,201 @@
+/*
+	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 { getStack, toFsPath } from "@cldmv/slothlet/helpers/resolve-from-caller";
+
+
+let runtimeModule = null;
+let runtimeImportPromise = null;
+
+
+async function ensureRuntime() {
+	if (runtimeModule) {
+		return runtimeModule;
+	}
+
+	if (!runtimeImportPromise) {
+		runtimeImportPromise = import("@cldmv/slothlet/runtime")
+			.then((module) => {
+				runtimeModule = module;
+				return module;
+			})
+			.catch((err) => {
+				console.error("[slothlet] Failed to import runtime for metadata API:", err.message);
+				runtimeModule = {}; 
+				return {};
+			});
+	}
+
+	return runtimeImportPromise;
+}
+
+
+function getApiRoot() {
+	
+	return runtimeModule?.self || null;
+}
+
+
+function findFunctionByStack(apiRoot, targetFile, targetLine, visited = new WeakSet()) {
+	if (!apiRoot || visited.has(apiRoot)) return null;
+	visited.add(apiRoot);
+
+	
+	if (typeof apiRoot === "function" && apiRoot.__sourceFile && apiRoot.__sourceLine) {
+		if (apiRoot.__sourceFile === targetFile && apiRoot.__sourceLine === targetLine) {
+			return apiRoot;
+		}
+	}
+
+	
+	if (typeof apiRoot === "object" || typeof apiRoot === "function") {
+		const keys = Object.keys(apiRoot);
+		for (const key of keys) {
+			
+			if (key.startsWith("_") || ["hooks", "shutdown", "addApi", "describe", "run"].includes(key)) {
+				continue;
+			}
+
+			const result = findFunctionByStack(apiRoot[key], targetFile, targetLine, visited);
+			if (result) return result;
+		}
+	}
+
+	return null;
+}
+
+
+function findFunctionByPath(apiRoot, path) {
+	if (!path || typeof path !== "string") return null;
+
+	const parts = path.split(".");
+	let current = apiRoot;
+
+	for (const part of parts) {
+		if (!current || (typeof current !== "object" && typeof current !== "function")) {
+			if (process.env.SLOTHLET_DEBUG) {
+				console.log("[findFunctionByPath] Failed: current is", typeof current);
+			}
+			return null;
+		}
+		current = current[part];
+	}
+
+	const result = typeof current === "function" ? current : null;
+	if (process.env.SLOTHLET_DEBUG) {
+		console.log("[findFunctionByPath] Result:", result ? "function found" : "null");
+	}
+	return result;
+}
+
+
+function parseCallSite(cs) {
+	if (!cs) return null;
+
+	const fileName = cs.getFileName?.();
+	if (!fileName) return null;
+
+	
+	const filePath = toFsPath(fileName);
+	if (!filePath) return null;
+
+	
+	if (filePath.startsWith?.("node:internal")) return null;
+
+	const lineNum = cs.getLineNumber?.();
+	if (typeof lineNum !== "number") return null;
+
+	return { file: filePath, line: lineNum };
+}
+
+
+export const metadataAPI = {
+	
+	async caller() {
+		
+		await ensureRuntime();
+
+		
+		const apiRoot = getApiRoot();
+		if (!apiRoot || typeof apiRoot !== "object") return null;
+
+		
+		const stack = getStack(metadataAPI.caller);
+
+		
+		
+		
+		if (stack.length < 1) return null;
+
+		const parsed = parseCallSite(stack[0]);
+		if (!parsed) return null;
+
+		
+		const func = findFunctionByStack(apiRoot, parsed.file, parsed.line);
+		if (!func) return null;
+
+		
+		return func.__metadata || null;
+	},
+
+	
+	async self() {
+		
+		await ensureRuntime();
+
+		
+		const apiRoot = getApiRoot();
+		if (!apiRoot || typeof apiRoot !== "object") return null;
+
+		
+		const stack = getStack(metadataAPI.self);
+
+		
+		if (stack.length < 1) return null;
+
+		const parsed = parseCallSite(stack[0]);
+		if (!parsed) return null;
+
+		
+		const func = findFunctionByStack(apiRoot, parsed.file, parsed.line);
+		if (!func) return null;
+
+		
+		return func.__metadata || null;
+	},
+
+	
+	async get(path, apiRoot) {
+		
+		await ensureRuntime();
+
+		
+		const root = apiRoot || getApiRoot();
+		if (!root || (typeof root !== "object" && typeof root !== "function")) {
+			return null;
+		}
+
+		const func = findFunctionByPath(root, path);
+		if (!func) return null;
+
+		
+		return func.__metadata || null;
+	}
+};

package/dist/lib/helpers/multidefault.mjs

@@ -1,5 +1,5 @@
 /*
-	Copyright 2025 CLDMV/Shinrai
+	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.
@@ -39,10 +39,19 @@ async function multidefault_analyzeModules(moduleFiles, baseDir, options = {}) {
 		const moduleFilePath = path.resolve(baseDir, file.name);
 
 		
+		
 		let importUrl = `file://${moduleFilePath.replace(/\\/g, "/")}`;
+		const separator = importUrl.includes("?") ? "&" : "?";
+
+		
+		importUrl = `${importUrl}${separator}_t=${Date.now()}_${Math.random().toString(36).slice(2)}`;
+
+		
 		if (instance && instance.instanceId) {
-			const separator = importUrl.includes("?") ? "&" : "?";
-			importUrl = `${importUrl}${separator}slothlet_instance=${instance.instanceId}`;
+			const runtimeType = instance.config?.runtime || "async";
+			if (runtimeType === "live") {
+				importUrl = `${importUrl}&slothlet_instance=${instance.instanceId}`;
+			}
 		}
 
 		

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

@@ -1,5 +1,5 @@
 /*
-	Copyright 2025 CLDMV/Shinrai
+	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.

package/dist/lib/helpers/sanitize.mjs

@@ -1,5 +1,5 @@
 /*
-	Copyright 2025 CLDMV/Shinrai
+	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.

package/dist/lib/helpers/utilities.mjs

@@ -0,0 +1,121 @@
+/*
+	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.
+*/
+
+
+
+
+
+
+export function safeDefine(obj, key, value, enumerable = false, config = null) {
+	const desc = Object.getOwnPropertyDescriptor(obj, key);
+	if (!desc) {
+		Object.defineProperty(obj, key, {
+			value,
+			writable: true,
+			configurable: true,
+			enumerable
+		});
+	} else if (desc.configurable) {
+		Object.defineProperty(obj, key, {
+			value,
+			writable: true,
+			configurable: true,
+			enumerable
+		});
+	} else if (config && config.debug) {
+		console.warn(`Could not redefine boundApi.${key}: not configurable`);
+	}
+}
+
+
+export function deepMerge(target, source) {
+	if (!source || typeof source !== "object" || Array.isArray(source)) {
+		return source;
+	}
+
+	for (const key in source) {
+		if (!Object.prototype.hasOwnProperty.call(source, key)) {
+			continue;
+		}
+
+		
+		if (key === "__proto__" || key === "prototype" || key === "constructor") {
+			continue;
+		}
+
+		const sourceValue = source[key];
+		const targetValue = target[key];
+
+		if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue)) {
+			target[key] = deepMerge(
+				targetValue && typeof targetValue === "object" && !Array.isArray(targetValue) ? targetValue : {},
+				sourceValue
+			);
+		} else {
+			target[key] = sourceValue;
+		}
+	}
+
+	return target;
+}
+
+
+export function mutateLiveBindingFunction(target, source) {
+	if (typeof source === "function") {
+		target._impl = (...args) => source(...args);
+		
+		for (const key of Object.keys(target)) {
+			if (key !== "_impl" && key !== "__ctx") delete target[key];
+		}
+		
+		for (const key of Object.getOwnPropertyNames(source)) {
+			if (key !== "length" && key !== "name" && key !== "prototype" && key !== "_impl" && key !== "__ctx") {
+				try {
+					target[key] = source[key];
+				} catch {
+					
+				}
+			}
+		}
+	} else if (typeof source === "object" && source !== null) {
+		
+		for (const key of Object.keys(target)) {
+			if (key !== "_impl" && key !== "__ctx") delete target[key];
+		}
+		
+		for (const [key, value] of Object.entries(source)) {
+			if (key !== "__ctx") {
+				target[key] = value;
+			}
+		}
+		
+		const managementMethods = ["shutdown", "addApi", "describe"];
+		for (const method of managementMethods) {
+			const desc = Object.getOwnPropertyDescriptor(source, method);
+			if (desc) {
+				try {
+					Object.defineProperty(target, method, desc);
+				} catch {
+					
+				}
+			}
+		}
+		
+		if (typeof source._impl === "function") {
+			target._impl = source._impl;
+		}
+	}
+}

package/dist/lib/modes/slothlet_eager.mjs

@@ -1,5 +1,5 @@
 /*
-	Copyright 2025 CLDMV/Shinrai
+	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.

package/dist/lib/modes/slothlet_lazy.mjs

@@ -1,5 +1,5 @@
 /*
-	Copyright 2025 CLDMV/Shinrai
+	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.
@@ -345,6 +345,11 @@ function createFolderProxy({ subDirPath, key, parent, instance, depth, maxDepth,
 				return pathParts.length > 0 ? pathParts.join(".") : undefined;
 			}
 			
+			if (prop === "__metadata" || prop === "__sourceFolder") {
+				
+				return Reflect.get(_t, prop);
+			}
+			
 			if (materialized) {
 				if (materialized && (typeof materialized === "object" || typeof materialized === "function")) return materialized[prop];
 				return undefined;
@@ -485,6 +490,10 @@ function createFolderProxy({ subDirPath, key, parent, instance, depth, maxDepth,
 			if (prop === "__materialized") {
 				return { configurable: true, enumerable: false, writable: true, value: materialized };
 			}
+			
+			if (prop === "__metadata" || prop === "__sourceFolder") {
+				return Reflect.getOwnPropertyDescriptor(lazy_lazyTarget, prop);
+			}
 			if (prop === "prototype") {
 				
 				return Object.getOwnPropertyDescriptor(lazy_lazyTarget, "prototype");

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

@@ -1,5 +1,5 @@
 /*
-	Copyright 2025 CLDMV/Shinrai
+	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.
@@ -21,6 +21,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import util from "node:util";
 import { enableAlsForEventEmitters } from "@cldmv/slothlet/helpers/als-eventemitter";
+import { metadataAPI } from "@cldmv/slothlet/helpers/metadata-api";
 
 const als = new AsyncLocalStorage();
 
@@ -28,6 +29,9 @@ const als = new AsyncLocalStorage();
 export const sharedALS = new AsyncLocalStorage();
 
 
+export const requestALS = new AsyncLocalStorage();
+
+
 enableAlsForEventEmitters(als);
 
 
@@ -42,17 +46,21 @@ export const runWithCtx = (ctx, fn, thisArg, args) => {
 	}
 
 	
+	const requestContext = requestALS.getStore();
+	const mergedCtx = requestContext ? { ...ctx, context: { ...ctx.context, ...requestContext } } : ctx;
+
+	
 	const path = fn.__slothletPath;
 
 	
 	const runtime_runInALS = () => {
 		try {
 			
-			const beforeResult = ctx.hookManager.executeBeforeHooks(path, args);
+			const beforeResult = mergedCtx.hookManager.executeBeforeHooks(path, args);
 
 			
 			if (beforeResult.cancelled) {
-				ctx.hookManager.executeAlwaysHooks(path, beforeResult.value, []);
+				mergedCtx.hookManager.executeAlwaysHooks(path, beforeResult.value, []);
 				return beforeResult.value;
 			}
 
@@ -67,20 +75,20 @@ export const runWithCtx = (ctx, fn, thisArg, args) => {
 				return result.then(
 					(resolvedResult) => {
 						
-						const finalResult = ctx.hookManager.executeAfterHooks(path, resolvedResult);
-						ctx.hookManager.executeAlwaysHooks(path, finalResult, []);
+						const finalResult = mergedCtx.hookManager.executeAfterHooks(path, resolvedResult);
+						mergedCtx.hookManager.executeAlwaysHooks(path, finalResult, []);
 						return finalResult;
 					},
 					(error) => {
 						
-						if (!ctx.hookManager.reportedErrors.has(error)) {
-							ctx.hookManager.reportedErrors.add(error);
-							ctx.hookManager.executeErrorHooks(path, error, { type: "function" });
+						if (!mergedCtx.hookManager.reportedErrors.has(error)) {
+							mergedCtx.hookManager.reportedErrors.add(error);
+							mergedCtx.hookManager.executeErrorHooks(path, error, { type: "function" });
 						}
 						
-						ctx.hookManager.executeAlwaysHooks(path, undefined, [error]);
+						mergedCtx.hookManager.executeAlwaysHooks(path, undefined, [error]);
 						
-						if (!ctx.hookManager.suppressErrors) {
+						if (!mergedCtx.hookManager.suppressErrors) {
 							throw error;
 						}
 						return undefined; 
@@ -89,26 +97,26 @@ export const runWithCtx = (ctx, fn, thisArg, args) => {
 			}
 
 			
-			const finalResult = ctx.hookManager.executeAfterHooks(path, result);
-			ctx.hookManager.executeAlwaysHooks(path, finalResult, []);
+			const finalResult = mergedCtx.hookManager.executeAfterHooks(path, result);
+			mergedCtx.hookManager.executeAlwaysHooks(path, finalResult, []);
 			return finalResult;
 		} catch (error) {
 			
-			if (!ctx.hookManager.reportedErrors.has(error)) {
-				ctx.hookManager.reportedErrors.add(error);
-				ctx.hookManager.executeErrorHooks(path, error, { type: "function" });
+			if (!mergedCtx.hookManager.reportedErrors.has(error)) {
+				mergedCtx.hookManager.reportedErrors.add(error);
+				mergedCtx.hookManager.executeErrorHooks(path, error, { type: "function" });
 			}
 			
-			ctx.hookManager.executeAlwaysHooks(path, undefined, [error]);
+			mergedCtx.hookManager.executeAlwaysHooks(path, undefined, [error]);
 			
-			if (!ctx.hookManager.suppressErrors) {
+			if (!mergedCtx.hookManager.suppressErrors) {
 				throw error;
 			}
 			return undefined; 
 		}
 	};
 
-	return als.run(ctx, runtime_runInALS);
+	return als.run(mergedCtx, runtime_runInALS);
 };
 
 
@@ -477,6 +485,26 @@ function runtime_createLiveBinding(contextKey) {
 			
 
 			
+			if (contextKey === "context") {
+				const ctx = getCtx();
+				const baseContext = ctx?.context || {};
+				const requestContext = requestALS.getStore() || {};
+
+				
+				
+				const isDeepMerge = ctx?.config?.scope?.merge === "deep";
+
+				if (isDeepMerge && Object.keys(requestContext).length > 0) {
+					
+					return requestContext[prop];
+				}
+
+				
+				const merged = { ...baseContext, ...requestContext };
+				return merged[prop];
+			}
+
+			
 			runtime_syncWithContext();
 			return target[prop];
 		},
@@ -538,3 +566,6 @@ export const context = runtime_createLiveBinding("context");
 export const reference = runtime_createLiveBinding("reference");
 
 
+export { metadataAPI };
+
+

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

@@ -1,5 +1,5 @@
 /*
-	Copyright 2025 CLDMV/Shinrai
+	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.
@@ -18,12 +18,17 @@
 
 
 
+import { AsyncLocalStorage } from "node:async_hooks";
 import {
 	detectCurrentInstanceId,
 	getInstanceData,
 	setActiveInstance,
 	getCurrentActiveInstanceId
 } from "@cldmv/slothlet/helpers/instance-manager";
+import { metadataAPI } from "@cldmv/slothlet/helpers/metadata-api";
+
+
+export const requestALS = new AsyncLocalStorage();
 
 
 function getCurrentInstanceContext() {
@@ -122,10 +127,21 @@ export const context = new Proxy(
 	{
 		get(target, prop) {
 			const ctx = getCurrentInstanceContext();
-			if (ctx && ctx.context) {
-				return ctx.context[prop];
+			const baseContext = ctx?.context || {};
+			const requestContext = requestALS.getStore() || {};
+
+			
+			
+			const isDeepMerge = ctx?.config?.scope?.merge === "deep";
+
+			if (isDeepMerge && Object.keys(requestContext).length > 0) {
+				
+				return requestContext[prop];
 			}
-			return undefined;
+
+			
+			const merged = { ...baseContext, ...requestContext };
+			return merged[prop];
 		},
 
 		set(target, prop, value) {
@@ -418,3 +434,6 @@ export const contextManager = {
 	set: setContext,
 	runWithCtx
 };
+
+
+export { metadataAPI };

package/dist/lib/runtime/runtime.mjs

@@ -1,5 +1,5 @@
 /*
-	Copyright 2025 CLDMV/Shinrai
+	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.
@@ -18,11 +18,11 @@
 
 
 
-import { detectCurrentInstanceId, getInstanceData } from "../helpers/instance-manager.mjs";
+import { detectCurrentInstanceId, getInstanceData } from "@cldmv/slothlet/helpers/instance-manager";
 
 
-const asyncRuntime = await import("./runtime-asynclocalstorage.mjs");
-const liveBindingsRuntime = await import("./runtime-livebindings.mjs");
+const asyncRuntime = await import("@cldmv/slothlet/runtime/async");
+const liveBindingsRuntime = await import("@cldmv/slothlet/runtime/live");
 
 
 function detectRuntimeType() {
@@ -225,3 +225,14 @@ export const instanceId = (() => {
 })();
 
 export const sharedALS = getCurrentRuntime().sharedALS;
+
+
+export const metadataAPI = new Proxy(
+	{},
+	{
+		get(_, prop) {
+			const runtime = getCurrentRuntime();
+			return runtime.metadataAPI[prop];
+		}
+	}
+);