@geekmidas/constructs 3.0.7 → 3.0.9

package/dist/lazyAccessors-Bc1u42WC.cjs

@@ -0,0 +1,1971 @@
+const require_Construct = require('./Construct-B14miJ6P.cjs');
+const require_functions = require('./functions-DiaRAdfp.cjs');
+const __geekmidas_schema_conversion = require_Construct.__toESM(require("@geekmidas/schema/conversion"));
+const __geekmidas_schema_openapi = require_Construct.__toESM(require("@geekmidas/schema/openapi"));
+const hono_cookie = require_Construct.__toESM(require("hono/cookie"));
+
+//#region ../../node_modules/.pnpm/lodash.set@4.3.2/node_modules/lodash.set/index.js
+var require_lodash$1 = require_Construct.__commonJS({ "../../node_modules/.pnpm/lodash.set@4.3.2/node_modules/lodash.set/index.js"(exports, module) {
+	/**
+	* lodash (Custom Build) <https://lodash.com/>
+	* Build: `lodash modularize exports="npm" -o ./`
+	* Copyright jQuery Foundation and other contributors <https://jquery.org/>
+	* Released under MIT license <https://lodash.com/license>
+	* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+	* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+	*/
+	/** Used as the `TypeError` message for "Functions" methods. */
+	var FUNC_ERROR_TEXT = "Expected a function";
+	/** Used to stand-in for `undefined` hash values. */
+	var HASH_UNDEFINED = "__lodash_hash_undefined__";
+	/** Used as references for various `Number` constants. */
+	var INFINITY$1 = Infinity, MAX_SAFE_INTEGER$1 = 9007199254740991;
+	/** `Object#toString` result references. */
+	var funcTag$1 = "[object Function]", genTag$1 = "[object GeneratorFunction]", symbolTag$1 = "[object Symbol]";
+	/** Used to match property names within property paths. */
+	var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/, reLeadingDot = /^\./, rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+	/**
+	* Used to match `RegExp`
+	* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+	*/
+	var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+	/** Used to match backslashes in property paths. */
+	var reEscapeChar = /\\(\\)?/g;
+	/** Used to detect host constructors (Safari). */
+	var reIsHostCtor = /^\[object .+?Constructor\]$/;
+	/** Used to detect unsigned integer values. */
+	var reIsUint = /^(?:0|[1-9]\d*)$/;
+	/** Detect free variable `global` from Node.js. */
+	var freeGlobal$1 = typeof global == "object" && global && global.Object === Object && global;
+	/** Detect free variable `self`. */
+	var freeSelf$1 = typeof self == "object" && self && self.Object === Object && self;
+	/** Used as a reference to the global object. */
+	var root$1 = freeGlobal$1 || freeSelf$1 || Function("return this")();
+	/**
+	* Gets the value at `key` of `object`.
+	*
+	* @private
+	* @param {Object} [object] The object to query.
+	* @param {string} key The key of the property to get.
+	* @returns {*} Returns the property value.
+	*/
+	function getValue(object, key) {
+		return object == null ? void 0 : object[key];
+	}
+	/**
+	* Checks if `value` is a host object in IE < 9.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+	*/
+	function isHostObject(value) {
+		var result = false;
+		if (value != null && typeof value.toString != "function") try {
+			result = !!(value + "");
+		} catch (e) {}
+		return result;
+	}
+	/** Used for built-in method references. */
+	var arrayProto = Array.prototype, funcProto = Function.prototype, objectProto$1 = Object.prototype;
+	/** Used to detect overreaching core-js shims. */
+	var coreJsData = root$1["__core-js_shared__"];
+	/** Used to detect methods masquerading as native. */
+	var maskSrcKey = function() {
+		var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+		return uid ? "Symbol(src)_1." + uid : "";
+	}();
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = funcProto.toString;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var objectToString$1 = objectProto$1.toString;
+	/** Used to detect if a method is native. */
+	var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty$1).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+	/** Built-in value references. */
+	var Symbol$1 = root$1.Symbol, splice = arrayProto.splice;
+	var Map$1 = getNative(root$1, "Map"), nativeCreate = getNative(Object, "create");
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+	/**
+	* Creates a hash object.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function Hash(entries) {
+		var index = -1, length = entries ? entries.length : 0;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	/**
+	* Removes all key-value entries from the hash.
+	*
+	* @private
+	* @name clear
+	* @memberOf Hash
+	*/
+	function hashClear() {
+		this.__data__ = nativeCreate ? nativeCreate(null) : {};
+	}
+	/**
+	* Removes `key` and its value from the hash.
+	*
+	* @private
+	* @name delete
+	* @memberOf Hash
+	* @param {Object} hash The hash to modify.
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function hashDelete(key) {
+		return this.has(key) && delete this.__data__[key];
+	}
+	/**
+	* Gets the hash value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf Hash
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function hashGet(key) {
+		var data = this.__data__;
+		if (nativeCreate) {
+			var result = data[key];
+			return result === HASH_UNDEFINED ? void 0 : result;
+		}
+		return hasOwnProperty$1.call(data, key) ? data[key] : void 0;
+	}
+	/**
+	* Checks if a hash value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf Hash
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function hashHas(key) {
+		var data = this.__data__;
+		return nativeCreate ? data[key] !== void 0 : hasOwnProperty$1.call(data, key);
+	}
+	/**
+	* Sets the hash `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf Hash
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the hash instance.
+	*/
+	function hashSet(key, value) {
+		var data = this.__data__;
+		data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+		return this;
+	}
+	Hash.prototype.clear = hashClear;
+	Hash.prototype["delete"] = hashDelete;
+	Hash.prototype.get = hashGet;
+	Hash.prototype.has = hashHas;
+	Hash.prototype.set = hashSet;
+	/**
+	* Creates an list cache object.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function ListCache(entries) {
+		var index = -1, length = entries ? entries.length : 0;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	/**
+	* Removes all key-value entries from the list cache.
+	*
+	* @private
+	* @name clear
+	* @memberOf ListCache
+	*/
+	function listCacheClear() {
+		this.__data__ = [];
+	}
+	/**
+	* Removes `key` and its value from the list cache.
+	*
+	* @private
+	* @name delete
+	* @memberOf ListCache
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function listCacheDelete(key) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		if (index < 0) return false;
+		var lastIndex = data.length - 1;
+		if (index == lastIndex) data.pop();
+		else splice.call(data, index, 1);
+		return true;
+	}
+	/**
+	* Gets the list cache value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf ListCache
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function listCacheGet(key) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		return index < 0 ? void 0 : data[index][1];
+	}
+	/**
+	* Checks if a list cache value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf ListCache
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function listCacheHas(key) {
+		return assocIndexOf(this.__data__, key) > -1;
+	}
+	/**
+	* Sets the list cache `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf ListCache
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the list cache instance.
+	*/
+	function listCacheSet(key, value) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		if (index < 0) data.push([key, value]);
+		else data[index][1] = value;
+		return this;
+	}
+	ListCache.prototype.clear = listCacheClear;
+	ListCache.prototype["delete"] = listCacheDelete;
+	ListCache.prototype.get = listCacheGet;
+	ListCache.prototype.has = listCacheHas;
+	ListCache.prototype.set = listCacheSet;
+	/**
+	* Creates a map cache object to store key-value pairs.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function MapCache(entries) {
+		var index = -1, length = entries ? entries.length : 0;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	/**
+	* Removes all key-value entries from the map.
+	*
+	* @private
+	* @name clear
+	* @memberOf MapCache
+	*/
+	function mapCacheClear() {
+		this.__data__ = {
+			"hash": new Hash(),
+			"map": new (Map$1 || ListCache)(),
+			"string": new Hash()
+		};
+	}
+	/**
+	* Removes `key` and its value from the map.
+	*
+	* @private
+	* @name delete
+	* @memberOf MapCache
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function mapCacheDelete(key) {
+		return getMapData(this, key)["delete"](key);
+	}
+	/**
+	* Gets the map value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf MapCache
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function mapCacheGet(key) {
+		return getMapData(this, key).get(key);
+	}
+	/**
+	* Checks if a map value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf MapCache
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function mapCacheHas(key) {
+		return getMapData(this, key).has(key);
+	}
+	/**
+	* Sets the map `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf MapCache
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the map cache instance.
+	*/
+	function mapCacheSet(key, value) {
+		getMapData(this, key).set(key, value);
+		return this;
+	}
+	MapCache.prototype.clear = mapCacheClear;
+	MapCache.prototype["delete"] = mapCacheDelete;
+	MapCache.prototype.get = mapCacheGet;
+	MapCache.prototype.has = mapCacheHas;
+	MapCache.prototype.set = mapCacheSet;
+	/**
+	* Assigns `value` to `key` of `object` if the existing value is not equivalent
+	* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	* for equality comparisons.
+	*
+	* @private
+	* @param {Object} object The object to modify.
+	* @param {string} key The key of the property to assign.
+	* @param {*} value The value to assign.
+	*/
+	function assignValue(object, key, value) {
+		var objValue = object[key];
+		if (!(hasOwnProperty$1.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) object[key] = value;
+	}
+	/**
+	* Gets the index at which the `key` is found in `array` of key-value pairs.
+	*
+	* @private
+	* @param {Array} array The array to inspect.
+	* @param {*} key The key to search for.
+	* @returns {number} Returns the index of the matched value, else `-1`.
+	*/
+	function assocIndexOf(array, key) {
+		var length = array.length;
+		while (length--) if (eq(array[length][0], key)) return length;
+		return -1;
+	}
+	/**
+	* The base implementation of `_.isNative` without bad shim checks.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a native function,
+	*  else `false`.
+	*/
+	function baseIsNative(value) {
+		if (!isObject$1(value) || isMasked(value)) return false;
+		var pattern = isFunction$1(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
+		return pattern.test(toSource(value));
+	}
+	/**
+	* The base implementation of `_.set`.
+	*
+	* @private
+	* @param {Object} object The object to modify.
+	* @param {Array|string} path The path of the property to set.
+	* @param {*} value The value to set.
+	* @param {Function} [customizer] The function to customize path creation.
+	* @returns {Object} Returns `object`.
+	*/
+	function baseSet(object, path, value, customizer) {
+		if (!isObject$1(object)) return object;
+		path = isKey(path, object) ? [path] : castPath(path);
+		var index = -1, length = path.length, lastIndex = length - 1, nested = object;
+		while (nested != null && ++index < length) {
+			var key = toKey$1(path[index]), newValue = value;
+			if (index != lastIndex) {
+				var objValue = nested[key];
+				newValue = customizer ? customizer(objValue, key, nested) : void 0;
+				if (newValue === void 0) newValue = isObject$1(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
+			}
+			assignValue(nested, key, newValue);
+			nested = nested[key];
+		}
+		return object;
+	}
+	/**
+	* The base implementation of `_.toString` which doesn't convert nullish
+	* values to empty strings.
+	*
+	* @private
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	*/
+	function baseToString(value) {
+		if (typeof value == "string") return value;
+		if (isSymbol$1(value)) return symbolToString ? symbolToString.call(value) : "";
+		var result = value + "";
+		return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
+	}
+	/**
+	* Casts `value` to a path array if it's not one.
+	*
+	* @private
+	* @param {*} value The value to inspect.
+	* @returns {Array} Returns the cast property path array.
+	*/
+	function castPath(value) {
+		return isArray$1(value) ? value : stringToPath(value);
+	}
+	/**
+	* Gets the data for `map`.
+	*
+	* @private
+	* @param {Object} map The map to query.
+	* @param {string} key The reference key.
+	* @returns {*} Returns the map data.
+	*/
+	function getMapData(map, key) {
+		var data = map.__data__;
+		return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+	}
+	/**
+	* Gets the native function at `key` of `object`.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @param {string} key The key of the method to get.
+	* @returns {*} Returns the function if it's native, else `undefined`.
+	*/
+	function getNative(object, key) {
+		var value = getValue(object, key);
+		return baseIsNative(value) ? value : void 0;
+	}
+	/**
+	* Checks if `value` is a valid array-like index.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+	* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+	*/
+	function isIndex(value, length) {
+		length = length == null ? MAX_SAFE_INTEGER$1 : length;
+		return !!length && (typeof value == "number" || reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;
+	}
+	/**
+	* Checks if `value` is a property name and not a property path.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @param {Object} [object] The object to query keys on.
+	* @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+	*/
+	function isKey(value, object) {
+		if (isArray$1(value)) return false;
+		var type = typeof value;
+		if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol$1(value)) return true;
+		return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+	}
+	/**
+	* Checks if `value` is suitable for use as unique object key.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+	*/
+	function isKeyable(value) {
+		var type = typeof value;
+		return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+	}
+	/**
+	* Checks if `func` has its source masked.
+	*
+	* @private
+	* @param {Function} func The function to check.
+	* @returns {boolean} Returns `true` if `func` is masked, else `false`.
+	*/
+	function isMasked(func) {
+		return !!maskSrcKey && maskSrcKey in func;
+	}
+	/**
+	* Converts `string` to a property path array.
+	*
+	* @private
+	* @param {string} string The string to convert.
+	* @returns {Array} Returns the property path array.
+	*/
+	var stringToPath = memoize(function(string) {
+		string = toString(string);
+		var result = [];
+		if (reLeadingDot.test(string)) result.push("");
+		string.replace(rePropName, function(match, number, quote, string$1) {
+			result.push(quote ? string$1.replace(reEscapeChar, "$1") : number || match);
+		});
+		return result;
+	});
+	/**
+	* Converts `value` to a string key if it's not a string or symbol.
+	*
+	* @private
+	* @param {*} value The value to inspect.
+	* @returns {string|symbol} Returns the key.
+	*/
+	function toKey$1(value) {
+		if (typeof value == "string" || isSymbol$1(value)) return value;
+		var result = value + "";
+		return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
+	}
+	/**
+	* Converts `func` to its source code.
+	*
+	* @private
+	* @param {Function} func The function to process.
+	* @returns {string} Returns the source code.
+	*/
+	function toSource(func) {
+		if (func != null) {
+			try {
+				return funcToString.call(func);
+			} catch (e) {}
+			try {
+				return func + "";
+			} catch (e) {}
+		}
+		return "";
+	}
+	/**
+	* Creates a function that memoizes the result of `func`. If `resolver` is
+	* provided, it determines the cache key for storing the result based on the
+	* arguments provided to the memoized function. By default, the first argument
+	* provided to the memoized function is used as the map cache key. The `func`
+	* is invoked with the `this` binding of the memoized function.
+	*
+	* **Note:** The cache is exposed as the `cache` property on the memoized
+	* function. Its creation may be customized by replacing the `_.memoize.Cache`
+	* constructor with one whose instances implement the
+	* [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+	* method interface of `delete`, `get`, `has`, and `set`.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Function
+	* @param {Function} func The function to have its output memoized.
+	* @param {Function} [resolver] The function to resolve the cache key.
+	* @returns {Function} Returns the new memoized function.
+	* @example
+	*
+	* var object = { 'a': 1, 'b': 2 };
+	* var other = { 'c': 3, 'd': 4 };
+	*
+	* var values = _.memoize(_.values);
+	* values(object);
+	* // => [1, 2]
+	*
+	* values(other);
+	* // => [3, 4]
+	*
+	* object.a = 2;
+	* values(object);
+	* // => [1, 2]
+	*
+	* // Modify the result cache.
+	* values.cache.set(object, ['a', 'b']);
+	* values(object);
+	* // => ['a', 'b']
+	*
+	* // Replace `_.memoize.Cache`.
+	* _.memoize.Cache = WeakMap;
+	*/
+	function memoize(func, resolver) {
+		if (typeof func != "function" || resolver && typeof resolver != "function") throw new TypeError(FUNC_ERROR_TEXT);
+		var memoized = function() {
+			var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+			if (cache.has(key)) return cache.get(key);
+			var result = func.apply(this, args);
+			memoized.cache = cache.set(key, result);
+			return result;
+		};
+		memoized.cache = new (memoize.Cache || MapCache)();
+		return memoized;
+	}
+	memoize.Cache = MapCache;
+	/**
+	* Performs a
+	* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	* comparison between two values to determine if they are equivalent.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to compare.
+	* @param {*} other The other value to compare.
+	* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	* @example
+	*
+	* var object = { 'a': 1 };
+	* var other = { 'a': 1 };
+	*
+	* _.eq(object, object);
+	* // => true
+	*
+	* _.eq(object, other);
+	* // => false
+	*
+	* _.eq('a', 'a');
+	* // => true
+	*
+	* _.eq('a', Object('a'));
+	* // => false
+	*
+	* _.eq(NaN, NaN);
+	* // => true
+	*/
+	function eq(value, other) {
+		return value === other || value !== value && other !== other;
+	}
+	/**
+	* Checks if `value` is classified as an `Array` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an array, else `false`.
+	* @example
+	*
+	* _.isArray([1, 2, 3]);
+	* // => true
+	*
+	* _.isArray(document.body.children);
+	* // => false
+	*
+	* _.isArray('abc');
+	* // => false
+	*
+	* _.isArray(_.noop);
+	* // => false
+	*/
+	var isArray$1 = Array.isArray;
+	/**
+	* Checks if `value` is classified as a `Function` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	* @example
+	*
+	* _.isFunction(_);
+	* // => true
+	*
+	* _.isFunction(/abc/);
+	* // => false
+	*/
+	function isFunction$1(value) {
+		var tag = isObject$1(value) ? objectToString$1.call(value) : "";
+		return tag == funcTag$1 || tag == genTag$1;
+	}
+	/**
+	* Checks if `value` is the
+	* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+	* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an object, else `false`.
+	* @example
+	*
+	* _.isObject({});
+	* // => true
+	*
+	* _.isObject([1, 2, 3]);
+	* // => true
+	*
+	* _.isObject(_.noop);
+	* // => true
+	*
+	* _.isObject(null);
+	* // => false
+	*/
+	function isObject$1(value) {
+		var type = typeof value;
+		return !!value && (type == "object" || type == "function");
+	}
+	/**
+	* Checks if `value` is object-like. A value is object-like if it's not `null`
+	* and has a `typeof` result of "object".
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	* @example
+	*
+	* _.isObjectLike({});
+	* // => true
+	*
+	* _.isObjectLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isObjectLike(_.noop);
+	* // => false
+	*
+	* _.isObjectLike(null);
+	* // => false
+	*/
+	function isObjectLike$1(value) {
+		return !!value && typeof value == "object";
+	}
+	/**
+	* Checks if `value` is classified as a `Symbol` primitive or object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+	* @example
+	*
+	* _.isSymbol(Symbol.iterator);
+	* // => true
+	*
+	* _.isSymbol('abc');
+	* // => false
+	*/
+	function isSymbol$1(value) {
+		return typeof value == "symbol" || isObjectLike$1(value) && objectToString$1.call(value) == symbolTag$1;
+	}
+	/**
+	* Converts `value` to a string. An empty string is returned for `null`
+	* and `undefined` values. The sign of `-0` is preserved.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	* @example
+	*
+	* _.toString(null);
+	* // => ''
+	*
+	* _.toString(-0);
+	* // => '-0'
+	*
+	* _.toString([1, 2, 3]);
+	* // => '1,2,3'
+	*/
+	function toString(value) {
+		return value == null ? "" : baseToString(value);
+	}
+	/**
+	* Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
+	* it's created. Arrays are created for missing index properties while objects
+	* are created for all other missing properties. Use `_.setWith` to customize
+	* `path` creation.
+	*
+	* **Note:** This method mutates `object`.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.7.0
+	* @category Object
+	* @param {Object} object The object to modify.
+	* @param {Array|string} path The path of the property to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns `object`.
+	* @example
+	*
+	* var object = { 'a': [{ 'b': { 'c': 3 } }] };
+	*
+	* _.set(object, 'a[0].b.c', 4);
+	* console.log(object.a[0].b.c);
+	* // => 4
+	*
+	* _.set(object, ['x', '0', 'y', 'z'], 5);
+	* console.log(object.x[0].y.z);
+	* // => 5
+	*/
+	function set$1(object, path, value) {
+		return object == null ? object : baseSet(object, path, value);
+	}
+	module.exports = set$1;
+} });
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash.pick@4.4.0/node_modules/lodash.pick/index.js
+var require_lodash = require_Construct.__commonJS({ "../../node_modules/.pnpm/lodash.pick@4.4.0/node_modules/lodash.pick/index.js"(exports, module) {
+	/**
+	* lodash (Custom Build) <https://lodash.com/>
+	* Build: `lodash modularize exports="npm" -o ./`
+	* Copyright jQuery Foundation and other contributors <https://jquery.org/>
+	* Released under MIT license <https://lodash.com/license>
+	* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+	* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+	*/
+	/** Used as references for various `Number` constants. */
+	var INFINITY = Infinity, MAX_SAFE_INTEGER = 9007199254740991;
+	/** `Object#toString` result references. */
+	var argsTag = "[object Arguments]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", symbolTag = "[object Symbol]";
+	/** Detect free variable `global` from Node.js. */
+	var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+	/** Used as a reference to the global object. */
+	var root = freeGlobal || freeSelf || Function("return this")();
+	/**
+	* A faster alternative to `Function#apply`, this function invokes `func`
+	* with the `this` binding of `thisArg` and the arguments of `args`.
+	*
+	* @private
+	* @param {Function} func The function to invoke.
+	* @param {*} thisArg The `this` binding of `func`.
+	* @param {Array} args The arguments to invoke `func` with.
+	* @returns {*} Returns the result of `func`.
+	*/
+	function apply(func, thisArg, args) {
+		switch (args.length) {
+			case 0: return func.call(thisArg);
+			case 1: return func.call(thisArg, args[0]);
+			case 2: return func.call(thisArg, args[0], args[1]);
+			case 3: return func.call(thisArg, args[0], args[1], args[2]);
+		}
+		return func.apply(thisArg, args);
+	}
+	/**
+	* A specialized version of `_.map` for arrays without support for iteratee
+	* shorthands.
+	*
+	* @private
+	* @param {Array} [array] The array to iterate over.
+	* @param {Function} iteratee The function invoked per iteration.
+	* @returns {Array} Returns the new mapped array.
+	*/
+	function arrayMap(array, iteratee) {
+		var index = -1, length = array ? array.length : 0, result = Array(length);
+		while (++index < length) result[index] = iteratee(array[index], index, array);
+		return result;
+	}
+	/**
+	* Appends the elements of `values` to `array`.
+	*
+	* @private
+	* @param {Array} array The array to modify.
+	* @param {Array} values The values to append.
+	* @returns {Array} Returns `array`.
+	*/
+	function arrayPush(array, values) {
+		var index = -1, length = values.length, offset = array.length;
+		while (++index < length) array[offset + index] = values[index];
+		return array;
+	}
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var objectToString = objectProto.toString;
+	/** Built-in value references. */
+	var Symbol = root.Symbol, propertyIsEnumerable = objectProto.propertyIsEnumerable, spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : void 0;
+	var nativeMax = Math.max;
+	/**
+	* The base implementation of `_.flatten` with support for restricting flattening.
+	*
+	* @private
+	* @param {Array} array The array to flatten.
+	* @param {number} depth The maximum recursion depth.
+	* @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+	* @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
+	* @param {Array} [result=[]] The initial result value.
+	* @returns {Array} Returns the new flattened array.
+	*/
+	function baseFlatten(array, depth, predicate, isStrict, result) {
+		var index = -1, length = array.length;
+		predicate || (predicate = isFlattenable);
+		result || (result = []);
+		while (++index < length) {
+			var value = array[index];
+			if (depth > 0 && predicate(value)) if (depth > 1) baseFlatten(value, depth - 1, predicate, isStrict, result);
+			else arrayPush(result, value);
+			else if (!isStrict) result[result.length] = value;
+		}
+		return result;
+	}
+	/**
+	* The base implementation of `_.pick` without support for individual
+	* property identifiers.
+	*
+	* @private
+	* @param {Object} object The source object.
+	* @param {string[]} props The property identifiers to pick.
+	* @returns {Object} Returns the new object.
+	*/
+	function basePick(object, props) {
+		object = Object(object);
+		return basePickBy(object, props, function(value, key) {
+			return key in object;
+		});
+	}
+	/**
+	* The base implementation of  `_.pickBy` without support for iteratee shorthands.
+	*
+	* @private
+	* @param {Object} object The source object.
+	* @param {string[]} props The property identifiers to pick from.
+	* @param {Function} predicate The function invoked per property.
+	* @returns {Object} Returns the new object.
+	*/
+	function basePickBy(object, props, predicate) {
+		var index = -1, length = props.length, result = {};
+		while (++index < length) {
+			var key = props[index], value = object[key];
+			if (predicate(value, key)) result[key] = value;
+		}
+		return result;
+	}
+	/**
+	* The base implementation of `_.rest` which doesn't validate or coerce arguments.
+	*
+	* @private
+	* @param {Function} func The function to apply a rest parameter to.
+	* @param {number} [start=func.length-1] The start position of the rest parameter.
+	* @returns {Function} Returns the new function.
+	*/
+	function baseRest(func, start) {
+		start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+		return function() {
+			var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+			while (++index < length) array[index] = args[start + index];
+			index = -1;
+			var otherArgs = Array(start + 1);
+			while (++index < start) otherArgs[index] = args[index];
+			otherArgs[start] = array;
+			return apply(func, this, otherArgs);
+		};
+	}
+	/**
+	* Checks if `value` is a flattenable `arguments` object or array.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
+	*/
+	function isFlattenable(value) {
+		return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
+	}
+	/**
+	* Converts `value` to a string key if it's not a string or symbol.
+	*
+	* @private
+	* @param {*} value The value to inspect.
+	* @returns {string|symbol} Returns the key.
+	*/
+	function toKey(value) {
+		if (typeof value == "string" || isSymbol(value)) return value;
+		var result = value + "";
+		return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+	}
+	/**
+	* Checks if `value` is likely an `arguments` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an `arguments` object,
+	*  else `false`.
+	* @example
+	*
+	* _.isArguments(function() { return arguments; }());
+	* // => true
+	*
+	* _.isArguments([1, 2, 3]);
+	* // => false
+	*/
+	function isArguments(value) {
+		return isArrayLikeObject(value) && hasOwnProperty.call(value, "callee") && (!propertyIsEnumerable.call(value, "callee") || objectToString.call(value) == argsTag);
+	}
+	/**
+	* Checks if `value` is classified as an `Array` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an array, else `false`.
+	* @example
+	*
+	* _.isArray([1, 2, 3]);
+	* // => true
+	*
+	* _.isArray(document.body.children);
+	* // => false
+	*
+	* _.isArray('abc');
+	* // => false
+	*
+	* _.isArray(_.noop);
+	* // => false
+	*/
+	var isArray = Array.isArray;
+	/**
+	* Checks if `value` is array-like. A value is considered array-like if it's
+	* not a function and has a `value.length` that's an integer greater than or
+	* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+	* @example
+	*
+	* _.isArrayLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isArrayLike(document.body.children);
+	* // => true
+	*
+	* _.isArrayLike('abc');
+	* // => true
+	*
+	* _.isArrayLike(_.noop);
+	* // => false
+	*/
+	function isArrayLike(value) {
+		return value != null && isLength(value.length) && !isFunction(value);
+	}
+	/**
+	* This method is like `_.isArrayLike` except that it also checks if `value`
+	* is an object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an array-like object,
+	*  else `false`.
+	* @example
+	*
+	* _.isArrayLikeObject([1, 2, 3]);
+	* // => true
+	*
+	* _.isArrayLikeObject(document.body.children);
+	* // => true
+	*
+	* _.isArrayLikeObject('abc');
+	* // => false
+	*
+	* _.isArrayLikeObject(_.noop);
+	* // => false
+	*/
+	function isArrayLikeObject(value) {
+		return isObjectLike(value) && isArrayLike(value);
+	}
+	/**
+	* Checks if `value` is classified as a `Function` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	* @example
+	*
+	* _.isFunction(_);
+	* // => true
+	*
+	* _.isFunction(/abc/);
+	* // => false
+	*/
+	function isFunction(value) {
+		var tag = isObject(value) ? objectToString.call(value) : "";
+		return tag == funcTag || tag == genTag;
+	}
+	/**
+	* Checks if `value` is a valid array-like length.
+	*
+	* **Note:** This method is loosely based on
+	* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+	* @example
+	*
+	* _.isLength(3);
+	* // => true
+	*
+	* _.isLength(Number.MIN_VALUE);
+	* // => false
+	*
+	* _.isLength(Infinity);
+	* // => false
+	*
+	* _.isLength('3');
+	* // => false
+	*/
+	function isLength(value) {
+		return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+	}
+	/**
+	* Checks if `value` is the
+	* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+	* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an object, else `false`.
+	* @example
+	*
+	* _.isObject({});
+	* // => true
+	*
+	* _.isObject([1, 2, 3]);
+	* // => true
+	*
+	* _.isObject(_.noop);
+	* // => true
+	*
+	* _.isObject(null);
+	* // => false
+	*/
+	function isObject(value) {
+		var type = typeof value;
+		return !!value && (type == "object" || type == "function");
+	}
+	/**
+	* Checks if `value` is object-like. A value is object-like if it's not `null`
+	* and has a `typeof` result of "object".
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	* @example
+	*
+	* _.isObjectLike({});
+	* // => true
+	*
+	* _.isObjectLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isObjectLike(_.noop);
+	* // => false
+	*
+	* _.isObjectLike(null);
+	* // => false
+	*/
+	function isObjectLike(value) {
+		return !!value && typeof value == "object";
+	}
+	/**
+	* Checks if `value` is classified as a `Symbol` primitive or object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+	* @example
+	*
+	* _.isSymbol(Symbol.iterator);
+	* // => true
+	*
+	* _.isSymbol('abc');
+	* // => false
+	*/
+	function isSymbol(value) {
+		return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
+	}
+	/**
+	* Creates an object composed of the picked `object` properties.
+	*
+	* @static
+	* @since 0.1.0
+	* @memberOf _
+	* @category Object
+	* @param {Object} object The source object.
+	* @param {...(string|string[])} [props] The property identifiers to pick.
+	* @returns {Object} Returns the new object.
+	* @example
+	*
+	* var object = { 'a': 1, 'b': '2', 'c': 3 };
+	*
+	* _.pick(object, ['a', 'c']);
+	* // => { 'a': 1, 'c': 3 }
+	*/
+	var pick$1 = baseRest(function(object, props) {
+		return object == null ? {} : basePick(object, arrayMap(baseFlatten(props, 1), toKey));
+	});
+	module.exports = pick$1;
+} });
+
+//#endregion
+//#region src/endpoints/Endpoint.ts
+var import_lodash = require_Construct.__toESM(require_lodash(), 1);
+var import_lodash$1 = require_Construct.__toESM(require_lodash$1(), 1);
+/**
+* Represents an HTTP endpoint that can handle requests with type-safe input/output validation,
+* dependency injection, session management, and authorization.
+*
+* @template TRoute - The route path string with parameter placeholders (e.g., '/users/:id')
+* @template TMethod - The HTTP method (GET, POST, PUT, DELETE, PATCH)
+* @template TInput - The input schema definition for body, query, and path parameters
+* @template OutSchema - The output schema for response validation
+* @template TServices - Array of service dependencies to inject
+* @template TLogger - The logger instance type
+* @template TSession - The session data type
+*
+* @extends Function - Base function construct for handler execution
+*
+* @example
+* ```typescript
+* const endpoint = new Endpoint({
+*   route: '/users/:id',
+*   method: 'GET',
+*   input: { params: userIdSchema },
+*   output: userSchema,
+*   fn: async ({ params }) => getUserById(params.id)
+* });
+* ```
+*/
+var Endpoint = class Endpoint extends require_functions.Function {
+	operationId;
+	/** The route path pattern with parameter placeholders */
+	route;
+	/** The HTTP method for this endpoint */
+	method;
+	/** Optional description for OpenAPI documentation */
+	description;
+	/** Optional tags for OpenAPI documentation */
+	tags;
+	/** The HTTP success status code to return (default: 200) */
+	status;
+	/**
+	* Response content type for this endpoint. Defaults to `'application/json'`.
+	* Non-JSON types cause adaptors to emit the body as-is with the declared
+	* Content-Type header instead of JSON-serializing.
+	*/
+	responseType;
+	/** Default headers to apply to all responses */
+	defaultHeaders = {};
+	/** Function to extract session data from the request context */
+	getSession = () => ({});
+	/** Function to determine if the request is authorized */
+	authorize = () => true;
+	/** Optional rate limiting configuration */
+	rateLimit;
+	/** Optional authorizer for this endpoint */
+	authorizer;
+	/** Optional actor extractor for audit records */
+	actorExtractor;
+	/** Declarative audit definitions */
+	audits = [];
+	/** RLS configuration for this endpoint */
+	rlsConfig;
+	/** Whether to bypass RLS for this endpoint */
+	rlsBypass;
+	/** The endpoint handler function */
+	endpointFn;
+	/**
+	* Builds a complete OpenAPI 3.1 schema from an array of endpoints.
+	*
+	* @param endpoints - Array of endpoint instances to document
+	* @param options - Optional configuration for OpenAPI generation
+	* @returns OpenAPI 3.1 specification object
+	*
+	* @example
+	* ```typescript
+	* const schema = await Endpoint.buildOpenApiSchema([
+	*   getUserEndpoint,
+	*   createUserEndpoint
+	* ], {
+	*   title: 'User API',
+	*   version: '1.0.0'
+	* });
+	* ```
+	*/
+	static async buildOpenApiSchema(endpoints, options) {
+		return (0, __geekmidas_schema_openapi.buildOpenApiSchema)(endpoints, options);
+	}
+	/**
+	* Gets the full path including HTTP method and route.
+	* @returns Formatted string like 'GET /users/{id}'
+	*/
+	get fullPath() {
+		return `${this.method} ${this._path}`;
+	}
+	/**
+	* Parses and validates input data for a specific input type (body, query, params).
+	*
+	* @param input - The raw input data to validate
+	* @param key - The input type key ('body', 'query', or 'params')
+	* @returns The validated input data for the specified key
+	* @throws {UnprocessableEntityError} When validation fails
+	*/
+	async parseInput(input, key) {
+		const schema = this.input?.[key];
+		return Endpoint.parseSchema(schema, input);
+	}
+	/**
+	* Parses and validates the request body against the body schema.
+	*
+	* @param body - The raw request body to validate
+	* @returns The validated body data
+	* @throws {UnprocessableEntityError} When body validation fails
+	*/
+	async parseBody(body) {
+		return this.parseInput(body, "body");
+	}
+	static isSuccessStatus(status) {
+		return status >= 200 && status < 300;
+	}
+	/**
+	* Creates a case-insensitive header lookup function from a headers object.
+	*
+	* @param headers - Object containing header key-value pairs
+	* @returns Function to retrieve header values by case-insensitive key, or all headers
+	*
+	* @example
+	* ```typescript
+	* const headerFn = Endpoint.createHeaders({ 'Content-Type': 'application/json' });
+	* headerFn('content-type'); // Returns 'application/json'
+	* headerFn(); // Returns { 'content-type': 'application/json' }
+	* ```
+	*/
+	static createHeaders(headers) {
+		const headerMap = /* @__PURE__ */ new Map();
+		for (const [k, v] of Object.entries(headers)) {
+			const key = k.toLowerCase();
+			headerMap.set(key, v);
+		}
+		function get(key) {
+			if (key === void 0) return Object.fromEntries(headerMap.entries());
+			return headerMap.get(key.toLowerCase());
+		}
+		return get;
+	}
+	/**
+	* Parses cookie string and creates a cookie lookup function.
+	*
+	* @param cookieHeader - The Cookie header value
+	* @returns Function to retrieve cookie values by name, or all cookies
+	*
+	* @example
+	* ```typescript
+	* const cookieFn = Endpoint.createCookies('session=abc123; theme=dark');
+	* cookieFn('session'); // Returns 'abc123'
+	* cookieFn(); // Returns { session: 'abc123', theme: 'dark' }
+	* ```
+	*/
+	static createCookies(cookieHeader) {
+		const cookieMap = /* @__PURE__ */ new Map();
+		if (cookieHeader) {
+			const cookies = cookieHeader.split(";");
+			for (const cookie of cookies) {
+				const [name, ...valueParts] = cookie.trim().split("=");
+				if (name) {
+					const value = valueParts.join("=");
+					cookieMap.set(name, decodeURIComponent(value));
+				}
+			}
+		}
+		function get(name) {
+			if (name === void 0) return Object.fromEntries(cookieMap.entries());
+			return cookieMap.get(name);
+		}
+		return get;
+	}
+	/**
+	* Formats a cookie as a Set-Cookie header string.
+	*
+	* @param name - Cookie name
+	* @param value - Cookie value
+	* @param options - Cookie options (httpOnly, secure, sameSite, etc.)
+	* @returns Formatted Set-Cookie header string
+	*
+	* @example
+	* ```typescript
+	* const header = Endpoint.formatCookieHeader('session', 'abc123', {
+	*   httpOnly: true,
+	*   secure: true,
+	*   sameSite: 'strict',
+	*   maxAge: 3600
+	* });
+	* // Returns: "session=abc123; Max-Age=3600; HttpOnly; Secure; SameSite=Strict"
+	* ```
+	*/
+	static formatCookieHeader(name, value, options) {
+		let cookie = `${name}=${value}`;
+		if (options) {
+			if (options.domain) cookie += `; Domain=${options.domain}`;
+			if (options.path) cookie += `; Path=${options.path}`;
+			if (options.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
+			if (options.maxAge !== void 0) cookie += `; Max-Age=${options.maxAge}`;
+			if (options.httpOnly) cookie += "; HttpOnly";
+			if (options.secure) cookie += "; Secure";
+			if (options.sameSite) cookie += `; SameSite=${options.sameSite.charAt(0).toUpperCase() + options.sameSite.slice(1)}`;
+		}
+		return cookie;
+	}
+	/**
+	* Extracts and refines input data from the endpoint context.
+	*
+	* @param ctx - The endpoint execution context
+	* @returns Object containing only the input data (body, query, params)
+	* @internal
+	*/
+	refineInput(ctx) {
+		const input = (0, import_lodash.default)(ctx, [
+			"body",
+			"query",
+			"params"
+		]);
+		return input;
+	}
+	handler = (ctx, response) => {
+		for (const [key, value] of Object.entries(this.defaultHeaders)) response.header(key, value);
+		const handlerCtx = {
+			...this.refineInput(ctx),
+			services: ctx.services,
+			logger: ctx.logger,
+			header: ctx.header,
+			cookie: ctx.cookie,
+			session: ctx.session,
+			..."auditor" in ctx && { auditor: ctx.auditor },
+			..."db" in ctx && { db: ctx.db }
+		};
+		return this.endpointFn(handlerCtx, response);
+	};
+	/**
+	* Type guard to check if an object is an Endpoint instance.
+	*
+	* @param obj - The object to check
+	* @returns True if the object is an Endpoint
+	*/
+	static isEndpoint(obj) {
+		return Boolean(obj && obj.__IS_FUNCTION__ === true && obj.type === require_Construct.ConstructType.Endpoint);
+	}
+	/**
+	* Helper to check if response has metadata
+	*/
+	static hasMetadata(response) {
+		return response !== null && typeof response === "object" && "data" in response && "metadata" in response;
+	}
+	/**
+	* Converts Express-style route params to OpenAPI format.
+	* @returns Route with ':param' converted to '{param}'
+	* @internal
+	*/
+	get _path() {
+		return this.route.replace(/:(\w+)/g, "{$1}");
+	}
+	/**
+	* Generates OpenAPI 3.1 schema for this endpoint.
+	*
+	* @returns OpenAPI route definition with operation details
+	*/
+	async toOpenApi3Route(componentCollector) {
+		const operation = {
+			operationId: this.operationId,
+			...this.description && { description: this.description },
+			...this.tags && this.tags.length > 0 && { tags: this.tags },
+			responses: { "200": { description: "Successful response" } }
+		};
+		if (this.outputSchema) {
+			const responseSchema = await (0, __geekmidas_schema_conversion.convertSchemaWithComponents)(this.outputSchema, componentCollector);
+			if (responseSchema) (0, import_lodash$1.default)(operation, [
+				"responses",
+				"200",
+				"content",
+				this.responseType,
+				"schema"
+			], responseSchema);
+		}
+		const pathParameters = [];
+		const queryParameters = [];
+		if (this.input && typeof this.input === "object") {
+			if ([
+				"POST",
+				"PUT",
+				"PATCH"
+			].includes(this.method) && "body" in this.input && this.input.body) {
+				const bodySchema = await (0, __geekmidas_schema_conversion.convertSchemaWithComponents)(this.input.body, componentCollector);
+				if (bodySchema) (0, import_lodash$1.default)(operation, ["requestBody"], {
+					required: true,
+					content: { "application/json": { schema: bodySchema } }
+				});
+			}
+			if ("params" in this.input && this.input.params) {
+				const paramsSchema = await (0, __geekmidas_schema_conversion.convertStandardSchemaToJsonSchema)(this.input.params);
+				if (paramsSchema && paramsSchema.type === "object" && paramsSchema.properties) for (const [name, schema] of Object.entries(paramsSchema.properties)) pathParameters.push({
+					name,
+					in: "path",
+					required: paramsSchema.required?.includes(name) ?? true,
+					schema
+				});
+			}
+			if ("query" in this.input && this.input.query) {
+				const querySchema = await (0, __geekmidas_schema_conversion.convertStandardSchemaToJsonSchema)(this.input.query);
+				if (querySchema && querySchema.type === "object" && querySchema.properties) for (const [name, schema] of Object.entries(querySchema.properties)) queryParameters.push({
+					name,
+					in: "query",
+					required: querySchema.required?.includes(name) ?? false,
+					schema
+				});
+			}
+		}
+		if (queryParameters.length > 0) operation.parameters = queryParameters;
+		const routeObject = {};
+		if (pathParameters.length > 0) routeObject.parameters = pathParameters;
+		routeObject[this.method.toLowerCase()] = operation;
+		return { [this._path]: routeObject };
+	}
+	/**
+	* Creates a new Endpoint instance.
+	*
+	* @param options - Configuration options for the endpoint
+	* @param options.fn - The handler function to execute
+	* @param options.method - HTTP method
+	* @param options.route - Route path with parameter placeholders
+	* @param options.description - Optional description for documentation
+	* @param options.input - Input schemas for validation
+	* @param options.logger - Logger instance
+	* @param options.output - Output schema for response validation
+	* @param options.services - Service dependencies
+	* @param options.timeout - Execution timeout in milliseconds
+	* @param options.getSession - Session extraction function
+	* @param options.authorize - Authorization check function
+	* @param options.status - Success HTTP status code (default: 200)
+	* @param options.authorizer - Optional authorizer configuration
+	*/
+	constructor({ fn, method, route, description, tags, input, logger, output: outputSchema, services, timeout, memorySize, getSession, authorize, rateLimit, status = SuccessStatus.OK, publisherService, events, authorizer, auditorStorageService, actorExtractor, audits, databaseService, rlsConfig, rlsBypass, responseType }) {
+		super(fn, timeout, require_Construct.ConstructType.Endpoint, input, outputSchema, services, logger, publisherService, events, memorySize, auditorStorageService);
+		this.route = route;
+		this.method = method;
+		this.description = description;
+		this.tags = tags;
+		this.status = status;
+		this.responseType = responseType ?? "application/json";
+		this.endpointFn = fn;
+		if (getSession) this.getSession = getSession;
+		if (authorize) this.authorize = authorize;
+		if (rateLimit) this.rateLimit = rateLimit;
+		if (authorizer) this.authorizer = authorizer;
+		if (actorExtractor) this.actorExtractor = actorExtractor;
+		if (audits) this.audits = audits;
+		if (databaseService) this.databaseService = databaseService;
+		if (rlsConfig) this.rlsConfig = rlsConfig;
+		if (rlsBypass) this.rlsBypass = rlsBypass;
+	}
+};
+/**
+* Response builder for fluent API in handlers
+*/
+var ResponseBuilder = class {
+	metadata = {
+		headers: {},
+		cookies: /* @__PURE__ */ new Map()
+	};
+	header(key, value) {
+		this.metadata.headers[key] = value;
+		return this;
+	}
+	cookie(name, value, options) {
+		this.metadata.cookies?.set(name, {
+			value,
+			options
+		});
+		return this;
+	}
+	deleteCookie(name, options) {
+		this.metadata.cookies?.set(name, {
+			value: "",
+			options: {
+				...options,
+				maxAge: 0,
+				expires: /* @__PURE__ */ new Date(0)
+			}
+		});
+		return this;
+	}
+	status(code) {
+		this.metadata.status = code;
+		return this;
+	}
+	send(data) {
+		return {
+			data,
+			metadata: this.metadata
+		};
+	}
+	getMetadata() {
+		return this.metadata;
+	}
+};
+/**
+* HTTP success status codes that can be returned by endpoints.
+*/
+let SuccessStatus = /* @__PURE__ */ function(SuccessStatus$1) {
+	/** Standard response for successful HTTP requests */
+	SuccessStatus$1[SuccessStatus$1["OK"] = 200] = "OK";
+	/** Request has been fulfilled and resulted in a new resource being created */
+	SuccessStatus$1[SuccessStatus$1["Created"] = 201] = "Created";
+	/** Request has been accepted for processing, but processing is not complete */
+	SuccessStatus$1[SuccessStatus$1["Accepted"] = 202] = "Accepted";
+	/** Server successfully processed the request but is not returning any content */
+	SuccessStatus$1[SuccessStatus$1["NoContent"] = 204] = "NoContent";
+	/** Server successfully processed the request and is not returning any content, client should reset the document view */
+	SuccessStatus$1[SuccessStatus$1["ResetContent"] = 205] = "ResetContent";
+	/** Server is delivering only part of the resource due to a range header */
+	SuccessStatus$1[SuccessStatus$1["PartialContent"] = 206] = "PartialContent";
+	return SuccessStatus$1;
+}({});
+
+//#endregion
+//#region src/publisher.ts
+async function publishEvents(logger, serviceDiscovery, ev = [], response, publisherService) {
+	try {
+		if (!ev?.length) {
+			logger.debug("No events to publish");
+			return;
+		}
+		if (!publisherService) {
+			logger.warn("No publisher service available");
+			return;
+		}
+		const services = await serviceDiscovery.register([publisherService]);
+		const publisher = services[publisherService.serviceName];
+		const events = [];
+		for (const { when, payload, type,...e } of ev) {
+			logger.debug({ event: type }, "Processing event");
+			const resolvedPayload = await payload(response);
+			const event = {
+				...e,
+				type,
+				payload: resolvedPayload
+			};
+			if (!when || when(response)) events.push(event);
+		}
+		if (events.length) {
+			logger.debug({ eventCount: ev.length }, "Publishing events");
+			await publisher.publish(events).catch((err) => {
+				logger.error(err, "Failed to publish events");
+			});
+		}
+	} catch (error) {
+		logger.error(error, "Something went wrong publishing events");
+	}
+}
+async function publishConstructEvents(construct, response, serviceDiscovery, logger = construct.logger) {
+	return publishEvents(logger, serviceDiscovery, construct.events, response, construct.publisherService);
+}
+
+//#endregion
+//#region src/endpoints/lazyAccessors.ts
+/**
+* Create a lazy header accessor for Hono.
+* Uses `c.req.header(name)` for single lookups (native, case-insensitive).
+* Only calls `c.req.header()` to get all headers when needed.
+*/
+function createHonoHeaders(c) {
+	let allHeaders = null;
+	return (key) => {
+		if (key !== void 0) return c.req.header(key);
+		if (!allHeaders) allHeaders = c.req.header();
+		return allHeaders;
+	};
+}
+/**
+* Create a lazy cookie accessor for Hono.
+* Uses `getCookie(c, name)` for single lookups (native).
+* Only parses the cookie header when all cookies are requested.
+*/
+function createHonoCookies(c) {
+	let allCookies = null;
+	return (name) => {
+		if (name !== void 0) return (0, hono_cookie.getCookie)(c, name);
+		if (!allCookies) {
+			allCookies = {};
+			const cookieHeader = c.req.header("cookie");
+			if (cookieHeader) for (const part of cookieHeader.split(";")) {
+				const trimmed = part.trim();
+				const eqIndex = trimmed.indexOf("=");
+				if (eqIndex > 0) {
+					const key = trimmed.slice(0, eqIndex);
+					const value = trimmed.slice(eqIndex + 1);
+					allCookies[key] = value;
+				}
+			}
+		}
+		return allCookies;
+	};
+}
+/**
+* Create a lazy header accessor for API Gateway events.
+* Handles case-insensitive lookups.
+*/
+function createApiGatewayHeaders(headers) {
+	let normalizedHeaders = null;
+	const normalize = () => {
+		if (!normalizedHeaders) {
+			normalizedHeaders = {};
+			if (headers) {
+				for (const [k, v] of Object.entries(headers)) if (v !== void 0) normalizedHeaders[k.toLowerCase()] = v;
+			}
+		}
+		return normalizedHeaders;
+	};
+	return (key) => {
+		if (key !== void 0) {
+			if (headers) {
+				const direct = headers[key] ?? headers[key.toLowerCase()];
+				if (direct !== void 0) return direct;
+				return normalize()[key.toLowerCase()];
+			}
+			return void 0;
+		}
+		return normalize();
+	};
+}
+/**
+* Create a lazy cookie accessor for API Gateway events.
+* Decodes URL-encoded values to match browser behavior.
+*/
+function createApiGatewayCookies(cookies, cookieHeader) {
+	let parsed = null;
+	const parse = () => {
+		if (!parsed) {
+			parsed = {};
+			if (cookies) for (const cookie of cookies) {
+				const eqIndex = cookie.indexOf("=");
+				if (eqIndex > 0) {
+					const key = cookie.slice(0, eqIndex);
+					const value = cookie.slice(eqIndex + 1);
+					parsed[key] = decodeURIComponent(value);
+				}
+			}
+			else if (cookieHeader) for (const part of cookieHeader.split(";")) {
+				const trimmed = part.trim();
+				const eqIndex = trimmed.indexOf("=");
+				if (eqIndex > 0) {
+					const key = trimmed.slice(0, eqIndex);
+					const value = trimmed.slice(eqIndex + 1);
+					parsed[key] = decodeURIComponent(value);
+				}
+			}
+		}
+		return parsed;
+	};
+	return (name) => {
+		if (name !== void 0) return parse()[name];
+		return parse();
+	};
+}
+/**
+* Create a lazy header accessor for plain object headers (test adaptor, etc).
+* Headers are already available as an object, just provide lazy access.
+*/
+function createObjectHeaders(headers) {
+	let normalized = null;
+	return (key) => {
+		if (key !== void 0) {
+			if (headers) {
+				const direct = headers[key] ?? headers[key.toLowerCase()];
+				if (direct !== void 0) return direct;
+			}
+			if (!normalized && headers) {
+				normalized = {};
+				for (const [k, v] of Object.entries(headers)) normalized[k.toLowerCase()] = v;
+			}
+			return normalized?.[key.toLowerCase()];
+		}
+		if (!normalized && headers) {
+			normalized = {};
+			for (const [k, v] of Object.entries(headers)) normalized[k.toLowerCase()] = v;
+		}
+		return normalized ?? {};
+	};
+}
+/**
+* Create a lazy cookie accessor from a cookie header string.
+* Decodes URL-encoded values to match browser behavior.
+*/
+function createCookieHeaderAccessor(cookieHeader) {
+	let parsed = null;
+	const parse = () => {
+		if (!parsed) {
+			parsed = {};
+			if (cookieHeader) for (const part of cookieHeader.split(";")) {
+				const trimmed = part.trim();
+				const eqIndex = trimmed.indexOf("=");
+				if (eqIndex > 0) {
+					const key = trimmed.slice(0, eqIndex);
+					const value = trimmed.slice(eqIndex + 1);
+					parsed[key] = decodeURIComponent(value);
+				}
+			}
+		}
+		return parsed;
+	};
+	return (name) => {
+		if (name !== void 0) return parse()[name];
+		return parse();
+	};
+}
+/**
+* Create a no-op header accessor (for minimal endpoints that don't use headers).
+*/
+function createNoopHeaders() {
+	return (key) => {
+		if (key !== void 0) return void 0;
+		return {};
+	};
+}
+/**
+* Create a no-op cookie accessor (for minimal endpoints that don't use cookies).
+*/
+function createNoopCookies() {
+	return (name) => {
+		if (name !== void 0) return void 0;
+		return {};
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'Endpoint', {
+  enumerable: true,
+  get: function () {
+    return Endpoint;
+  }
+});
+Object.defineProperty(exports, 'ResponseBuilder', {
+  enumerable: true,
+  get: function () {
+    return ResponseBuilder;
+  }
+});
+Object.defineProperty(exports, 'createApiGatewayCookies', {
+  enumerable: true,
+  get: function () {
+    return createApiGatewayCookies;
+  }
+});
+Object.defineProperty(exports, 'createApiGatewayHeaders', {
+  enumerable: true,
+  get: function () {
+    return createApiGatewayHeaders;
+  }
+});
+Object.defineProperty(exports, 'createCookieHeaderAccessor', {
+  enumerable: true,
+  get: function () {
+    return createCookieHeaderAccessor;
+  }
+});
+Object.defineProperty(exports, 'createHonoCookies', {
+  enumerable: true,
+  get: function () {
+    return createHonoCookies;
+  }
+});
+Object.defineProperty(exports, 'createHonoHeaders', {
+  enumerable: true,
+  get: function () {
+    return createHonoHeaders;
+  }
+});
+Object.defineProperty(exports, 'createNoopCookies', {
+  enumerable: true,
+  get: function () {
+    return createNoopCookies;
+  }
+});
+Object.defineProperty(exports, 'createNoopHeaders', {
+  enumerable: true,
+  get: function () {
+    return createNoopHeaders;
+  }
+});
+Object.defineProperty(exports, 'createObjectHeaders', {
+  enumerable: true,
+  get: function () {
+    return createObjectHeaders;
+  }
+});
+Object.defineProperty(exports, 'publishConstructEvents', {
+  enumerable: true,
+  get: function () {
+    return publishConstructEvents;
+  }
+});
+Object.defineProperty(exports, 'publishEvents', {
+  enumerable: true,
+  get: function () {
+    return publishEvents;
+  }
+});
+Object.defineProperty(exports, 'require_lodash', {
+  enumerable: true,
+  get: function () {
+    return require_lodash$1;
+  }
+});
+//# sourceMappingURL=lazyAccessors-Bc1u42WC.cjs.map