@cldmv/slothlet 1.0.1 → 2.0.1

package/dist/slothlet.mjs

@@ -0,0 +1,1092 @@
+/*
+	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 fs from "fs/promises";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+
+import { resolvePathFromCaller } from "@cldmv/slothlet/helpers/resolve-from-caller";
+import { sanitizePathName } from "@cldmv/slothlet/helpers/sanitize";
+
+
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+
+
+
+
+let DEBUG = process.argv.includes("--slothletdebug")
+	? true
+	: process.env.SLOTHLET_DEBUG === "1" || process.env.SLOTHLET_DEBUG === "true"
+		? true
+		: false;
+
+
+export let _slothlet = new URL(import.meta.url).searchParams.get("_slothlet") || "";
+
+
+
+
+
+export const self = {};
+
+
+export const context = {};
+
+
+export const reference = {};
+
+
+async function slothlet(options = {}) {
+	
+	const instance = createFreshInstance();
+
+	
+	for (const key of Object.keys(slothlet)) {
+		if (key.startsWith("_")) continue; 
+		
+		if (key === "name" || key === "length") continue;
+		try {
+			delete slothlet[key];
+		} catch {
+			
+		}
+	}
+
+	
+	for (const [k, v] of Object.entries(instance)) {
+		if (typeof v === "function") {
+			
+			Object.defineProperty(slothlet, k, { value: v.bind(instance), writable: false, enumerable: true, configurable: true });
+		} else {
+			
+			Object.defineProperty(slothlet, k, { value: instance[k], writable: true, enumerable: true, configurable: true });
+		}
+	}
+	Object.defineProperty(slothlet, "_instance", { value: instance, writable: false, enumerable: false, configurable: true });
+
+	
+	return await instance.create(options);
+}
+
+
+function createFreshInstance() {
+	const instance = {};
+	for (const [k, v] of Object.entries(slothletObject)) {
+		if (typeof v === "function") {
+			
+			instance[k] = v;
+			continue;
+		}
+		
+		if (k === "config") instance[k] = { ...v };
+		else if (k === "boundapi" || k === "context" || k === "reference") instance[k] = {};
+		else instance[k] = v;
+	}
+	return instance;
+}
+
+
+const slothletObject = {
+	
+	api: null,
+	self: {},
+	boundapi: {},
+	context: {},
+	reference: {},
+	mode: "singleton",
+	loaded: false,
+	config: { lazy: false, apiDepth: Infinity, debug: DEBUG, dir: null },
+	_dispose: null,
+	_boundAPIShutdown: null,
+
+	
+	async create(options = {}) {
+		if (this.loaded) {
+			console.warn("[slothlet] create: API already loaded, returning existing instance.");
+			return this.boundapi;
+		}
+
+		
+		if (!this.modes) {
+			this.modes = {};
+			const modesDir = path.join(__dirname, "lib", "modes");
+			
+			
+			const dirents = await fs.readdir(modesDir, { withFileTypes: true });
+			const modeFiles = dirents.filter((d) => d.isFile()).map((d) => path.join(modesDir, d.name));
+			
+			
+
+			for (const file of modeFiles) {
+				
+				
+				const modePath = file;
+
+				
+				
+				
+				
+
+				const modeName = path.parse(file).name.replace(/^slothlet_/, "");
+				if (!modeName || modeName.includes(" ")) continue;
+				try {
+					
+					const modeUrl = pathToFileURL(modePath).href;
+					
+					
+					
+					
+					const imported = await import(modeUrl);
+					if (imported && typeof imported === "object") {
+						this.modes[modeName] = imported.default || imported;
+					}
+				} catch (err) {
+					console.error(`[slothlet] Could not import mode '${modeName}':`, err);
+				}
+			}
+		}
+
+		
+		
+		const { entry = import.meta.url, mode = "singleton", api_mode = "auto" } = options ?? {};
+
+		_slothlet = new URL(import.meta.url).searchParams.get("_slothlet") || "";
+		
+
+		
+		
+		
+
+		this.mode = mode;
+		this.api_mode = api_mode;
+		let api;
+		let dispose;
+		if (mode === "singleton") {
+			const { context = null, reference = null, ...loadConfig } = options;
+			this.context = context;
+			this.reference = reference;
+
+			
+			
+			if (this.api_mode === "function") {
+				this.boundapi = function (...args) {
+					if (typeof this.boundapi._impl === "function") {
+						return this.boundapi._impl(...args);
+					}
+				}.bind(this);
+				this.boundapi._impl = () => {};
+			} else if (this.api_mode === "auto") {
+				
+				this.boundapi = {};
+			} else {
+				this.boundapi = {};
+			}
+
+			await this.load(loadConfig, { context, reference });
+
+			
+			
+			return this.boundapi;
+		} else {
+			const { createEngine } = await import("./lib/engine/slothlet_engine.mjs");
+			({ api, dispose } = await createEngine({ entry, ...options }));
+			
+			
+			if (typeof dispose === "function") {
+				Object.defineProperty(api, "__dispose__", {
+					value: dispose,
+					writable: false,
+					enumerable: false,
+					configurable: false
+				});
+			}
+			this._dispose = dispose;
+			this.loaded = true;
+			return api;
+		}
+	},
+
+	
+	async load(config = {}, ctxRef = { context: null, reference: null }) {
+		this.config = { ...this.config, ...config };
+		
+		
+		let apiDir = this.config.dir || "api";
+		
+		if (apiDir && !path.isAbsolute(apiDir)) {
+			
+			apiDir = resolvePathFromCaller(apiDir);
+			
+			
+			
+			
+		}
+
+		
+
+		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);
+		} else {
+			this.api = await this.modes.eager.create.call(this, apiDir, true, this.config.apiDepth || Infinity, 0);
+		}
+		if (this.config.debug) console.log(this.api);
+
+		
+		if (this.api_mode === "auto") {
+			this.api_mode = typeof this.api === "function" ? "function" : "object";
+			if (this.config.debug) {
+				console.log(`[DEBUG] Auto-detected api_mode: ${this.api_mode} (API is ${typeof this.api})`);
+			}
+
+			
+			if (this.api_mode === "function" && typeof this.boundapi !== "function") {
+				this.boundapi = function (...args) {
+					
+					if (typeof this.boundapi._impl === "function") {
+						return this.boundapi._impl(...args);
+					}
+				}.bind(this);
+				this.boundapi._impl = () => {};
+			} else if (this.api_mode === "object" && typeof this.boundapi === "function") {
+				this.boundapi = {};
+			}
+		}
+
+		
+
+		const l_ctxRef = { ...{ context: null, reference: null }, ...ctxRef };
+
+		
+		
+		
+		const _boundapi = this.createBoundApi(l_ctxRef.reference);
+
+		
+
+		mutateLiveBindingFunction(this.boundapi, _boundapi);
+
+		this.updateBindings(this.context, this.reference, this.boundapi);
+		
+		
+		
+		
+		
+		
+		
+		
+		this.loaded = true;
+
+		
+		
+
+		
+
+		
+		
+		
+		
+		
+
+		
+		
+
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+
+		return this.boundapi;
+	},
+
+	
+	_toApiKey(name) {
+		return sanitizePathName(name);
+		
+	},
+
+	
+	async _buildCategory(categoryPath, options = {}) {
+		const { currentDepth = 0, maxDepth = Infinity, mode = "eager", subdirHandler } = options;
+
+		
+		if (this.config.debug) {
+			console.log(`[DEBUG] _buildCategory called with path: ${categoryPath}, mode: ${mode}`);
+		}
+
+		const files = await fs.readdir(categoryPath, { withFileTypes: true });
+		const moduleFiles = files.filter((f) => this._shouldIncludeFile(f));
+		const categoryName = this._toApiKey(path.basename(categoryPath));
+		const subDirs = files.filter((e) => e.isDirectory() && !e.name.startsWith("."));
+
+		
+		if (moduleFiles.length === 1 && subDirs.length === 0) {
+			const moduleExt = path.extname(moduleFiles[0].name);
+			const moduleName = this._toApiKey(path.basename(moduleFiles[0].name, moduleExt));
+			const mod = await this._loadSingleModule(path.join(categoryPath, moduleFiles[0].name));
+
+			
+			const functionNameMatchesFolder = typeof mod === "function" && mod.name && mod.name.toLowerCase() === categoryName.toLowerCase();
+
+			
+			const functionNameMatchesFilename =
+				typeof mod === "function" &&
+				mod.name &&
+				this._toApiKey(mod.name).toLowerCase() === this._toApiKey(moduleName).toLowerCase() &&
+				mod.name !== this._toApiKey(moduleName);
+
+			
+			
+			
+			
+			
+			
+			
+
+			
+			if (moduleName === categoryName && typeof mod === "function") {
+				try {
+					Object.defineProperty(mod, "name", { value: categoryName, configurable: true });
+				} catch {
+					
+				}
+				return mod;
+			}
+
+			
+			if (functionNameMatchesFolder) {
+				try {
+					
+					Object.defineProperty(mod, "name", { value: mod.name, configurable: true });
+				} catch {
+					
+				}
+				return mod;
+			}
+
+			
+			if (functionNameMatchesFilename) {
+				
+				
+				
+				return { [mod.name]: mod };
+			}
+
+			
+			
+			if (
+				typeof mod === "function" &&
+				(!mod.name || mod.name === "default" || mod.__slothletDefault === true) 
+			) {
+				try {
+					Object.defineProperty(mod, "name", { value: categoryName, configurable: true });
+				} catch {
+					
+				}
+				return mod;
+			}
+			if (moduleName === categoryName && mod && typeof mod === "object" && !mod.default) {
+				return { ...mod };
+			}
+			return { [moduleName]: mod };
+		}
+
+		
+		const categoryModules = {};
+		for (const file of moduleFiles) {
+			const moduleExt = path.extname(file.name);
+			const moduleName = this._toApiKey(path.basename(file.name, moduleExt));
+
+			
+			
+			
+			
+
+			const mod = await this._loadSingleModule(path.join(categoryPath, file.name));
+			if (moduleName === categoryName && mod && typeof mod === "object") {
+				if (
+					Object.prototype.hasOwnProperty.call(mod, categoryName) &&
+					typeof mod[categoryName] === "object" &&
+					mod[categoryName] !== null
+				) {
+					Object.assign(categoryModules, mod[categoryName]);
+					for (const [key, value] of Object.entries(mod)) {
+						if (key !== categoryName) categoryModules[this._toApiKey(key)] = value;
+					}
+				} else {
+					Object.assign(categoryModules, mod);
+				}
+			} else if (typeof mod === "function") {
+				const fnName = mod.name && mod.name !== "default" ? mod.name : moduleName;
+				try {
+					Object.defineProperty(mod, "name", { value: fnName, configurable: true });
+				} catch {
+					
+				}
+
+				
+				
+				let apiKey;
+				if (fnName && fnName.toLowerCase() === moduleName.toLowerCase() && fnName !== moduleName) {
+					
+					apiKey = fnName;
+					if (this.config.debug) {
+						console.log(`[DEBUG] Using function name '${fnName}' instead of module name '${moduleName}'`);
+					}
+				} else {
+					
+					apiKey = this._toApiKey(fnName);
+					if (this.config.debug) {
+						console.log(`[DEBUG] Using sanitized key '${apiKey}' for function '${fnName}' (module: '${moduleName}')`);
+					}
+				}
+
+				categoryModules[apiKey] = mod;
+			} else {
+				
+				let hasPreferredName = false;
+				const modWithPreferredNames = {};
+
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+
+				for (const [exportName, exportValue] of Object.entries(mod)) {
+					if (
+						typeof exportValue === "function" &&
+						exportValue.name &&
+						this._toApiKey(exportValue.name).toLowerCase() === this._toApiKey(moduleName).toLowerCase() &&
+						exportValue.name !== this._toApiKey(moduleName)
+					) {
+						
+						modWithPreferredNames[exportValue.name] = exportValue;
+						hasPreferredName = true;
+						if (this.config.debug) {
+							console.log("[DEBUG] Using preferred name:", exportValue.name, "instead of:", this._toApiKey(moduleName));
+						}
+					} else {
+						modWithPreferredNames[this._toApiKey(exportName)] = exportValue;
+					}
+				}
+
+				if (hasPreferredName) {
+					Object.assign(categoryModules, modWithPreferredNames);
+					
+				} else {
+					categoryModules[this._toApiKey(moduleName)] = mod;
+					
+					
+					
+				}
+			}
+		}
+
+		
+		for (const subDirEntry of subDirs) {
+			if (currentDepth < maxDepth) {
+				const key = this._toApiKey(subDirEntry.name);
+				const subDirPath = path.join(categoryPath, subDirEntry.name);
+				let subModule;
+
+				if (mode === "lazy" && typeof subdirHandler === "function") {
+					subModule = subdirHandler({
+						subDirEntry,
+						subDirPath,
+						key,
+						categoryModules,
+						currentDepth,
+						maxDepth
+					});
+				} else {
+					subModule = await this._buildCategory(subDirPath, {
+						currentDepth: currentDepth + 1,
+						maxDepth,
+						mode: "eager"
+					});
+				}
+
+				
+				
+				if (
+					typeof subModule === "function" &&
+					subModule.name &&
+					subModule.name.toLowerCase() === key.toLowerCase() &&
+					subModule.name !== key
+				) {
+					
+					categoryModules[subModule.name] = subModule;
+				} else {
+					categoryModules[key] = subModule;
+				}
+			}
+		}
+
+		
+		const keys = Object.keys(categoryModules);
+		if (keys.length === 1) {
+			const singleKey = keys[0];
+			if (singleKey === categoryName) {
+				const single = categoryModules[singleKey];
+				if (typeof single === "function") {
+					if (single.name !== categoryName) {
+						try {
+							Object.defineProperty(single, "name", { value: categoryName, configurable: true });
+						} catch {
+							
+						}
+					}
+					return single;
+				} else if (single && typeof single === "object" && !Array.isArray(single)) {
+					return single;
+				}
+			}
+		}
+		return categoryModules;
+	},
+
+	
+	async _loadCategory(categoryPath, currentDepth = 0, maxDepth = Infinity) {
+		return this._buildCategory(categoryPath, { currentDepth, maxDepth, mode: "eager" });
+	},
+
+	
+	async _loadSingleModule(modulePath, rootLevel = false) {
+		const moduleUrl = pathToFileURL(modulePath).href;
+		
+		
+		
+		const module = await import(moduleUrl);
+
+		
+		
+
+		
+
+		
+		if (this.config.debug) console.log("module: ", module);
+		
+		if (typeof module.default === "function") {
+			let fn;
+			if (rootLevel) {
+				fn = module;
+			} else {
+				fn = module.default;
+				
+				try {
+					Object.defineProperty(fn, "__slothletDefault", { value: true, enumerable: false });
+				} catch {
+					
+				}
+
+				
+				
+				
+				
+				
+
+				for (const [exportName, exportValue] of Object.entries(module)) {
+					if (exportName !== "default") {
+						
+						
+						
+						
+						
+						fn[this._toApiKey(exportName)] = exportValue;
+						
+					}
+				}
+				if (this.config.debug) console.log("fn: ", fn);
+			}
+			return fn;
+		}
+
+		const moduleExports = Object.entries(module);
+		
+		if (!moduleExports.length) {
+			throw new Error(
+				`slothlet: No exports found in module '${modulePath}'. The file is empty or does not export any function/object/variable.`
+			);
+		}
+		if (this.config.debug) console.log("moduleExports: ", moduleExports);
+
+		
+		const defaultExportObj =
+			typeof module.default === "object" && module.default !== null
+				? module.default
+				: typeof moduleExports[0][1] === "object" && typeof moduleExports[0][1].default === "function" && moduleExports[0][1] !== null
+					? moduleExports[0][1]
+					: null;
+		let objectName = null;
+		if (typeof module.default === "function" && module.default.name) {
+			objectName = module.default.name;
+		} else if (moduleExports[0] && moduleExports[0][0] !== "default") {
+			objectName = moduleExports[0][0];
+		}
+		
+		
+
+		if (this.config.debug) console.log("defaultExportObj: ", defaultExportObj);
+		if (this.config.debug) console.log("objectName: ", objectName);
+
+		if (defaultExportObj && typeof defaultExportObj.default === "function") {
+			if (this.config.debug) console.log("DEFAULT FUNCTION FOUND FOR: ", module);
+			
+			const callableApi = {
+				[objectName]: function (...args) {
+					return defaultExportObj.default.apply(defaultExportObj, args);
+				}
+			}[objectName];
+			for (const [methodName, method] of Object.entries(defaultExportObj)) {
+				if (methodName === "default") continue;
+				callableApi[methodName] = method;
+			}
+			
+			
+			
+			
+			
+			if (this.config.debug) console.log("callableApi", callableApi);
+			return callableApi;
+		} else if (defaultExportObj) {
+			if (this.config.debug) console.log("DEFAULT FOUND FOR: ", module);
+
+			const obj = { ...defaultExportObj };
+
+			
+			
+			
+			
+			
+			
+			
+			
+			
+			
+
+			for (const [exportName, exportValue] of Object.entries(module)) {
+				if (exportName !== "default" && exportValue !== obj) {
+					
+					
+					
+					
+					
+					obj[exportName] = exportValue;
+				}
+			}
+
+			return obj;
+		}
+		
+		const namedExports = Object.entries(module).filter(([k]) => k !== "default");
+		if (this.config.debug) console.log("namedExports: ", namedExports);
+		if (namedExports.length === 1 && !module.default) {
+			if (typeof namedExports[0][1] === "object") {
+				
+				if (this.config.debug) console.log("namedExports[0][1] === object: ", namedExports[0][1]);
+				const obj = { ...namedExports[0][1] };
+
+				
+				
+				
+				
+				
+				
+				
+				
+
+				return obj;
+			}
+			if (typeof namedExports[0][1] === "function") {
+				if (this.config.debug) console.log("namedExports[0][1] === function: ", namedExports[0][1]);
+				
+				
+				return namedExports[0][1];
+			}
+		}
+		const apiExport = {};
+		for (const [exportName, exportValue] of namedExports) {
+			
+			
+			apiExport[exportName] = exportValue;
+		}
+		return apiExport;
+	},
+
+	
+	_shouldIncludeFile(entry) {
+		
+		if (!entry.isFile()) return false;
+		
+		if (!(entry.name.endsWith(".mjs") || entry.name.endsWith(".cjs") || entry.name.endsWith(".js"))) return false;
+		
+		if (entry.name.startsWith(".")) return false;
+		
+		if (entry.name.startsWith("__slothlet_")) return false;
+		return true;
+	},
+
+	
+	updateBoundApiProperty(key, materializedValue) {
+		if (this.boundapi && key) {
+			try {
+				
+				Object.defineProperty(this.boundapi, key, {
+					value: materializedValue,
+					writable: true,
+					enumerable: true,
+					configurable: true
+				});
+
+				
+				if (self && typeof self === "object") {
+					Object.defineProperty(self, key, {
+						value: materializedValue,
+						writable: true,
+						enumerable: true,
+						configurable: true
+					});
+				}
+
+				
+				
+				const currentApi = this.api;
+				if (currentApi && currentApi[key] === materializedValue) {
+					mutateLiveBindingFunction(this.boundapi, currentApi);
+				}
+
+				if (this.config.debug) {
+					console.log(`[DEBUG] Updated boundapi.${key} with materialized value`);
+					console.log(`[DEBUG] boundapi.${key} is now:`, typeof this.boundapi[key]);
+					console.log(`[DEBUG] boundapi.${key} keys:`, Object.keys(this.boundapi[key] || {}));
+				}
+			} catch (error) {
+				console.warn(`[slothlet] Failed to update boundapi.${key}:`, error.message);
+			}
+		}
+	},
+
+	
+	updateBindings(newContext = null, newReference = null, newSelf = null) {
+		if (newContext === null || (typeof newContext === "object" && Object.keys(newContext).length === 0)) newContext = { ...context };
+		if (newReference === null || (typeof newReference === "object" && Object.keys(newReference).length === 0))
+			newReference = { ...reference };
+		if (newSelf === null || (typeof newSelf === "object" && Object.keys(newSelf).length === 0)) newSelf = this.boundapi;
+		
+		
+		
+
+		mutateLiveBindingFunction(self, newSelf);
+		Object.assign(context, newContext || {});
+		Object.assign(reference, newReference || {});
+
+		this.safeDefine(this.boundapi, "__ctx", {
+			self: this.boundapi,
+			context: this.context,
+			reference: this.reference
+		});
+	},
+
+	
+	createBoundApi(ref = null) {
+		if (!this.api) throw new Error("BindleApi modules not loaded. Call load() first.");
+
+		
+		
+
+		let boundApi;
+		
+
+		boundApi = this.api;
+
+		
+		if (ref && typeof ref === "object") {
+			for (const [key, value] of Object.entries(ref)) {
+				if (!(key in boundApi)) {
+					try {
+						boundApi[key] = value;
+					} catch {
+						
+					}
+				}
+			}
+		}
+
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+
+		
+		
+
+		
+		
+		
+		this.safeDefine(boundApi, "describe", function (showAll = false) {
+			
+			if (this.config && this.config.lazy) {
+				if (!showAll) {
+					return Reflect.ownKeys(boundApi);
+				}
+				
+				async function resolveAll(obj) {
+					const keys = Reflect.ownKeys(obj);
+					const entries = await Promise.all(
+						keys.map(async (key) => {
+							const value = obj[key];
+							
+							if (typeof value === "function" && value.constructor.name === "Proxy") {
+								let resolved;
+								try {
+									resolved = await value();
+								} catch {
+									resolved = value;
+								}
+								
+								if (resolved && typeof resolved === "object" && !Array.isArray(resolved)) {
+									return [key, await resolveAll(resolved)];
+								}
+								return [key, resolved];
+							} else if (value && typeof value === "object" && !Array.isArray(value)) {
+								
+								return [key, await resolveAll(value)];
+							} else {
+								return [key, value];
+							}
+						})
+					);
+					const apiObj = {};
+					for (const [key, val] of entries) {
+						apiObj[key] = val;
+					}
+					return apiObj;
+				}
+				return resolveAll(boundApi);
+			}
+			
+			return { ...boundApi };
+		});
+
+		
+		if (
+			typeof boundApi.shutdown === "function" &&
+			boundApi.shutdown !== this.shutdown &&
+			boundApi.shutdown.name !== "bound get" &&
+			boundApi.shutdown.name !== "bound shutdown" &&
+			boundApi.shutdown.toString().indexOf("[native code]") === -1 &&
+			boundApi.shutdown.toString() !== this.shutdown.bind(this).toString()
+		) {
+			this._boundAPIShutdown = boundApi.shutdown; 
+		} else {
+			this._boundAPIShutdown = null;
+		}
+		const shutdownDesc = Object.getOwnPropertyDescriptor(boundApi, "shutdown");
+		if (!shutdownDesc || shutdownDesc.configurable) {
+			Object.defineProperty(boundApi, "shutdown", {
+				value: this.shutdown.bind(this),
+				writable: true,
+				configurable: true,
+				enumerable: true
+			});
+		} else if (this.config && this.config.debug) {
+			console.warn("Could not redefine boundApi.shutdown: not configurable");
+		}
+		
+
+		
+
+		
+		
+
+		return boundApi;
+	},
+
+	
+	safeDefine(obj, key, value) {
+		const desc = Object.getOwnPropertyDescriptor(obj, key);
+		if (!desc) {
+			Object.defineProperty(obj, key, {
+				value,
+				writable: true,
+				configurable: true,
+				enumerable: true
+			});
+		} else if (desc.configurable) {
+			Object.defineProperty(obj, key, {
+				value,
+				writable: true,
+				configurable: true,
+				enumerable: true
+			});
+		} else if (this.config && this.config.debug) {
+			console.warn(`Could not redefine boundApi.${key}: not configurable`);
+		}
+	},
+
+	
+	isLoaded() {
+		return this.loaded;
+	},
+
+	
+	getApi() {
+		return this.api;
+	},
+
+	
+	getBoundApi() {
+		return this.boundapi;
+	},
+
+	
+	async shutdown() {
+		
+		
+		if (this._shutdownInProgress) {
+			if (!this.loaded) return; 
+			console.warn("[slothlet] shutdown already in progress – ignoring nested call.");
+			return; 
+		}
+		this._shutdownInProgress = true;
+		try {
+			
+			if (this.loaded) {
+				const TIMEOUT_MS = 5000;
+				let apiError, internalError;
+				if (typeof this._boundAPIShutdown === "function") {
+					try {
+						await Promise.race([
+							this._boundAPIShutdown.call(this.boundapi),
+							new Promise((_, reject) => setTimeout(() => reject(new Error("API shutdown timeout")), TIMEOUT_MS))
+						]);
+					} catch (err) {
+						apiError = err;
+					}
+				}
+				
+				const disposeFn = this.boundapi && typeof this.boundapi.__dispose__ === "function" ? this.boundapi.__dispose__ : this._dispose;
+				if (typeof disposeFn === "function") {
+					try {
+						await disposeFn();
+					} catch (err) {
+						internalError = err;
+					}
+				}
+				this.loaded = false;
+				this.api = null;
+				this.boundapi = {};
+				this.context = {};
+				this.reference = {};
+				this._dispose = null;
+				this._boundAPIShutdown = null;
+				if (apiError || internalError) throw apiError || internalError;
+			}
+		} finally {
+			
+			this._shutdownInProgress = false;
+		}
+	}
+};
+
+
+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;
+			}
+		}
+		
+		if (typeof source._impl === "function") {
+			target._impl = source._impl;
+		}
+	}
+}
+
+export { slothlet };
+export default slothlet;
+
+
+
+
+
+