@cldmv/slothlet 2.10.0 → 3.0.0

package/dist/lib/handlers/unified-wrapper.mjs

@@ -0,0 +1,3031 @@
+/*
+	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.
+*/
+
+
+
+
+
+
+const ____COLLISION_MERGED_PROPERTY = Symbol("collisionMergedProperty");
+import util from "node:util";
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
+
+
+const ERROR_HOOK_PROCESSED = Symbol.for("@cldmv/slothlet/hook-error-processed");
+
+
+const hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+
+function unwrapError(error) {
+	
+	if (error && error.name === "SlothletError" && error.originalError) {
+		return error.originalError;
+	}
+	return error;
+}
+
+const wrapperDebugEnabled =
+	process.env.SLOTHLET_DEBUG_WRAPPER === "1" ||
+	process.env.SLOTHLET_DEBUG_WRAPPER === "true" ||
+	process.env.SLOTHLET_DEBUG_SCRIPT_VERBOSE === "1" ||
+	process.env.SLOTHLET_DEBUG_SCRIPT_VERBOSE === "true";
+
+
+export const TYPE_STATES = {
+	UNMATERIALIZED: Symbol("unmaterialized"),
+	IN_FLIGHT: Symbol("inFlight")
+};
+
+
+function getSafeFunctionName(apiPath, fallback) {
+	const parts = String(apiPath || "")
+		.split(".")
+		.filter((part) => part && part !== "null");
+	const baseName = parts.length > 0 ? parts[parts.length - 1] : "";
+	let safeName = String(baseName || "").replace(/[^A-Za-z0-9_$]/g, "_");
+	if (!safeName || !/^[A-Za-z_$]/.test(safeName[0])) {
+		safeName = safeName ? `_${safeName}` : "";
+	}
+	return safeName || fallback;
+}
+
+
+function createNamedProxyTarget(nameHint, fallback) {
+	const safeName = getSafeFunctionName(nameHint, fallback);
+	return { [safeName]: function () {} }[safeName];
+}
+
+
+const _proxyRegistry = new WeakMap();
+
+
+export class UnifiedWrapper extends ComponentBase {
+	
+	#internal = null;
+
+	
+	get ____slothletInternal() {
+		if (!(#internal in this)) return undefined;
+		return this.#internal;
+	}
+
+	
+	constructor(
+		slothlet,
+		{
+			mode,
+			apiPath,
+			initialImpl = null,
+			materializeFunc = null,
+			isCallable,
+			materializeOnCreate = false,
+			filePath = null,
+			moduleID = null,
+			sourceFolder = null
+		}
+	) {
+		super(slothlet);
+
+		
+		
+		
+		const isCallableExplicit = typeof isCallable === "boolean";
+		const isCallableValue = isCallableExplicit
+			? isCallable
+			: typeof initialImpl === "function" || (initialImpl && typeof initialImpl.default === "function");
+		
+		
+		
+		const isCallableLocked = isCallableValue || isCallableExplicit;
+
+		const internal = Object.create(null);
+		internal.id = Math.random().toString(36).substr(2, 9); 
+		internal.mode = mode;
+		internal.apiPath = apiPath;
+		internal.materializeOnCreate = materializeOnCreate;
+		internal.isCallable = isCallableValue;
+		internal.isCallableLocked = isCallableLocked;
+		internal.moduleID = moduleID;
+		internal.filePath = filePath;
+		internal.sourceFolder = sourceFolder;
+		internal.invalid = false;
+		internal.state = {
+			materialized: initialImpl !== null,
+			inFlight: false,
+			collisionMode: "merge"
+		};
+		internal.displayName = apiPath ? `${String(apiPath).replace(/\./g, "__")}__UnifiedWrapper` : "UnifiedWrapper";
+		
+		
+		
+		
+
+		
+		this.#internal = internal;
+
+		
+		const wrapper = this;
+		Object.defineProperty(internal, "wrapper", {
+			
+			
+			get() {
+				return wrapper;
+			},
+			
+			enumerable: false,
+			configurable: false
+		});
+
+		
+		
+		internal.callableImpl = null;
+
+		internal.waitingProxyCache = new Map(); 
+		internal.proxy = null;
+
+		
+		
+		internal.impl = UnifiedWrapper._cloneImpl(initialImpl);
+
+		internal.materializeFunc = materializeFunc;
+
+		
+		if (filePath && slothlet.handlers?.lifecycle) {
+			slothlet.handlers.lifecycle.emit("impl:created", {
+				apiPath,
+				impl: this,
+				
+				
+				
+				
+				wrapper: Object.freeze({ __impl: this.____slothletInternal.impl }),
+				source: "initial",
+				moduleID,
+				filePath,
+				
+				
+				sourceFolder: sourceFolder || slothlet.config?.dir
+			});
+		}
+
+		
+		if (initialImpl !== null && filePath && slothlet.handlers?.lifecycle) {
+			slothlet.handlers.lifecycle.emit("impl:created", {
+				apiPath,
+				impl: initialImpl,
+				wrapper: Object.freeze({ __impl: this.____slothletInternal.impl }),
+				source: "initial",
+				moduleID,
+				filePath,
+				
+				
+				sourceFolder: sourceFolder || slothlet.config?.dir
+			});
+		}
+
+		if (initialImpl !== null) {
+			const implKeys = Object.keys(initialImpl || {});
+			if ((wrapperDebugEnabled || this.____config?.debug?.wrapper) && apiPath && (apiPath === "config" || apiPath.startsWith("config."))) {
+				this.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_WRAPPER_CONSTRUCTOR_IMPL_KEYS",
+					apiPath,
+					keyCount: implKeys.length,
+					keySample: implKeys.slice(0, 5)
+				});
+			}
+			this.___adoptImplChildren();
+			if ((wrapperDebugEnabled || this.____config?.debug?.wrapper) && apiPath && (apiPath === "config" || apiPath.startsWith("config."))) {
+				const childKeys = Object.keys(this).filter((k) => !k.startsWith("_") && !k.startsWith("__"));
+				this.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_WRAPPER_CONSTRUCTOR_AFTER_ADOPT",
+					apiPath,
+					childCount: childKeys.length,
+					childKeySample: childKeys.slice(0, 5)
+				});
+			}
+		}
+
+		
+		if (mode === "lazy") {
+			slothlet._registerLazyWrapper();
+
+			
+			if (slothlet.config.tracking?.materialization) {
+				
+				
+				setImmediate(() => {
+					this._materialize().catch((err) => {
+						
+						
+						
+						
+						if (slothlet.config?.debug?.materialize) {
+							slothlet.debug("materialize", {
+								key: "DEBUG_MODE_BACKGROUND_MATERIALIZE_ERROR",
+								apiPath: this.____slothletInternal?.apiPath,
+								error: err.message
+							});
+						}
+					});
+				});
+			}
+		}
+	}
+
+	
+	[util.inspect.custom](____depth, ____options, ____inspect) {
+		
+		
+		
+		
+		const w = _proxyRegistry.get(this) ?? this;
+		
+		const childKeys = Object.keys(w).filter((k) => !k.startsWith("_") && !k.startsWith("__"));
+		if (childKeys.length > 0 && !w.____slothletInternal?.isCallable) {
+			const inspectObj = {};
+			for (const key of childKeys) {
+				
+				inspectObj[key] = w[key];
+			}
+			return inspectObj;
+		}
+
+		
+		
+		if (
+			w.____slothletInternal?.mode === "lazy" &&
+			w.____slothletInternal?.state &&
+			!w.____slothletInternal?.state.materialized &&
+			w.____slothletInternal?.proxy
+		) {
+			return w.____slothletInternal.proxy;
+		}
+		return w.____slothletInternal?.impl;
+	}
+
+	
+	get __impl() {
+		return this.____slothletInternal.impl;
+	}
+
+	
+	static _cloneImpl(value) {
+		if (value && typeof value === "object" && !Array.isArray(value) && typeof value !== "function") {
+			const isProxy = util.types.isProxy(value);
+			if (isProxy) {
+				
+				
+				
+				
+				
+				
+				
+				
+				if (resolveWrapper(value)) {
+					const clone = {};
+					for (const key of Reflect.ownKeys(value)) {
+						try {
+							clone[key] = value[key];
+						} catch {
+							
+						}
+					}
+					return clone;
+				}
+				
+				return value;
+			}
+			const uw_cloneDescriptors = Object.getOwnPropertyDescriptors(value);
+			return Object.create(Object.getPrototypeOf(value), uw_cloneDescriptors);
+		}
+		return value;
+	}
+
+	
+	static _extractFullImpl(wrapper) {
+		if (!wrapper) return null;
+
+		const impl = wrapper.____slothletInternal.impl;
+
+		
+		if (impl === null || impl === undefined) return impl;
+		if (typeof impl !== "object" && typeof impl !== "function") return impl;
+
+		
+		if (typeof impl === "function") return impl;
+
+		
+		const extractFullImpl_result = {};
+
+		
+		for (const key of Object.keys(impl)) {
+			
+			
+			if (key.startsWith("__")) continue; 
+			extractFullImpl_result[key] = impl[key];
+		}
+
+		
+		
+		
+		
+		
+		if (impl.__childFilePaths) {
+			extractFullImpl_result.__childFilePaths = impl.__childFilePaths;
+		}
+		
+		
+		
+		
+		if (impl.__childFilePathsPreMaterialize) {
+			extractFullImpl_result.__childFilePathsPreMaterialize = impl.__childFilePathsPreMaterialize;
+		}
+
+		
+		
+		for (const key of Object.keys(wrapper)) {
+			
+			
+			if (UnifiedWrapper.INTERNAL_KEYS.has(key)) continue;
+			if (key in extractFullImpl_result) continue; 
+
+			const extractFullImpl_child = wrapper[key];
+			const _extractChildW = resolveWrapper(extractFullImpl_child);
+			if (_extractChildW) {
+				
+				extractFullImpl_result[key] = UnifiedWrapper._extractFullImpl(_extractChildW);
+			} else {
+				extractFullImpl_result[key] = extractFullImpl_child;
+			}
+		}
+
+		return extractFullImpl_result;
+	}
+
+	
+	_applyNewImpl(newImpl, forceReuseChildren = false) {
+		
+		
+		this.____slothletInternal.impl = UnifiedWrapper._cloneImpl(newImpl);
+		this.____slothletInternal.invalid = false;
+
+		
+		
+		
+		if (
+			!this.____slothletInternal.isCallableLocked &&
+			!this.____slothletInternal.isCallable &&
+			(typeof newImpl === "function" || (newImpl && typeof newImpl.default === "function"))
+		) {
+			this.____slothletInternal.isCallable = true;
+			this.____slothletInternal.isCallableLocked = true;
+		}
+
+		
+		
+		
+		
+		
+		if (!this.____slothletInternal.filePath && this.____slothletInternal.impl && this.____slothletInternal.impl.__filePath) {
+			this.____slothletInternal.filePath = this.____slothletInternal.impl.__filePath;
+			this.slothlet.debug("wrapper", {
+				key: "DEBUG_MODE_APPLY_IMPL_UPDATE_PATH",
+				apiPath: this.____slothletInternal.apiPath,
+				filePath: this.____slothletInternal.filePath
+			});
+		}
+
+		this.___adoptImplChildren(forceReuseChildren);
+	}
+
+	
+	___setImpl(newImpl, moduleID = null, forceReuseChildren = false) {
+		
+		
+		if ((wrapperDebugEnabled || this.____config?.debug?.wrapper) && this.____slothletInternal.apiPath === "string") {
+			this.slothlet.debug("wrapper", {
+				key: "DEBUG_MODE_SETIMPL_CALLED",
+				apiPath: this.____slothletInternal.apiPath,
+				
+				
+				newImplKeys: Object.keys(newImpl || {})
+			});
+		}
+		
+
+		this._applyNewImpl(newImpl, forceReuseChildren);
+
+		
+		if (newImpl && this.slothlet.handlers?.lifecycle) {
+			const wrapperMetadata = this.slothlet.handlers.metadata.getMetadata(this);
+			
+			let extractedModuleId = moduleID || (wrapperMetadata?.moduleID ? wrapperMetadata.moduleID.split(":")[0] : null);
+
+			
+			
+			if (extractedModuleId && typeof extractedModuleId !== "string") {
+				extractedModuleId = extractedModuleId.moduleID || extractedModuleId.__moduleID || String(extractedModuleId);
+			}
+
+			this.slothlet.handlers.lifecycle.emit("impl:changed", {
+				apiPath: this.____slothletInternal.apiPath,
+				impl: newImpl,
+				wrapper: Object.freeze({ __impl: this.____slothletInternal.impl }),
+				source: "hot-reload",
+				moduleID: extractedModuleId,
+				filePath: wrapperMetadata?.filePath,
+				sourceFolder: wrapperMetadata?.sourceFolder
+			});
+		}
+
+		this.____slothletInternal.state.materialized = true;
+		this.____slothletInternal.state.inFlight = false;
+
+		
+		
+		
+		if (this.slothlet._onWrapperMaterialized) {
+			this.slothlet._onWrapperMaterialized();
+		}
+	}
+
+	
+	___resetLazy(newMaterializeFunc) {
+		this.slothlet.debug("wrapper", {
+			key: "DEBUG_MODE_RESETLAZY_CALLED",
+			apiPath: this.____slothletInternal.apiPath,
+			hadImpl: this.____slothletInternal.impl !== null,
+			hadChildren: Object.keys(this).filter((k) => !k.startsWith("_") && !k.startsWith("__")).length
+		});
+
+		
+		for (const key of Reflect.ownKeys(this)) {
+			
+			
+			if (typeof key === "string" && (key.startsWith("_") || key.startsWith("__"))) {
+				continue;
+			}
+			const child = this[key];
+			const childRaw = resolveWrapper(child);
+			if (childRaw) {
+				childRaw.___invalidate();
+			}
+			const descriptor = Object.getOwnPropertyDescriptor(this, key);
+			
+			
+			if (descriptor?.configurable) {
+				delete this[key];
+			}
+		}
+
+		
+		this.____slothletInternal.impl = null;
+		this.____slothletInternal.invalid = false;
+		this.____slothletInternal.state.materialized = false;
+		this.____slothletInternal.state.inFlight = false;
+
+		
+		this.____slothletInternal.materializationPromise = null;
+
+		
+		this.____slothletInternal.materializeFunc = newMaterializeFunc;
+
+		
+		
+		
+		if (this.____slothletInternal.waitingProxyCache) {
+			this.____slothletInternal.waitingProxyCache.clear();
+		}
+
+		this.slothlet.debug("wrapper", {
+			key: "DEBUG_MODE_RESETLAZY_COMPLETE",
+			apiPath: this.____slothletInternal.apiPath
+		});
+	}
+
+	
+	async ___materialize() {
+		
+		if (this.____slothletInternal.state.materialized) {
+			return;
+		}
+
+		
+		
+		if (this.____slothletInternal.invalid) {
+			return;
+		}
+
+		
+		
+		if (this.____slothletInternal.materializationPromise) {
+			this.slothlet.debug("wrapper", {
+				key: "DEBUG_MODE_MATERIALIZE_AWAIT",
+				apiPath: this.____slothletInternal.apiPath
+			});
+			return this.____slothletInternal.materializationPromise;
+		}
+
+		
+		
+		if ((wrapperDebugEnabled || this.____config?.debug?.wrapper) && this.apiPath === "string") {
+			this.slothlet.debug("wrapper", {
+				key: "DEBUG_MODE_MATERIALIZE_START",
+				apiPath: this.apiPath
+			});
+		}
+
+		
+		this.____slothletInternal.materializationPromise = (async () => {
+			this.____slothletInternal.state.inFlight = true;
+
+			try {
+				if (this.____slothletInternal.materializeFunc) {
+					if ((wrapperDebugEnabled || this.____config?.debug?.wrapper) && this.____slothletInternal.apiPath === "string") {
+						this.slothlet.debug("wrapper", {
+							key: "DEBUG_MODE_MATERIALIZE_CALLING_FUNC",
+							apiPath: this.____slothletInternal.apiPath
+						});
+					}
+					
+					
+					const lazy_setImpl = (value) => {
+						this._applyNewImpl(value);
+					};
+					const result = await this.____slothletInternal.materializeFunc(lazy_setImpl);
+
+					
+					if (!this.____slothletInternal.impl) {
+						this._applyNewImpl(result);
+					}
+
+					this.____slothletInternal.state.materialized = true;
+
+					
+					
+					
+					if (this.slothlet._onWrapperMaterialized) {
+						this.slothlet._onWrapperMaterialized();
+					}
+
+					if ((wrapperDebugEnabled || this.____config?.debug?.wrapper) && this.____slothletInternal.apiPath === "string") {
+						this.slothlet.debug("wrapper", {
+							key: "DEBUG_MODE_MATERIALIZE_COMPLETE",
+							apiPath: this.____slothletInternal.apiPath,
+							resultType: typeof result,
+							
+							
+							resultKeys: Object.keys(result || {})
+						});
+					}
+				}
+			} catch (error) {
+				
+				
+				if ((wrapperDebugEnabled || this.____config?.debug?.wrapper) && this.____slothletInternal.apiPath === "string") {
+					this.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_MATERIALIZE_ERROR",
+						apiPath: this.____slothletInternal.apiPath,
+						error: error.message
+					});
+				}
+				throw error;
+			} finally {
+				
+				this.____slothletInternal.state.inFlight = false;
+				this.____slothletInternal.materializationPromise = null;
+			}
+		})();
+
+		
+		return this.____slothletInternal.materializationPromise;
+	}
+
+	
+	_materialize() {
+		return this.___materialize();
+	}
+
+	
+	___invalidate() {
+		this.____slothletInternal.invalid = true;
+		this.____slothletInternal.impl = null;
+		
+		for (const key of Reflect.ownKeys(this)) {
+			
+			
+			if (typeof key === "string" && (key.startsWith("_") || key.startsWith("__"))) {
+				continue;
+			}
+			const descriptor = Object.getOwnPropertyDescriptor(this, key);
+			
+			
+			if (descriptor?.configurable) {
+				delete this[key];
+			}
+		}
+	}
+
+	
+	___adoptImplChildren(forceReuseChildren = false) {
+		const preExistingKeys = Object.keys(this).filter((k) => !k.startsWith("_") && !k.startsWith("__"));
+		this.slothlet.debug("wrapper", {
+			key: "DEBUG_MODE_ADOPT_START",
+			apiPath: this.____slothletInternal.apiPath,
+			
+			
+			wrapperId: this.____slothletInternal.id || "no-id",
+			preExistingKeys: preExistingKeys.join(","),
+			collisionMode: this.____slothletInternal.state.collisionMode
+		});
+
+		if (
+			!this.____slothletInternal.impl ||
+			(typeof this.____slothletInternal.impl !== "object" && typeof this.____slothletInternal.impl !== "function")
+		) {
+			return;
+		}
+
+		const ownKeys = Reflect.ownKeys(this.____slothletInternal.impl);
+
+		const internalKeys = new Set([
+			"__impl",
+			"___setImpl",
+			"___resetLazy",
+			"_materialize",
+			"_impl",
+			"_state",
+			"_invalid",
+			"____slothlet",
+			"____slothletInternal"
+		]);
+		const keepImplProperties =
+			typeof this.____slothletInternal.impl === "function" ||
+			(this.____slothletInternal.impl &&
+				typeof this.____slothletInternal.impl === "object" &&
+				typeof this.____slothletInternal.impl.default === "function");
+		if (
+			keepImplProperties &&
+			this.____slothletInternal.impl &&
+			typeof this.____slothletInternal.impl === "object" &&
+			typeof this.____slothletInternal.impl.default === "function"
+		) {
+			internalKeys.add("default");
+		}
+		const observedKeys = new Set();
+
+		
+		
+		
+		const existingKeys = Object.keys(this).filter((k) => !k.startsWith("_") && !k.startsWith("__"));
+		const storedCollisionMode = this.____slothletInternal.state.collisionMode; 
+		const isMergeScenario = storedCollisionMode !== "replace" && existingKeys.length > 0;
+
+		this.slothlet.debug("wrapper", {
+			key: "DEBUG_MODE_ADOPT",
+			apiPath: this.____slothletInternal.apiPath,
+			mode: this.____slothletInternal.mode,
+			storedCollisionMode,
+			existingKeys: existingKeys.join(","),
+			isMergeScenario
+		});
+
+		
+		
+		
+		const savedChildren = new Map();
+		if (storedCollisionMode === "replace" && existingKeys.length > 0) {
+			this.slothlet.debug("wrapper", {
+				key: "DEBUG_MODE_ADOPT_REPLACE_CLEARING",
+				count: existingKeys.length
+			});
+
+			for (const key of existingKeys) {
+				const child = this[key];
+				if (resolveWrapper(child) !== null) {
+					savedChildren.set(key, child);
+				}
+				const descriptor = Object.getOwnPropertyDescriptor(this, key);
+				if (descriptor?.configurable) {
+					delete this[key];
+				}
+			}
+			
+		} else {
+			
+			for (const key of existingKeys) {
+				observedKeys.add(key);
+			}
+		}
+
+		
+		const metadataKeys = new Set(["__childFilePaths", "__filePath", "__childFilePathsPreMaterialize"]);
+		const skipKeys = typeof this.____slothletInternal.impl === "function" ? new Set(["length", "name", "prototype"]) : null;
+		
+		const builtinKeys = new Set(["slothlet", "shutdown", "destroy"]);
+
+		for (const key of ownKeys) {
+			if (internalKeys.has(key)) {
+				continue;
+			}
+			
+			if (typeof key === "string" && metadataKeys.has(key)) {
+				continue;
+			}
+			
+			if (typeof key === "string" && builtinKeys.has(key)) {
+				continue;
+			}
+			if (skipKeys && typeof key === "string" && skipKeys.has(key)) {
+				continue;
+			}
+			
+			
+			
+			if (
+				!this.____slothletInternal.impl ||
+				(typeof this.____slothletInternal.impl !== "object" && typeof this.____slothletInternal.impl !== "function")
+			) {
+				break;
+			}
+			
+			const descriptor = Object.getOwnPropertyDescriptor(this.____slothletInternal.impl, key);
+			
+			
+			if (!descriptor) {
+				continue;
+			}
+			
+			const value = this.____slothletInternal.impl[key];
+			
+			
+			if (value === this.____slothletInternal.impl) {
+				continue;
+			}
+			
+			
+			
+			
+			if (typeof key !== "symbol") {
+				this.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_ADOPT_PROCESS",
+					apiPath: this.____slothletInternal.apiPath,
+					propKey: key,
+					typeOf: typeof value,
+					valueName: value?.name
+				});
+			}
+			observedKeys.add(key);
+
+			
+			
+			if (hasOwn(this, key) && !key.toString().startsWith("_")) {
+				
+				
+				
+				
+				if (typeof key !== "symbol") {
+					this.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_ADOPT_CHECK",
+						apiPath: this.____slothletInternal.apiPath,
+						propKey: key,
+						has__collisionMergedKeys: !!this.____slothletInternal.collisionMergedKeys,
+						inSet: this.____slothletInternal.collisionMergedKeys?.has(key)
+					});
+				}
+				const isCollisionMerged = this.____slothletInternal.collisionMergedKeys && this.____slothletInternal.collisionMergedKeys.has(key);
+
+				if (isCollisionMerged && !forceReuseChildren) {
+					
+					
+					
+					
+					
+					
+					if (typeof key !== "symbol") {
+						this.slothlet.debug("wrapper", {
+							key: "DEBUG_MODE_ADOPT_SKIP_COLLISION_MERGED",
+							apiPath: this.____slothletInternal.apiPath,
+							propKey: key
+						});
+					}
+					
+					
+					if (descriptor.configurable) {
+						delete this.____slothletInternal.impl[key];
+					}
+					continue;
+				}
+				
+				
+				
+				
+				
+				if (typeof key !== "symbol") {
+					this.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_ADOPT_ALLOW_NOT_COLLISION_MERGED",
+						apiPath: this.____slothletInternal.apiPath,
+						propKey: key
+					});
+				}
+			}
+
+			
+			
+			
+			
+			
+			
+			
+			const existingChild = savedChildren.get(key) || this[key];
+			let wrapped;
+
+			
+			
+			
+			
+			const skipChildReuse = !forceReuseChildren && this.____slothletInternal.mode === "lazy" && storedCollisionMode === "replace";
+
+			if (!skipChildReuse && existingChild && resolveWrapper(existingChild) !== null) {
+				
+				
+				
+				if (resolveWrapper(value) !== null) {
+					
+					const newWrapper = resolveWrapper(value);
+					
+					
+					let rawImpl = newWrapper ? newWrapper.____slothletInternal.impl : null;
+
+					
+					
+					
+					
+					if (
+						rawImpl &&
+						typeof rawImpl === "object" &&
+						!Array.isArray(rawImpl) &&
+						typeof rawImpl !== "function" &&
+						Object.keys(rawImpl).filter((k) => !k.startsWith("__")).length === 0
+					) {
+						const wrapperOwnKeys = Object.keys(newWrapper).filter((k) => !k.startsWith("_") && !k.startsWith("__"));
+						
+						
+						if (wrapperOwnKeys.length > 0) {
+							rawImpl = UnifiedWrapper._extractFullImpl(newWrapper);
+						}
+					}
+
+					
+					
+					if (rawImpl !== null && rawImpl !== undefined) {
+						resolveWrapper(existingChild).___setImpl(
+							rawImpl,
+							this.slothlet,
+							this.____slothletInternal.moduleID,
+							this.____slothletInternal.filePath
+						);
+					} else if (newWrapper && newWrapper.____slothletInternal.materializeFunc) {
+						
+						
+						
+						const existingChildWrapper = resolveWrapper(existingChild);
+						
+						
+						if (existingChildWrapper) {
+							existingChildWrapper.___resetLazy(newWrapper.____slothletInternal.materializeFunc);
+						}
+					}
+					
+					wrapped = existingChild;
+				} else {
+					resolveWrapper(existingChild).___setImpl(
+						value,
+						this.slothlet,
+						this.____slothletInternal.moduleID,
+						this.____slothletInternal.filePath
+					);
+					wrapped = existingChild;
+				}
+				
+				
+				if (typeof key !== "symbol") {
+					this.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_ADOPT_REUSE_CHILD_WRAPPER",
+						apiPath: this.____slothletInternal.apiPath,
+						propKey: key
+					});
+				}
+			} else {
+				
+				wrapped = this.___createChildWrapper(key, value);
+				
+				
+				if (typeof key !== "symbol") {
+					this.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_ADOPT_WRAP",
+						apiPath: this.____slothletInternal.apiPath,
+						propKey: key,
+						wrapped: wrapped ? "YES" : wrapped === null ? "NULL" : "NO"
+					});
+				}
+			}
+
+			if (wrapped) {
+				
+				
+				const existing = this[key];
+				const existingDescriptor = Object.getOwnPropertyDescriptor(this, key);
+
+				
+				
+				
+				if (existing === wrapped || (existingDescriptor && !existingDescriptor.configurable)) {
+					
+					
+					if (typeof key !== "symbol") {
+						this.slothlet.debug("wrapper", {
+							key:
+								existingDescriptor && !existingDescriptor.configurable
+									? "DEBUG_MODE_ADOPT_SKIP_NON_CONFIGURABLE"
+									: "DEBUG_MODE_ADOPT_SKIP_SAME_WRAPPER",
+							apiPath: this.____slothletInternal.apiPath,
+							propKey: key
+						});
+					}
+				} else {
+					
+					
+					if (typeof key !== "symbol") {
+						this.slothlet.debug("wrapper", {
+							key: "DEBUG_MODE_ADOPT_DEFINE",
+							apiPath: this.____slothletInternal.apiPath,
+							propKey: key
+						});
+					}
+					Object.defineProperty(this, key, {
+						value: wrapped,
+						writable: false,
+						enumerable: true,
+						configurable: true
+					});
+					
+					
+					if (typeof key !== "symbol") {
+						this.slothlet.debug("wrapper", {
+							key: "DEBUG_MODE_ADOPT_DEFINED",
+							apiPath: this.____slothletInternal.apiPath,
+							propKey: key
+						});
+					}
+				}
+				
+				
+				if (descriptor.configurable && !keepImplProperties && this.____slothletInternal.impl) {
+					delete this.____slothletInternal.impl[key];
+				}
+			} else if (wrapped === null) {
+				
+				Object.defineProperty(this, key, {
+					value: value,
+					writable: false,
+					enumerable: true,
+					configurable: true
+				});
+				
+				
+				if (descriptor.configurable && !keepImplProperties && this.____slothletInternal.impl) {
+					delete this.____slothletInternal.impl[key];
+				}
+			} else {
+				
+				Object.defineProperty(this, key, {
+					value: value,
+					writable: false,
+					enumerable: true,
+					configurable: true
+				});
+				
+				
+				if (descriptor.configurable && !keepImplProperties && this.____slothletInternal.impl) {
+					delete this.____slothletInternal.impl[key];
+				}
+			}
+		}
+
+		
+		
+		if (!isMergeScenario) {
+			const currentKeys = Object.keys(this).filter((k) => !k.startsWith("_") && !k.startsWith("__"));
+			for (const key of currentKeys) {
+				if (!observedKeys.has(key)) {
+					const existing = this[key];
+					const existingRaw = resolveWrapper(existing);
+					
+					
+					if (existingRaw) {
+						existingRaw.___invalidate();
+					}
+					const descriptor = Object.getOwnPropertyDescriptor(this, key);
+					
+					
+					
+					
+					
+					
+					if (descriptor?.configurable) {
+						delete this[key];
+					}
+				}
+			}
+		}
+
+		
+		if (this._mergeAfterMaterialize) {
+			const { existingWrapper, isMergeReplace: ____isMergeReplace } = this._mergeAfterMaterialize;
+
+			
+			
+			const existingKeys = Object.keys(existingWrapper).filter((k) => !k.startsWith("_") && !k.startsWith("__"));
+			for (const key of existingKeys) {
+				if (!(key in this) || key.startsWith("_") || key.startsWith("__")) {
+					const child = existingWrapper[key];
+					Object.defineProperty(this, key, {
+						value: child,
+						writable: false,
+						enumerable: true,
+						configurable: true
+					});
+				}
+			}
+
+			
+			delete this._mergeAfterMaterialize;
+		}
+	}
+
+	
+	___createChildWrapper(key, value) {
+		if (value === undefined) {
+			return undefined;
+		}
+
+		if (value && resolveWrapper(value) !== null) {
+			return value;
+		}
+
+		
+		
+		
+		if (
+			value instanceof Map ||
+			value instanceof Set ||
+			value instanceof WeakMap ||
+			value instanceof WeakSet ||
+			value instanceof Date ||
+			value instanceof RegExp ||
+			value instanceof Promise ||
+			value instanceof Error ||
+			ArrayBuffer.isView(value) ||
+			value instanceof ArrayBuffer
+		) {
+			return null;
+		}
+
+		let childImpl = value;
+		if (this.____slothletInternal.mode === "eager" && childImpl && typeof childImpl === "object") {
+			if (Array.isArray(childImpl)) {
+				childImpl = childImpl.slice();
+			} else {
+				const descriptors = Object.getOwnPropertyDescriptors(childImpl);
+				childImpl = Object.create(Object.getPrototypeOf(childImpl), descriptors);
+			}
+		}
+
+		
+		const parentMetadata = this.slothlet.handlers?.metadata?.getMetadata(this);
+
+		
+		const childExistingMetadata = this.slothlet.handlers?.metadata?.getMetadata(value);
+		let childFilePath = childExistingMetadata?.filePath || null;
+		let childModuleId = null;
+
+		if (!childFilePath) {
+			
+			
+			
+			const keyStr = typeof key === "symbol" ? String(key) : key;
+			this.slothlet.debug("wrapper", {
+				key: "DEBUG_MODE_WRAP_CHILD_PATH_CHECK",
+				apiPath: this.apiPath,
+				propKey: keyStr,
+				has_impl: !!this.____slothletInternal.impl,
+				has__childFilePaths: !!(this.____slothletInternal.impl && this.____slothletInternal.impl.__childFilePaths),
+				has__childFilePathsPreMaterialize: !!this.____slothletInternal.childFilePathsPreMaterialize,
+				parentFilePath: parentMetadata?.filePath
+			});
+			if (this.____slothletInternal.impl && this.____slothletInternal.impl.__childFilePaths) {
+				this.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_WRAP_CHILD_PATH_AVAILABLE",
+					keys: Object.keys(this.____slothletInternal.impl.__childFilePaths).join(","),
+					propKey: keyStr,
+					found: !!this.____slothletInternal.impl.__childFilePaths[key]
+				});
+			}
+			
+			
+			if (
+				this.____slothletInternal.impl &&
+				this.____slothletInternal.impl.__childFilePaths &&
+				this.____slothletInternal.impl.__childFilePaths[key]
+			) {
+				childFilePath = this.____slothletInternal.impl.__childFilePaths[key];
+				this.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_WRAP_CHILD_PATH_USING",
+					childFilePath
+				});
+				
+				
+			} else if (this.____slothletInternal.childFilePathsPreMaterialize && this.____slothletInternal.childFilePathsPreMaterialize[key]) {
+				
+				childFilePath = this.____slothletInternal.childFilePathsPreMaterialize[key];
+				this.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_WRAP_CHILD_PATH_PRE_MAT",
+					childFilePath
+				});
+				
+			} else {
+				
+				childFilePath = parentMetadata?.filePath || null;
+				this.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_WRAP_CHILD_PATH_FALLBACK",
+					childFilePath
+				});
+			}
+
+			
+			if (parentMetadata?.moduleID) {
+				const colonIndex = parentMetadata.moduleID.indexOf(":");
+				
+				
+				childModuleId = colonIndex > 0 ? parentMetadata.moduleID.substring(0, colonIndex) : parentMetadata.moduleID;
+			}
+		} else {
+			
+			
+			
+			if (childExistingMetadata?.moduleID) {
+				const colonIndex = childExistingMetadata.moduleID.indexOf(":");
+				
+				
+				childModuleId = colonIndex > 0 ? childExistingMetadata.moduleID.substring(0, colonIndex) : childExistingMetadata.moduleID;
+			}
+		}
+
+		const childSourceFolder = childExistingMetadata?.sourceFolder || parentMetadata?.sourceFolder || null;
+
+		const nestedWrapper = new UnifiedWrapper(this.slothlet, {
+			mode: "eager",
+			
+			
+			apiPath: this.____slothletInternal.apiPath
+				? `${this.____slothletInternal.apiPath}.${typeof key === "symbol" ? String(key) : key}`
+				: String(key),
+			
+			initialImpl: childImpl,
+			isCallable: typeof childImpl === "function",
+			filePath: childFilePath,
+			moduleID: childModuleId,
+			sourceFolder: childSourceFolder
+		});
+		
+		
+		return nestedWrapper.createProxy();
+	}
+
+	
+	___createWaitingProxy(propChain = []) {
+		const wrapper = this;
+
+		
+		const cacheKey = propChain.join(".");
+
+		
+		
+		
+		
+		if (!wrapper.____slothletInternal.waitingProxyCache) {
+			wrapper.____slothletInternal.waitingProxyCache = new Map();
+		}
+		
+
+		
+		if (wrapper.____slothletInternal.waitingProxyCache.has(cacheKey)) {
+			return wrapper.____slothletInternal.waitingProxyCache.get(cacheKey);
+		}
+
+		
+		
+		const waitingTarget = createNamedProxyTarget(`${wrapper.____slothletInternal.apiPath}_waitingProxy`, "waitingProxyTarget");
+		
+		
+
+		const waitingProxy = new Proxy(waitingTarget, {
+			get(___target, prop) {
+				if (prop === "then") {
+					
+					
+					
+					return (onFulfilled, onRejected) => {
+						const waitingProxy_thenResolve = async () => {
+							
+							if (!wrapper.____slothletInternal.state.materialized) {
+								await wrapper._materialize();
+							}
+
+							
+							let current = wrapper;
+							for (const chainProp of propChain) {
+								
+								
+								if (!current) return undefined;
+
+								
+								if (
+									current.____slothletInternal.impl &&
+									typeof current.____slothletInternal.impl === "object" &&
+									util.types.isProxy(current.____slothletInternal.impl)
+								) {
+									let result = current.____slothletInternal.impl;
+									
+									const idx = propChain.indexOf(chainProp);
+									for (let i = idx; i < propChain.length; i++) {
+										result = result[propChain[i]];
+									}
+									return result;
+								}
+
+								
+								const isInternal = typeof chainProp === "string" && (chainProp.startsWith("_") || chainProp.startsWith("__"));
+								if (!isInternal && hasOwn(current, chainProp)) {
+									const child = current[chainProp];
+									const _childW = resolveWrapper(child);
+									if (_childW) {
+										current = _childW;
+										
+										if (current.____slothletInternal.mode === "lazy" && !current.____slothletInternal.state.materialized) {
+											await current._materialize();
+										}
+										continue;
+									}
+									return child;
+								}
+
+								
+								if (current.____slothletInternal.impl && current.____slothletInternal.impl[chainProp] !== undefined) {
+									return current.____slothletInternal.impl[chainProp];
+								}
+
+								return undefined;
+							}
+
+							
+							if (
+								current.____slothletInternal.impl &&
+								typeof current.____slothletInternal.impl === "object" &&
+								util.types.isProxy(current.____slothletInternal.impl)
+							) {
+								return current.____slothletInternal.impl;
+							}
+							return current.____slothletInternal.impl;
+						};
+
+						waitingProxy_thenResolve().then(onFulfilled, onRejected);
+					};
+				}
+				if (prop === "____slothletInternal") return undefined; 
+				if (prop === "_materialize") return wrapper._materialize.bind(wrapper);
+				if (prop === "__mode") return wrapper.____slothletInternal.mode;
+				if (prop === "__materialized") return wrapper.____slothletInternal.state.materialized;
+				if (prop === "__inFlight") return wrapper.____slothletInternal.state.inFlight;
+				
+
+				
+				
+				if (
+					wrapper.____slothletInternal.mode === "lazy" &&
+					!wrapper.____slothletInternal.state.materialized &&
+					!wrapper.____slothletInternal.state.inFlight
+				) {
+					wrapper._materialize();
+				}
+
+				if (prop === util.inspect.custom) {
+					
+					
+					if (wrapper.____slothletInternal.state.inFlight) {
+						return waitingTarget;
+					}
+					
+					
+					
+					if (!wrapper.____slothletInternal.state.materialized) {
+						return waitingTarget;
+					}
+					
+					
+					
+					
+					if (wrapper.____slothletInternal.impl) {
+						let current = wrapper.____slothletInternal.impl;
+						for (const chainProp of propChain) {
+							if (!current || current === null) {
+								return undefined;
+							}
+							current = current[chainProp];
+						}
+						
+						
+						
+						return current;
+					}
+					
+					
+					return waitingTarget;
+				}
+				if (prop === "__type") {
+					wrapper.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_WAITING_TYPE",
+						apiPath: wrapper.apiPath,
+						propChain: propChain.join(","),
+						materialized: wrapper.____slothletInternal.state.materialized,
+						hasImpl: wrapper.____slothletInternal.impl !== null
+					});
+					
+					
+					
+					
+					
+					if (
+						wrapper.____slothletInternal.state.materialized ||
+						(wrapper.____slothletInternal.impl !== null && wrapper.____slothletInternal.impl !== undefined)
+					) {
+						
+						
+						let current = wrapper.createProxy();
+						for (const chainProp of propChain) {
+							if (!current) break;
+							const currentWrapper = resolveWrapper(current);
+							if (current && currentWrapper) {
+								
+								
+								const isInternal = typeof chainProp === "string" && (chainProp.startsWith("_") || chainProp.startsWith("__"));
+								if (!isInternal && chainProp in currentWrapper) {
+									current = currentWrapper[chainProp];
+									wrapper.slothlet.debug("wrapper", {
+										key: "DEBUG_MODE_WAITING_TYPE_WALK_WRAPPER",
+										chainProp: String(chainProp),
+										typeOf: typeof current
+									});
+									continue;
+								}
+								if (
+									currentWrapper.____slothletInternal.impl &&
+									typeof currentWrapper.____slothletInternal.impl === "object" &&
+									currentWrapper.____slothletInternal.impl !== null &&
+									chainProp in currentWrapper.____slothletInternal.impl
+								) {
+									current = currentWrapper.____slothletInternal.impl[chainProp];
+									wrapper.slothlet.debug("wrapper", {
+										key: "DEBUG_MODE_WAITING_TYPE_WALK_IMPL",
+										chainProp: String(chainProp),
+										typeOf: typeof current
+									});
+									continue;
+								}
+							}
+							wrapper.slothlet.debug("wrapper", {
+								key: "DEBUG_MODE_WAITING_TYPE_WALK_DIRECT",
+								chainProp: String(chainProp),
+								typeOf: typeof current
+							});
+							current = current[chainProp];
+						}
+						
+						const resolvedType =
+							typeof current === "function" ? "function" : typeof current === "object" && current !== null ? "object" : typeof current;
+						wrapper.slothlet.debug("wrapper", {
+							key: "DEBUG_MODE_WAITING_TYPE_RESOLVED",
+							apiPath: wrapper.apiPath,
+							propChain: propChain.join(","),
+							resolvedType
+						});
+						return resolvedType;
+					}
+					
+					wrapper.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_WAITING_TYPE_INFLIGHT",
+						apiPath: wrapper.apiPath,
+						propChain: propChain.join(",")
+					});
+					return TYPE_STATES.IN_FLIGHT;
+				}
+				if (prop === "__metadata") {
+					
+					
+					
+					if (wrapper.slothlet.handlers?.metadata) {
+						return wrapper.slothlet.handlers.metadata.getMetadata(wrapper);
+					}
+					
+					
+					return {};
+				}
+				if (typeof prop === "symbol") return undefined;
+				if (prop === "length") {
+					
+					
+					return 0;
+				}
+				
+				
+				if (prop === "name") return waitingTarget.name || "waitingProxyTarget";
+				if (prop === "toString") {
+					
+					return Function.prototype.toString.bind(waitingTarget);
+				}
+				if (prop === "valueOf") {
+					
+					return Function.prototype.valueOf.bind(waitingTarget);
+				}
+				
+				
+				if (prop === "toJSON") {
+					
+					
+					return () => undefined;
+				}
+				
+				if (prop === "__slothletPath") return wrapper.____slothletInternal.apiPath;
+
+				
+				
+				
+				
+				
+				if (
+					wrapper.____slothletInternal.impl !== null &&
+					wrapper.____slothletInternal.impl !== undefined &&
+					typeof wrapper.____slothletInternal.impl === "object" &&
+					util.types.isProxy(wrapper.____slothletInternal.impl)
+				) {
+					
+					
+					let result = wrapper.____slothletInternal.impl;
+					for (const chainProp of propChain) {
+						result = result[chainProp];
+					}
+					
+					return result[prop];
+				}
+
+				
+				
+				
+				
+				
+				if (wrapper.____slothletInternal.impl !== null && wrapper.____slothletInternal.impl !== undefined) {
+					
+					let current = wrapper;
+					let remainingChain = [...propChain];
+
+					
+					for (let i = 0; i < propChain.length; i++) {
+						const chainProp = propChain[i];
+
+						
+						if (
+							current.____slothletInternal.impl &&
+							typeof current.____slothletInternal.impl === "object" &&
+							util.types.isProxy(current.____slothletInternal.impl)
+						) {
+							
+							let proxyResult = current.____slothletInternal.impl;
+							for (const remainingProp of remainingChain) {
+								proxyResult = proxyResult[remainingProp];
+							}
+
+							
+							return proxyResult[prop];
+						}
+
+						const isInternal = typeof chainProp === "string" && (chainProp.startsWith("_") || chainProp.startsWith("__"));
+						if (!isInternal && current && chainProp in current) {
+							const cached = current[chainProp];
+
+							
+							const _cachedW2 = resolveWrapper(cached);
+							
+							
+							if (_cachedW2) {
+								current = _cachedW2;
+								remainingChain.shift(); 
+							} else {
+								
+								return undefined;
+							}
+							
+						} else {
+							
+							return undefined;
+						}
+					}
+
+					
+					
+					if (
+						current &&
+						current.____slothletInternal.impl &&
+						typeof current.____slothletInternal.impl === "object" &&
+						util.types.isProxy(current.____slothletInternal.impl)
+					) {
+						return current.____slothletInternal.impl[prop];
+					}
+
+					
+					const isFinalInternal = typeof prop === "string" && (prop.startsWith("_") || prop.startsWith("__"));
+					if (!isFinalInternal && current && prop in current) {
+						return current[prop];
+					}
+
+					
+					return undefined;
+				}
+
+				
+				
+				
+				
+				const isInternal = typeof prop === "string" && (prop.startsWith("_") || prop.startsWith("__"));
+				if (!isInternal && hasOwn(wrapper, prop)) {
+					wrapper.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_WAITING_GET_PREMATURE",
+						apiPath: wrapper.____slothletInternal.apiPath,
+						prop
+					});
+					return wrapper[prop];
+				}
+
+				
+				
+				
+				
+				
+				
+				if (
+					wrapper.____slothletInternal.needsImmediateChildAdoption &&
+					wrapper.____slothletInternal.materializeFunc &&
+					!wrapper.____slothletInternal.state.materialized &&
+					!wrapper.____slothletInternal.state.inFlight
+				) {
+					wrapper.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_WAITING_GET_IMMEDIATE_MAT",
+						apiPath: wrapper.____slothletInternal.apiPath,
+						prop
+					});
+					
+					wrapper._materialize().catch((err) => {
+						wrapper.slothlet.debug("wrapper", {
+							key: "DEBUG_MODE_WAITING_GET_IMMEDIATE_MAT_ERROR",
+							apiPath: wrapper.apiPath,
+							error: err.message
+						});
+					});
+					
+					
+					const isInternal = typeof prop === "string" && (prop.startsWith("_") || prop.startsWith("__"));
+					if (!isInternal && hasOwn(wrapper, prop)) {
+						wrapper.slothlet.debug("wrapper", {
+							key: "DEBUG_MODE_WAITING_GET_IMMEDIATE_MAT_SUCCESS",
+							apiPath: wrapper.____slothletInternal.apiPath,
+							prop
+						});
+						return wrapper[prop];
+					}
+				}
+				
+
+				
+				if (wrapper.____slothletInternal.state.inFlight) {
+					
+					
+					return wrapper.___createWaitingProxy([...propChain, prop]);
+				}
+
+				
+				return wrapper.___createWaitingProxy([...propChain, prop]);
+			},
+
+			async apply(___target, ___thisArg, args) {
+				wrapper.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_WAITING_APPLY_ENTRY",
+					apiPath: wrapper.____slothletInternal.apiPath,
+					propChain: propChain.join(","),
+					args: args.join(",")
+				});
+				const chainLabel = propChain.map((prop) => String(prop)).join(".");
+
+				if (
+					wrapper.____slothletInternal.mode === "lazy" &&
+					!wrapper.____slothletInternal.state.materialized &&
+					!wrapper.____slothletInternal.state.inFlight
+				) {
+					wrapper.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_WAITING_APPLY_MATERIALIZE",
+						apiPath: wrapper.____slothletInternal.apiPath
+					});
+					await wrapper._materialize();
+					wrapper.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_WAITING_APPLY_MATERIALIZED",
+						apiPath: wrapper.____slothletInternal.apiPath
+					});
+				} else if (
+					wrapper.____slothletInternal.mode === "lazy" &&
+					!wrapper.____slothletInternal.state.materialized &&
+					wrapper.____slothletInternal.state.inFlight
+				) {
+					
+					
+					
+					
+					if (wrapper.____slothletInternal.materializationPromise) {
+						await wrapper.____slothletInternal.materializationPromise;
+						
+						
+					} else {
+						
+						await wrapper._materialize();
+					}
+					
+				}
+
+				wrapper.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_WAITING_APPLY_START_WALK",
+					apiPath: wrapper.____slothletInternal.apiPath,
+					propChain: propChain.join(",")
+				});
+				let current = wrapper.createProxy();
+				let lastWrapper = wrapper;
+				let lastObject = null; 
+
+				for (const prop of propChain) {
+					wrapper.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_WAITING_APPLY_WALK",
+						prop: String(prop),
+						typeOf: typeof current,
+						constructorName: current?.constructor?.name
+					});
+					if (!current) {
+						
+						
+						
+						
+						
+						if (propChain.some((p) => typeof p === "symbol")) {
+							return undefined;
+						}
+						
+						
+						
+						
+						
+						if (
+							wrapper.____slothletInternal.invalid ||
+							wrapper.____slothletInternal.impl === null ||
+							(lastWrapper && (lastWrapper.__invalid || lastWrapper._impl === null))
+						) {
+							return undefined;
+						}
+						
+						
+						
+						
+						const finalProp = propChain[propChain.length - 1];
+						if (
+							finalProp === "hasAttribute" ||
+							finalProp === "toJSON" ||
+							finalProp === Symbol.toStringTag ||
+							finalProp === "constructor" ||
+							typeof finalProp === "symbol" ||
+							typeof prop === "symbol"
+						) {
+							return undefined;
+						}
+						throw new wrapper.slothlet.SlothletError(
+							"CHAIN_ACCESS_UNDEFINED",
+							{
+								apiPath: wrapper.____slothletInternal.apiPath,
+								chainLabel,
+								prop: String(prop)
+							},
+							null,
+							{ validationError: true }
+						);
+					}
+
+					const currentWrapper = resolveWrapper(current);
+					
+					
+					if (currentWrapper) {
+						const state = currentWrapper.____slothletInternal.state;
+						if (!state.materialized) {
+							
+							
+							if (!state.inFlight && typeof current._materialize === "function") {
+								await current._materialize();
+							}
+							
+							
+							
+							while (!currentWrapper.____slothletInternal.state.materialized) {
+								const nextState = currentWrapper.____slothletInternal.state;
+								if (!nextState.inFlight && !nextState.materialized) {
+									throw new wrapper.slothlet.SlothletError(
+										"CHAIN_MATERIALIZE_FAILED",
+										{
+											apiPath: wrapper.____slothletInternal.apiPath,
+											chainLabel,
+											prop: String(prop)
+										},
+										null,
+										{ validationError: true }
+									);
+								}
+								await new Promise((resolve) => setImmediate(resolve));
+							}
+							
+						}
+					}
+
+					
+					
+					if (current && currentWrapper) {
+						lastWrapper = currentWrapper; 
+						const isInternal = typeof prop === "string" && (prop.startsWith("_") || prop.startsWith("__"));
+						if (!isInternal && prop in currentWrapper) {
+							lastObject = current; 
+							current = currentWrapper[prop];
+							continue;
+						}
+						
+						if (
+							currentWrapper.____slothletInternal.impl &&
+							typeof currentWrapper.____slothletInternal.impl === "object" &&
+							currentWrapper.____slothletInternal.impl !== null &&
+							prop in currentWrapper.____slothletInternal.impl
+						) {
+							lastObject = currentWrapper.____slothletInternal.impl; 
+							current = currentWrapper.____slothletInternal.impl[prop];
+							continue;
+						}
+					}
+
+					lastObject = current; 
+					current = current[prop];
+				}
+
+				wrapper.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_WAITING_APPLY",
+					apiPath: wrapper.____slothletInternal.apiPath,
+					propChain: propChain.join(","),
+					typeOf: typeof current,
+					currentName: current?.name,
+					isFunction: typeof current === "function"
+				});
+
+				if (typeof current === "function") {
+					
+					
+					
+					return Reflect.apply(current, lastObject, args);
+				}
+
+				
+				
+				
+				
+				const _finalChainProp = propChain[propChain.length - 1];
+				
+				
+				if (_finalChainProp === "hasAttribute" || _finalChainProp === "toJSON") {
+					return undefined;
+				}
+				
+
+				
+				
+				if (current === undefined || current === null) {
+					throw new wrapper.slothlet.SlothletError(
+						"CHAIN_NOT_CALLABLE",
+						{
+							apiPath: wrapper.____slothletInternal.apiPath,
+							chainLabel
+						},
+						null,
+						{ validationError: true }
+					);
+				}
+
+				throw new wrapper.slothlet.SlothletError(
+					"CHAIN_NOT_CALLABLE",
+					{
+						apiPath: wrapper.____slothletInternal.apiPath,
+						chainLabel
+					},
+					null,
+					{ validationError: true }
+				);
+			},
+			getPrototypeOf: () => null
+		});
+
+		
+		
+		
+		_proxyRegistry.set(waitingProxy, wrapper);
+
+		
+		wrapper.____slothletInternal.waitingProxyCache.set(cacheKey, waitingProxy);
+
+		return waitingProxy;
+	}
+
+	
+	createProxy() {
+		const wrapper = this;
+		if (wrapper.____slothletInternal.proxy) {
+			return wrapper.____slothletInternal.proxy;
+		}
+
+		
+		
+		if (
+			wrapper.____slothletInternal.materializeOnCreate &&
+			wrapper.____slothletInternal.mode === "lazy" &&
+			!wrapper.____slothletInternal.state.materialized &&
+			wrapper.____slothletInternal.materializeFunc
+		) {
+			wrapper._materialize(); 
+		}
+
+		
+		
+		
+		
+		
+		
+		
+		const mightBeCallable =
+			wrapper.____slothletInternal.isCallable ||
+			(wrapper.____slothletInternal.mode === "lazy" && !wrapper.____slothletInternal.isCallableLocked);
+		let proxyTarget;
+		if (mightBeCallable) {
+			
+			
+			proxyTarget = createNamedProxyTarget(wrapper.____slothletInternal.apiPath, "callableProxy");
+		} else {
+			
+			proxyTarget = wrapper;
+		}
+
+		
+		if (!(util.inspect.custom in proxyTarget)) {
+			Object.defineProperty(proxyTarget, util.inspect.custom, {
+				value: function () {
+					
+					const childKeys = Object.keys(wrapper).filter((k) => !k.startsWith("_") && !k.startsWith("__"));
+					if (childKeys.length > 0 && !wrapper.____slothletInternal.isCallable) {
+						const obj = {};
+						for (const key of childKeys) {
+							
+							const child = wrapper[key];
+							
+							
+							if (child && typeof child.createProxy === "function") {
+								obj[key] = child.createProxy();
+							} else {
+								obj[key] = child;
+							}
+						}
+						return obj;
+					}
+					
+					
+					
+					if (
+						wrapper.____slothletInternal.mode === "lazy" &&
+						!wrapper.____slothletInternal.state.materialized &&
+						(wrapper.____slothletInternal.impl === null || wrapper.____slothletInternal.impl === undefined)
+					) {
+						
+						
+						
+						return wrapper.____slothletInternal.proxy || wrapper;
+					}
+					
+					return wrapper.____slothletInternal.impl;
+				},
+				writable: false,
+				enumerable: false,
+				configurable: true
+			});
+		}
+
+		
+		const getTrap = (target, prop, ____receiver) => {
+			
+			
+			if (target !== wrapper && prop in target) {
+				const desc = Object.getOwnPropertyDescriptor(target, prop);
+				
+				
+				if (desc && !desc.configurable) {
+					
+					
+					if (typeof prop === "string" && prop.startsWith("__")) {
+						return wrapper[prop];
+					}
+					return target[prop];
+				}
+				
+			}
+			
+			
+			
+			
+			if (target === wrapper && typeof prop === "string") {
+				const desc = Object.getOwnPropertyDescriptor(target, prop);
+				if (desc && !desc.configurable) {
+					return target[prop];
+				}
+			}
+			
+
+			
+			
+			const isInternalProp = typeof prop === "string" && UnifiedWrapper.INTERNAL_KEYS.has(prop);
+
+			
+			
+			
+			const allowedInternals = new Set([
+				"_materialize",
+				"__mode",
+				"__apiPath",
+				"__isCallable",
+				"__materializeOnCreate",
+				"__displayName",
+				"__type",
+				"__materialized",
+				"__inFlight",
+				"__slothletPath",
+				"__metadata",
+				
+				"__filePath",
+				"__sourceFolder",
+				"__moduleID"
+			]);
+			if (isInternalProp && !allowedInternals.has(prop)) {
+				return undefined; 
+			}
+
+			
+			if (prop === "power" || prop === "add") {
+				this.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_GET_START",
+					apiPath: wrapper.____slothletInternal.apiPath,
+					prop: String(prop),
+					mode: wrapper.____slothletInternal.mode,
+					
+					
+					collisionMode: wrapper.____slothletInternal.state.collisionMode || "none",
+					materialized: wrapper.____slothletInternal.state.materialized,
+					hasImpl: wrapper.____slothletInternal.impl !== null,
+					inWrapper: !isInternalProp && hasOwn(wrapper, prop)
+				});
+			}
+
+			if (prop === "__mode") return wrapper.____slothletInternal.mode;
+			if (prop === "__apiPath") return wrapper.____slothletInternal.apiPath;
+			if (prop === "__isCallable") return wrapper.____slothletInternal.isCallable;
+			if (prop === "__materializeOnCreate") return wrapper.____slothletInternal.materializeOnCreate;
+			if (prop === "__materialized") return wrapper.____slothletInternal.state.materialized;
+			if (prop === "__inFlight") return wrapper.____slothletInternal.state.inFlight;
+			if (prop === "__displayName") return wrapper.____slothletInternal.displayName;
+			if (prop === "__type") {
+				
+				if (
+					wrapper.____slothletInternal.mode === "lazy" &&
+					!wrapper.____slothletInternal.state.materialized &&
+					!wrapper.____slothletInternal.state.inFlight
+				) {
+					wrapper._materialize();
+				}
+
+				
+				if (wrapper.____slothletInternal.mode === "lazy" && wrapper.____slothletInternal.state.inFlight) {
+					return TYPE_STATES.IN_FLIGHT;
+				}
+				if (wrapper.____slothletInternal.mode === "lazy" && !wrapper.____slothletInternal.state.materialized) {
+					return TYPE_STATES.UNMATERIALIZED;
+				}
+
+				
+				const impl = wrapper.____slothletInternal.impl;
+				if (typeof impl === "function") {
+					return "function";
+				}
+				if (impl && typeof impl === "object" && typeof impl.default === "function") {
+					return "function";
+				}
+				if (impl && typeof impl === "object") {
+					return "object";
+				}
+				
+				if (typeof impl === "string") {
+					return "string";
+				}
+				if (typeof impl === "number") {
+					return "number";
+				}
+				if (typeof impl === "boolean") {
+					return "boolean";
+				}
+				if (typeof impl === "symbol") {
+					return "symbol";
+				}
+				if (typeof impl === "bigint") {
+					return "bigint";
+				}
+				return "undefined";
+			}
+			if (prop === "_materialize") return wrapper._materialize.bind(wrapper);
+			if (prop === "__slothletPath") return wrapper.____slothletInternal.apiPath;
+			
+			if (prop === "__metadata") {
+				
+				if (wrapper.slothlet.handlers?.metadata) {
+					return wrapper.slothlet.handlers.metadata.getMetadata(wrapper);
+				}
+				return {};
+			}
+			
+			
+			
+			if (prop === "__filePath") return wrapper.____slothletInternal.filePath ?? undefined;
+			
+			
+			if (prop === "__sourceFolder") return wrapper.____slothletInternal.sourceFolder ?? undefined;
+			
+			
+			if (prop === "__moduleID") return wrapper.____slothletInternal.moduleID ?? undefined;
+			
+			
+			if (prop === "__invalid") return wrapper.____slothletInternal.invalid;
+			if (prop === "then") return undefined;
+			if (prop === "constructor") return Object.prototype.constructor;
+			if (prop === util.inspect.custom) {
+				
+				return () => {
+					
+					const childKeys = Object.keys(wrapper).filter((k) => !k.startsWith("_") && !k.startsWith("__"));
+					if (childKeys.length > 0 && !wrapper.____slothletInternal.isCallable) {
+						const obj = {};
+						for (const key of childKeys) {
+							const child = wrapper[key];
+							
+							
+							if (child && typeof child.createProxy === "function") {
+								obj[key] = child.createProxy();
+							} else {
+								obj[key] = child;
+							}
+						}
+						return obj;
+					}
+					
+					
+					
+					if (
+						wrapper.____slothletInternal.mode === "lazy" &&
+						!wrapper.____slothletInternal.state.materialized &&
+						(wrapper.____slothletInternal.impl === null || wrapper.____slothletInternal.impl === undefined)
+					) {
+						
+						this.slothlet.debug("wrapper", {
+							key: "DEBUG_MODE_INSPECT_LAZY_UNMATERIALIZED",
+							apiPath: wrapper.apiPath,
+							wrapper: wrapper,
+							____proxy: wrapper.____slothletInternal.proxy
+						});
+						
+						
+						return wrapper || wrapper.____slothletInternal.proxy;
+					}
+					
+					return wrapper.____slothletInternal.impl;
+				};
+			}
+			if (prop === Symbol.toStringTag) {
+				
+				const impl = wrapper.____slothletInternal.impl;
+				if (typeof impl === "function") {
+					return "Function";
+				}
+				if (impl && typeof impl === "object" && typeof impl.default === "function") {
+					return "Function";
+				}
+				return "Object";
+			}
+			if (typeof prop === "symbol") return undefined;
+			if (prop === "length") {
+				
+				const impl = wrapper.____slothletInternal.impl;
+				if (typeof impl === "function") {
+					return impl.length;
+				}
+				if (impl && typeof impl === "object" && typeof impl.default === "function") {
+					return impl.default.length;
+				}
+				return 0;
+			}
+			if (prop === "name") {
+				
+				
+				
+				
+				if (wrapper.____slothletInternal.apiPath) {
+					const pathParts = wrapper.____slothletInternal.apiPath.split(".");
+					const lastPart = pathParts[pathParts.length - 1];
+					
+					
+					if (lastPart) {
+						return lastPart;
+					}
+				}
+				
+				
+				return target.name || "unifiedWrapperProxy";
+			}
+			if (prop === "toString") {
+				
+				const impl = wrapper.____slothletInternal.impl;
+				if (typeof impl === "function") {
+					return impl.toString.bind(impl);
+				}
+				if (impl && typeof impl === "object" && typeof impl.default === "function") {
+					return impl.default.toString.bind(impl.default);
+				}
+				
+				if (typeof target === "function") {
+					return Function.prototype.toString.bind(target);
+				}
+				return () => `[UnifiedWrapper: ${wrapper.____slothletInternal.apiPath}]`;
+			}
+			if (prop === "valueOf") {
+				
+				const impl = wrapper.____slothletInternal.impl;
+				if (typeof impl === "function") {
+					return impl.valueOf.bind(impl);
+				}
+				if (impl && typeof impl === "object" && typeof impl.default === "function") {
+					return impl.default.valueOf.bind(impl.default);
+				}
+				return Function.prototype.valueOf.bind(target);
+			}
+			if (prop === "toJSON") {
+				
+				
+				
+				const impl = wrapper.____slothletInternal.impl;
+				
+				
+				if (impl && typeof impl.toJSON === "function") {
+					return impl.toJSON.bind(impl);
+				}
+				
+				return () => undefined;
+			}
+
+			if (wrapper.____slothletInternal.invalid) {
+				return undefined;
+			}
+
+			if (
+				wrapper.____slothletInternal.mode === "lazy" &&
+				!wrapper.____slothletInternal.state.materialized &&
+				!wrapper.____slothletInternal.state.inFlight
+			) {
+				wrapper._materialize();
+			}
+
+			
+			
+			
+			
+			const isInternal = typeof prop === "string" && (prop.startsWith("_") || prop.startsWith("__"));
+			if (!isInternal && hasOwn(wrapper, prop)) {
+				
+				if (wrapper.____slothletInternal.state.collisionMode === "replace" && (prop === "power" || prop === "add")) {
+					this.slothlet.debug("wrapper", {
+						key: "DEBUG_MODE_GET_CACHED_REPLACE",
+						apiPath: wrapper.apiPath,
+						prop: String(prop),
+						collisionMode: wrapper.____slothletInternal.state.collisionMode,
+						wrapperKeys: Object.keys(wrapper)
+							.filter((k) => !k.startsWith("_") && !k.startsWith("__"))
+							.join(", ")
+					});
+				}
+				this.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_GET_CACHED",
+					apiPath: wrapper.____slothletInternal.apiPath,
+					prop: String(prop),
+					materialized: wrapper.____slothletInternal.state.materialized,
+					hasImpl: wrapper.____slothletInternal.impl !== null
+				});
+				const cached = wrapper[prop];
+				
+				
+				const _cachedWrapper = resolveWrapper(cached);
+				if (_cachedWrapper?.____slothletInternal?.impl !== null && _cachedWrapper?.____slothletInternal?.impl !== undefined) {
+					const cachedImpl = _cachedWrapper.____slothletInternal.impl;
+					
+					const cachedType = typeof cachedImpl;
+					if (
+						cachedType === "string" ||
+						cachedType === "number" ||
+						cachedType === "boolean" ||
+						cachedType === "bigint" ||
+						cachedType === "symbol"
+					) {
+						return cachedImpl;
+					}
+				}
+				
+				if (_cachedWrapper) {
+					const cachedWrapper = _cachedWrapper;
+					if (
+						cachedWrapper.____slothletInternal.mode === "lazy" &&
+						!cachedWrapper.____slothletInternal.state.materialized &&
+						!cachedWrapper.____slothletInternal.state.inFlight
+					) {
+						cachedWrapper._materialize();
+					}
+				}
+				
+				return cached;
+			}
+
+			
+			
+			
+			
+			if (wrapper.____slothletInternal.impl !== null && wrapper.____slothletInternal.impl !== undefined) {
+				
+				
+				if (typeof wrapper.____slothletInternal.impl === "object" && util.types.isProxy(wrapper.____slothletInternal.impl)) {
+					return wrapper.____slothletInternal.impl[prop];
+				}
+
+				
+				const isInternal = typeof prop === "string" && (prop.startsWith("_") || prop.startsWith("__"));
+				
+				
+				if (!isInternal && hasOwn(wrapper, prop)) {
+					if (prop === "power" || prop === "add") {
+						this.slothlet.debug("wrapper", {
+							key: "DEBUG_MODE_GET_PROXYGET_ACCESSING",
+							prop,
+							wrapperId: wrapper.____slothletInternal.id,
+							apiPath: wrapper.apiPath,
+							collisionMode: wrapper.____slothletInternal.state.collisionMode || "none"
+						});
+						this.slothlet.debug("wrapper", {
+							key: "DEBUG_MODE_GET_PROXYGET_FOUND",
+							wrapperKeys: Object.keys(wrapper)
+								.filter((k) => !k.startsWith("_") && !k.startsWith("__"))
+								.join(", ")
+						});
+					}
+					const cached = wrapper[prop];
+					
+					const _cachedWrapper4 = resolveWrapper(cached);
+					if (_cachedWrapper4) {
+						const cachedWrapper = _cachedWrapper4;
+						if (
+							cachedWrapper.____slothletInternal.mode === "lazy" &&
+							!cachedWrapper.____slothletInternal.state.materialized &&
+							!cachedWrapper.____slothletInternal.state.inFlight
+						) {
+							cachedWrapper._materialize();
+						}
+					}
+					return cached;
+				}
+				
+			}
+
+			
+			
+			
+			const isInternalProp2 = typeof prop === "string" && UnifiedWrapper.INTERNAL_KEYS.has(prop);
+			if (
+				wrapper.____slothletInternal.mode === "lazy" &&
+				wrapper.____slothletInternal.state.materialized &&
+				!isInternalProp2 &&
+				!hasOwn(wrapper, prop) &&
+				wrapper.____slothletInternal.impl &&
+				!(prop in wrapper.____slothletInternal.impl)
+			) {
+				return undefined;
+			}
+
+			if (
+				wrapper.____slothletInternal.mode === "lazy" &&
+				(wrapper.____slothletInternal.state.inFlight || !wrapper.____slothletInternal.impl)
+			) {
+				
+				
+				
+				
+				
+				if (!wrapper.____slothletInternal.state.materialized && !wrapper.____slothletInternal.state.inFlight) {
+					wrapper._materialize();
+				}
+
+				this.slothlet.debug("wrapper", {
+					key: "DEBUG_MODE_LAZY_GET_CREATE_WAITING_PROXY",
+					prop: String(prop),
+					
+					
+					collisionMode: wrapper.____slothletInternal.state.collisionMode || "none",
+					apiPath: wrapper.____slothletInternal.apiPath
+				});
+
+				
+				
+				
+				if (
+					wrapper.____slothletInternal.impl &&
+					typeof wrapper.____slothletInternal.impl === "object" &&
+					util.types.isProxy(wrapper.____slothletInternal.impl)
+				) {
+					const value = wrapper.____slothletInternal.impl[prop];
+					return value;
+				}
+				
+				return wrapper.___createWaitingProxy([prop]);
+			}
+
+			
+			
+			
+			if (
+				wrapper.____slothletInternal.impl &&
+				typeof wrapper.____slothletInternal.impl === "object" &&
+				util.types.isProxy(wrapper.____slothletInternal.impl)
+			) {
+				const value = wrapper.____slothletInternal.impl[prop];
+				
+				
+				return value;
+			}
+			
+
+			
+			
+			
+			
+			let value = wrapper.____slothletInternal.impl ? wrapper.____slothletInternal.impl[prop] : undefined;
+
+			
+			if (value === undefined && wrapper.____slothletInternal.impl) {
+				const descriptor = Object.getOwnPropertyDescriptor(wrapper.____slothletInternal.impl, prop);
+				
+				
+				if (descriptor && descriptor.get) {
+					
+					value = descriptor.get.call(wrapper.____slothletInternal.impl);
+				}
+				
+			}
+			
+			
+			
+			
+			if (value === undefined && Object.prototype.hasOwnProperty.call(target, prop)) {
+				value = target[prop];
+			}
+
+			if (value === undefined) {
+				return undefined;
+			}
+
+			
+			
+			const valueType = typeof value;
+			if (
+				value === null ||
+				valueType === "string" ||
+				valueType === "number" ||
+				valueType === "boolean" ||
+				valueType === "bigint" ||
+				valueType === "symbol"
+			) {
+				return value;
+			}
+
+			
+			
+			
+			if (
+				value instanceof Map ||
+				value instanceof Set ||
+				value instanceof WeakMap ||
+				value instanceof WeakSet ||
+				value instanceof Date ||
+				value instanceof RegExp ||
+				value instanceof Promise ||
+				value instanceof Error ||
+				ArrayBuffer.isView(value) ||
+				value instanceof ArrayBuffer
+			) {
+				return value;
+			}
+			
+
+			
+			
+			
+			
+			
+			if (value && typeof value === "object" && util.types.isProxy(value)) {
+				return value;
+			}
+
+			if (value && (typeof value === "object" || typeof value === "function") && resolveWrapper(value) !== null) {
+				return value;
+			}
+
+			const wrapped = wrapper.___createChildWrapper(prop, value);
+			
+			
+			if (wrapped) {
+				Object.defineProperty(wrapper, prop, {
+					value: wrapped,
+					writable: false,
+					enumerable: true,
+					configurable: true
+				});
+				return wrapped;
+			}
+
+			
+			
+			
+			
+			return value;
+		};
+
+		
+		const applyTrap = (target, thisArg, args) => {
+			if (wrapper.____slothletInternal.invalid) {
+				
+				
+				throw new TypeError(`${wrapper.____slothletInternal.apiPath || "api"} is invalidated`);
+			}
+
+			
+			const hookManager = wrapper.slothlet.handlers?.hookManager;
+			
+			const hasHooks = hookManager && hookManager.enabled && !wrapper.____slothletInternal.apiPath.startsWith("slothlet.hook");
+
+			
+			const api = wrapper.slothlet.boundApi;
+			const ctx = wrapper.slothlet.config?.context || {};
+
+			
+			let result;
+			let finalResult;
+			let isAsync = false; 
+
+			try {
+				
+				if (hasHooks) {
+					const beforeResult = hookManager.executeBeforeHooks(wrapper.____slothletInternal.apiPath, args, api, ctx);
+					args = beforeResult.args;
+
+					
+					if (beforeResult.shortCircuit) {
+						
+						finalResult = beforeResult.value;
+						return beforeResult.value;
+					}
+				}
+
+				
+				if (
+					wrapper.____slothletInternal.mode === "lazy" &&
+					!wrapper.____slothletInternal.state.materialized &&
+					!wrapper.____slothletInternal.state.inFlight
+				) {
+					wrapper._materialize();
+				}
+
+				
+				if (wrapper.____slothletInternal.mode === "lazy" && wrapper.____slothletInternal.state.inFlight) {
+					return new Promise((resolve, reject) => {
+						const checkMaterialized = () => {
+							if (wrapper.____slothletInternal.state.materialized) {
+								const impl = wrapper.____slothletInternal.impl;
+								if (typeof impl === "function") {
+									if (wrapper.slothlet.contextManager) {
+										resolve(wrapper.slothlet.contextManager.runInContext(wrapper.instanceID, impl, thisArg, args, wrapper));
+									} else {
+										resolve(impl.apply(thisArg, args));
+									}
+								} else if (impl && typeof impl === "object" && typeof impl.default === "function") {
+									if (wrapper.contextManager) {
+										resolve(wrapper.contextManager.runInContext(wrapper.instanceID, impl.default, impl, args, wrapper));
+									} else {
+										resolve(impl.default.apply(impl, args));
+									}
+								} else {
+									reject(
+										new wrapper.slothlet.SlothletError(
+											"INVALID_CONFIG_NOT_A_FUNCTION",
+											{
+												apiPath: wrapper.____slothletInternal.apiPath,
+												actualType: typeof impl
+											},
+											null,
+											{ validationError: true }
+										)
+									);
+								}
+								return;
+							}
+							if (!wrapper.____slothletInternal.state.inFlight) {
+								reject(
+									new wrapper.slothlet.SlothletError(
+										"INVALID_CONFIG_LAZY_MATERIALIZATION_FAILED",
+										{ apiPath: wrapper.____slothletInternal.apiPath },
+										null,
+										{
+											validationError: true
+										}
+									)
+								);
+								return;
+							}
+							setImmediate(checkMaterialized);
+						};
+						checkMaterialized();
+					});
+				}
+
+				
+				const impl = wrapper.____slothletInternal.impl;
+
+				if (typeof impl === "function") {
+					if (wrapper.slothlet.contextManager) {
+						result = wrapper.slothlet.contextManager.runInContext(wrapper.instanceID, impl, thisArg, args, wrapper);
+					} else {
+						result = impl.apply(thisArg, args);
+					}
+				} else if (impl && typeof impl === "object" && typeof impl.default === "function") {
+					if (wrapper.slothlet.contextManager) {
+						result = wrapper.slothlet.contextManager.runInContext(wrapper.instanceID, impl.default, impl, args, wrapper);
+					} else {
+						result = impl.default.apply(impl, args);
+					}
+				} else {
+					throw new wrapper.SlothletError(
+						"INVALID_CONFIG_NOT_A_FUNCTION",
+						{
+							apiPath: wrapper.____slothletInternal.apiPath,
+							actualType: typeof impl
+						},
+						null,
+						{ validationError: true }
+					);
+				}
+
+				
+				if (result && typeof result === "object" && typeof result.then === "function") {
+					
+					isAsync = true;
+					
+					return result.then(
+						(resolvedResult) => {
+							try {
+								
+								if (hasHooks) {
+									const afterResult = hookManager.executeAfterHooks(wrapper.____slothletInternal.apiPath, resolvedResult, args, api, ctx);
+									const finalResult = afterResult.modified ? afterResult.result : resolvedResult;
+									hookManager.executeAlwaysHooks(wrapper.____slothletInternal.apiPath, args, finalResult, false, [], api, ctx);
+									return finalResult;
+								}
+								return resolvedResult;
+							} catch (error) {
+								
+								
+								
+								if (hasHooks) {
+									const originalError = unwrapError(error);
+									const sourceInfo = {
+										type: "after",
+										timestamp: Date.now(),
+										stack: originalError.stack
+									};
+									hookManager.executeErrorHooks(wrapper.____slothletInternal.apiPath, originalError, sourceInfo, args, api, ctx);
+									hookManager.executeAlwaysHooks(wrapper.____slothletInternal.apiPath, args, undefined, true, [originalError], api, ctx);
+								}
+
+								
+								const suppressErrors = wrapper.slothlet.config?.hook?.suppressErrors === true;
+								if (suppressErrors) {
+									return undefined;
+								}
+
+								throw error;
+							}
+						},
+						(error) => {
+							
+							if (hasHooks && !error[ERROR_HOOK_PROCESSED]) {
+								const originalError = unwrapError(error);
+								const sourceInfo = {
+									type: "function",
+									timestamp: Date.now(),
+									stack: originalError.stack
+								};
+								hookManager.executeErrorHooks(wrapper.____slothletInternal.apiPath, originalError, sourceInfo, args, api, ctx);
+							}
+							
+							if (hasHooks) {
+								const originalError = unwrapError(error);
+								hookManager.executeAlwaysHooks(wrapper.____slothletInternal.apiPath, args, undefined, true, [originalError], api, ctx);
+							}
+
+							
+							const suppressErrors = wrapper.slothlet.config?.hook?.suppressErrors === true;
+							if (suppressErrors) {
+								return undefined;
+							}
+
+							throw error;
+						}
+					);
+				}
+
+				
+				finalResult = result;
+				if (hasHooks) {
+					const afterResult = hookManager.executeAfterHooks(wrapper.____slothletInternal.apiPath, result, args, api, ctx);
+					if (afterResult.modified) {
+						finalResult = afterResult.result;
+					}
+				}
+				return finalResult;
+			} catch (error) {
+				
+				this.lastSyncError = error; 
+				if (hasHooks && !error[ERROR_HOOK_PROCESSED]) {
+					const originalError = unwrapError(error);
+					const sourceInfo = {
+						type: "function",
+						timestamp: Date.now(),
+						stack: originalError.stack
+					};
+					hookManager.executeErrorHooks(wrapper.____slothletInternal.apiPath, originalError, sourceInfo, args, api, ctx);
+				}
+
+				
+				const suppressErrors = wrapper.slothlet.config?.hook?.suppressErrors === true;
+				if (suppressErrors) {
+					
+					return undefined;
+				}
+
+				throw error;
+			} finally {
+				
+				
+				
+				if (hasHooks && !isAsync) {
+					
+					const syncError = this.lastSyncError;
+					this.lastSyncError = null;
+					
+					const resultValue = syncError ? undefined : typeof finalResult !== "undefined" ? finalResult : result;
+					const errors = syncError ? [unwrapError(syncError)] : [];
+					hookManager.executeAlwaysHooks(wrapper.____slothletInternal.apiPath, args, resultValue, !!syncError, errors, api, ctx);
+				}
+			}
+		};
+
+		
+		const hasTrap = (target, prop) => {
+			if (prop === "_materialize") {
+				return true;
+			}
+
+			if (
+				wrapper.____slothletInternal.mode === "lazy" &&
+				!wrapper.____slothletInternal.state.materialized &&
+				!wrapper.____slothletInternal.state.inFlight
+			) {
+				wrapper._materialize();
+			}
+
+			
+			const isInternal = typeof prop === "string" && (prop.startsWith("_") || prop.startsWith("__"));
+			if (!isInternal && hasOwn(wrapper, prop)) {
+				return true;
+			}
+
+			if (
+				wrapper.____slothletInternal.impl &&
+				(typeof wrapper.____slothletInternal.impl === "object" || typeof wrapper.____slothletInternal.impl === "function") &&
+				prop in wrapper.____slothletInternal.impl
+			) {
+				return true;
+			}
+
+			return Object.prototype.hasOwnProperty.call(target, prop);
+		};
+
+		
+		const getOwnPropertyDescriptorTrap = (target, prop) => {
+			if (
+				wrapper.____slothletInternal.mode === "lazy" &&
+				!wrapper.____slothletInternal.state.materialized &&
+				!wrapper.____slothletInternal.state.inFlight
+			) {
+				wrapper._materialize();
+			}
+
+			if (prop === "____slothletInternal") return undefined;
+
+			if (prop === "prototype" && typeof target === "function") {
+				const desc = Object.getOwnPropertyDescriptor(target, "prototype");
+				
+				
+				
+				if (desc) {
+					return desc;
+				}
+			}
+
+			if (Object.prototype.hasOwnProperty.call(target, prop)) {
+				return Object.getOwnPropertyDescriptor(target, prop);
+			}
+
+			
+			const isInternal = typeof prop === "string" && (prop.startsWith("_") || prop.startsWith("__"));
+			if (!isInternal && hasOwn(wrapper, prop)) {
+				const desc = Object.getOwnPropertyDescriptor(wrapper, prop);
+				
+				
+				
+				if (desc) {
+					return desc;
+				}
+			}
+
+			if (
+				wrapper.____slothletInternal.impl &&
+				(typeof wrapper.____slothletInternal.impl === "object" || typeof wrapper.____slothletInternal.impl === "function") &&
+				prop in wrapper.____slothletInternal.impl
+			) {
+				return Object.getOwnPropertyDescriptor(wrapper.____slothletInternal.impl, prop);
+			}
+
+			return undefined;
+		};
+
+		
+		const ownKeysTrap = (target) => {
+			if (
+				wrapper.____slothletInternal.mode === "lazy" &&
+				!wrapper.____slothletInternal.state.materialized &&
+				!wrapper.____slothletInternal.state.inFlight
+			) {
+				wrapper._materialize();
+			}
+
+			const keys = new Set();
+
+			
+			
+			
+			if (typeof target === "function" || (target && target.__isCallable)) {
+				keys.add("prototype");
+				keys.add("length");
+				keys.add("name");
+			}
+
+			
+			for (const key of Reflect.ownKeys(target)) {
+				const descriptor = Object.getOwnPropertyDescriptor(target, key);
+				
+				
+				if (!descriptor.configurable || descriptor.enumerable) {
+					keys.add(key);
+				}
+			}
+
+			
+			
+			if (target !== wrapper) {
+				for (const key of Reflect.ownKeys(wrapper)) {
+					const descriptor = Object.getOwnPropertyDescriptor(wrapper, key);
+					
+					
+					if (descriptor && descriptor.enumerable) {
+						keys.add(key);
+					}
+				}
+			}
+
+			
+			const implKeys =
+				wrapper.____slothletInternal.impl &&
+				(typeof wrapper.____slothletInternal.impl === "object" || typeof wrapper.____slothletInternal.impl === "function")
+					? Reflect.ownKeys(wrapper.____slothletInternal.impl)
+					: [];
+			for (const key of implKeys) {
+				
+				if (key !== "prototype") {
+					keys.add(key);
+				}
+			}
+
+			return Array.from(keys);
+		};
+
+		
+		const setTrap = (target, prop, value) => {
+			if (
+				wrapper.____slothletInternal.mode === "lazy" &&
+				!wrapper.____slothletInternal.state.materialized &&
+				!wrapper.____slothletInternal.state.inFlight
+			) {
+				wrapper._materialize();
+			}
+			
+			
+			
+			
+			if (UnifiedWrapper.INTERNAL_KEYS.has(prop) && prop !== "_materialize") return true;
+
+			const internalKeys = new Set(["_materialize"]);
+			if (!internalKeys.has(prop)) {
+				
+				if (hasOwn(wrapper, prop)) {
+					delete wrapper[prop];
+				}
+				Object.defineProperty(wrapper, prop, {
+					value: value,
+					writable: false,
+					enumerable: true,
+					configurable: true
+				});
+			} else {
+				
+				target[prop] = value;
+			}
+			return true;
+		};
+
+		
+		const deletePropertyTrap = (target, prop) => {
+			
+			
+			
+			
+			
+
+			
+			
+			
+			const internalKeys = new Set([
+				
+				"____slothletInternal",
+				"__impl",
+				"___setImpl",
+				"___resetLazy",
+				"_materialize",
+				"___invalidate",
+				"_impl",
+				"___getState",
+				"__state",
+				
+				"__mode",
+				"__apiPath",
+				"__slothletPath",
+				"__isCallable",
+				"__materializeOnCreate",
+				"__displayName",
+				"__type",
+				"__metadata",
+				"__invalid",
+				"__filePath",
+				"__sourceFolder",
+				"__moduleID",
+				"__materialized",
+				"__inFlight"
+			]);
+			if (internalKeys.has(prop)) {
+				return true; 
+			}
+
+			
+			const isInternal = typeof prop === "string" && (prop.startsWith("_") || prop.startsWith("__"));
+			if (!isInternal && hasOwn(wrapper, prop)) {
+				const childWrapper = wrapper[prop];
+				const childWrapperRaw = resolveWrapper(childWrapper);
+				
+				
+				if (childWrapperRaw) {
+					childWrapperRaw.___invalidate();
+				}
+				const descriptor = Object.getOwnPropertyDescriptor(wrapper, prop);
+				
+				
+				if (descriptor?.configurable) {
+					delete wrapper[prop];
+				}
+			}
+
+			
+			if (
+				wrapper.____slothletInternal.impl &&
+				typeof wrapper.____slothletInternal.impl === "object" &&
+				prop in wrapper.____slothletInternal.impl
+			) {
+				delete wrapper.____slothletInternal.impl[prop];
+			}
+
+			
+			delete target[prop];
+
+			return true;
+		};
+
+		wrapper.____slothletInternal.proxy = new Proxy(proxyTarget, {
+			get: getTrap,
+			apply: applyTrap,
+			has: hasTrap,
+			getOwnPropertyDescriptor: getOwnPropertyDescriptorTrap,
+			ownKeys: ownKeysTrap,
+			set: setTrap,
+			deleteProperty: deletePropertyTrap,
+			getPrototypeOf: () => null
+		});
+
+		_proxyRegistry.set(wrapper.____slothletInternal.proxy, wrapper);
+		return wrapper.____slothletInternal.proxy;
+	}
+}
+
+
+export function resolveWrapper(value) {
+	if (!value) return null;
+	
+	
+	
+	const registered = _proxyRegistry.get(value);
+	if (registered) return registered;
+	
+	
+	
+	if (value instanceof UnifiedWrapper && value.____slothletInternal != null) return value;
+	return null;
+}