@keystrokehq/cli 0.0.1

package/dist/projects-CHkRE9rS.mjs

@@ -0,0 +1,1574 @@
+#!/usr/bin/env node
+
+import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-CH6r78ws.mjs";
+import { a as require_type, r as require_call_bind_apply_helpers, t as require_get_intrinsic } from "./get-intrinsic-zLxwtrLK.mjs";
+import { ZodError, z } from "zod";
+import ky from "ky";
+z.object({
+	SERVER_URL: z.url(),
+	KEYSTROKE_API_KEY: z.string().min(1)
+});
+/** Lenient env for client - only requires what's needed when not overridden by config */
+const clientEnvSchema = z.object({
+	SERVER_URL: z.url().optional(),
+	KEYSTROKE_API_KEY: z.string().min(1).optional(),
+	KEYSTROKE_ORG_ID: z.string().min(1).optional()
+});
+function getClientEnv() {
+	return clientEnvSchema.parse(process.env);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/util.inspect.js
+var require_util_inspect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = __require("util").inspect;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/index.js
+var require_object_inspect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hasMap = typeof Map === "function" && Map.prototype;
+	var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null;
+	var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null;
+	var mapForEach = hasMap && Map.prototype.forEach;
+	var hasSet = typeof Set === "function" && Set.prototype;
+	var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null;
+	var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null;
+	var setForEach = hasSet && Set.prototype.forEach;
+	var weakMapHas = typeof WeakMap === "function" && WeakMap.prototype ? WeakMap.prototype.has : null;
+	var weakSetHas = typeof WeakSet === "function" && WeakSet.prototype ? WeakSet.prototype.has : null;
+	var weakRefDeref = typeof WeakRef === "function" && WeakRef.prototype ? WeakRef.prototype.deref : null;
+	var booleanValueOf = Boolean.prototype.valueOf;
+	var objectToString = Object.prototype.toString;
+	var functionToString = Function.prototype.toString;
+	var $match = String.prototype.match;
+	var $slice = String.prototype.slice;
+	var $replace = String.prototype.replace;
+	var $toUpperCase = String.prototype.toUpperCase;
+	var $toLowerCase = String.prototype.toLowerCase;
+	var $test = RegExp.prototype.test;
+	var $concat = Array.prototype.concat;
+	var $join = Array.prototype.join;
+	var $arrSlice = Array.prototype.slice;
+	var $floor = Math.floor;
+	var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null;
+	var gOPS = Object.getOwnPropertySymbols;
+	var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null;
+	var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object";
+	var toStringTag = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null;
+	var isEnumerable = Object.prototype.propertyIsEnumerable;
+	var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {
+		return O.__proto__;
+	} : null);
+	function addNumericSeparator(num, str) {
+		if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) return str;
+		var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
+		if (typeof num === "number") {
+			var int = num < 0 ? -$floor(-num) : $floor(num);
+			if (int !== num) {
+				var intStr = String(int);
+				var dec = $slice.call(str, intStr.length + 1);
+				return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, "");
+			}
+		}
+		return $replace.call(str, sepRegex, "$&_");
+	}
+	var utilInspect = require_util_inspect();
+	var inspectCustom = utilInspect.custom;
+	var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
+	var quotes = {
+		__proto__: null,
+		"double": "\"",
+		single: "'"
+	};
+	var quoteREs = {
+		__proto__: null,
+		"double": /(["\\])/g,
+		single: /(['\\])/g
+	};
+	module.exports = function inspect_(obj, options, depth, seen) {
+		var opts = options || {};
+		if (has(opts, "quoteStyle") && !has(quotes, opts.quoteStyle)) throw new TypeError("option \"quoteStyle\" must be \"single\" or \"double\"");
+		if (has(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) throw new TypeError("option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`");
+		var customInspect = has(opts, "customInspect") ? opts.customInspect : true;
+		if (typeof customInspect !== "boolean" && customInspect !== "symbol") throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
+		if (has(opts, "indent") && opts.indent !== null && opts.indent !== "	" && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) throw new TypeError("option \"indent\" must be \"\\t\", an integer > 0, or `null`");
+		if (has(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") throw new TypeError("option \"numericSeparator\", if provided, must be `true` or `false`");
+		var numericSeparator = opts.numericSeparator;
+		if (typeof obj === "undefined") return "undefined";
+		if (obj === null) return "null";
+		if (typeof obj === "boolean") return obj ? "true" : "false";
+		if (typeof obj === "string") return inspectString(obj, opts);
+		if (typeof obj === "number") {
+			if (obj === 0) return Infinity / obj > 0 ? "0" : "-0";
+			var str = String(obj);
+			return numericSeparator ? addNumericSeparator(obj, str) : str;
+		}
+		if (typeof obj === "bigint") {
+			var bigIntStr = String(obj) + "n";
+			return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
+		}
+		var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth;
+		if (typeof depth === "undefined") depth = 0;
+		if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") return isArray(obj) ? "[Array]" : "[Object]";
+		var indent = getIndent(opts, depth);
+		if (typeof seen === "undefined") seen = [];
+		else if (indexOf(seen, obj) >= 0) return "[Circular]";
+		function inspect(value, from, noIndent) {
+			if (from) {
+				seen = $arrSlice.call(seen);
+				seen.push(from);
+			}
+			if (noIndent) {
+				var newOpts = { depth: opts.depth };
+				if (has(opts, "quoteStyle")) newOpts.quoteStyle = opts.quoteStyle;
+				return inspect_(value, newOpts, depth + 1, seen);
+			}
+			return inspect_(value, opts, depth + 1, seen);
+		}
+		if (typeof obj === "function" && !isRegExp(obj)) {
+			var name = nameOf(obj);
+			var keys = arrObjKeys(obj, inspect);
+			return "[Function" + (name ? ": " + name : " (anonymous)") + "]" + (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : "");
+		}
+		if (isSymbol(obj)) {
+			var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj);
+			return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString;
+		}
+		if (isElement(obj)) {
+			var s = "<" + $toLowerCase.call(String(obj.nodeName));
+			var attrs = obj.attributes || [];
+			for (var i = 0; i < attrs.length; i++) s += " " + attrs[i].name + "=" + wrapQuotes(quote(attrs[i].value), "double", opts);
+			s += ">";
+			if (obj.childNodes && obj.childNodes.length) s += "...";
+			s += "</" + $toLowerCase.call(String(obj.nodeName)) + ">";
+			return s;
+		}
+		if (isArray(obj)) {
+			if (obj.length === 0) return "[]";
+			var xs = arrObjKeys(obj, inspect);
+			if (indent && !singleLineValues(xs)) return "[" + indentedJoin(xs, indent) + "]";
+			return "[ " + $join.call(xs, ", ") + " ]";
+		}
+		if (isError(obj)) {
+			var parts = arrObjKeys(obj, inspect);
+			if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect(obj.cause), parts), ", ") + " }";
+			if (parts.length === 0) return "[" + String(obj) + "]";
+			return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }";
+		}
+		if (typeof obj === "object" && customInspect) {
+			if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) return utilInspect(obj, { depth: maxDepth - depth });
+			else if (customInspect !== "symbol" && typeof obj.inspect === "function") return obj.inspect();
+		}
+		if (isMap(obj)) {
+			var mapParts = [];
+			if (mapForEach) mapForEach.call(obj, function(value, key) {
+				mapParts.push(inspect(key, obj, true) + " => " + inspect(value, obj));
+			});
+			return collectionOf("Map", mapSize.call(obj), mapParts, indent);
+		}
+		if (isSet(obj)) {
+			var setParts = [];
+			if (setForEach) setForEach.call(obj, function(value) {
+				setParts.push(inspect(value, obj));
+			});
+			return collectionOf("Set", setSize.call(obj), setParts, indent);
+		}
+		if (isWeakMap(obj)) return weakCollectionOf("WeakMap");
+		if (isWeakSet(obj)) return weakCollectionOf("WeakSet");
+		if (isWeakRef(obj)) return weakCollectionOf("WeakRef");
+		if (isNumber(obj)) return markBoxed(inspect(Number(obj)));
+		if (isBigInt(obj)) return markBoxed(inspect(bigIntValueOf.call(obj)));
+		if (isBoolean(obj)) return markBoxed(booleanValueOf.call(obj));
+		if (isString(obj)) return markBoxed(inspect(String(obj)));
+		if (typeof window !== "undefined" && obj === window) return "{ [object Window] }";
+		if (typeof globalThis !== "undefined" && obj === globalThis || typeof global !== "undefined" && obj === global) return "{ [object globalThis] }";
+		if (!isDate(obj) && !isRegExp(obj)) {
+			var ys = arrObjKeys(obj, inspect);
+			var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
+			var protoTag = obj instanceof Object ? "" : "null prototype";
+			var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
+			var tag = (isPlainObject || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "") + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
+			if (ys.length === 0) return tag + "{}";
+			if (indent) return tag + "{" + indentedJoin(ys, indent) + "}";
+			return tag + "{ " + $join.call(ys, ", ") + " }";
+		}
+		return String(obj);
+	};
+	function wrapQuotes(s, defaultStyle, opts) {
+		var quoteChar = quotes[opts.quoteStyle || defaultStyle];
+		return quoteChar + s + quoteChar;
+	}
+	function quote(s) {
+		return $replace.call(String(s), /"/g, "&quot;");
+	}
+	function canTrustToString(obj) {
+		return !toStringTag || !(typeof obj === "object" && (toStringTag in obj || typeof obj[toStringTag] !== "undefined"));
+	}
+	function isArray(obj) {
+		return toStr(obj) === "[object Array]" && canTrustToString(obj);
+	}
+	function isDate(obj) {
+		return toStr(obj) === "[object Date]" && canTrustToString(obj);
+	}
+	function isRegExp(obj) {
+		return toStr(obj) === "[object RegExp]" && canTrustToString(obj);
+	}
+	function isError(obj) {
+		return toStr(obj) === "[object Error]" && canTrustToString(obj);
+	}
+	function isString(obj) {
+		return toStr(obj) === "[object String]" && canTrustToString(obj);
+	}
+	function isNumber(obj) {
+		return toStr(obj) === "[object Number]" && canTrustToString(obj);
+	}
+	function isBoolean(obj) {
+		return toStr(obj) === "[object Boolean]" && canTrustToString(obj);
+	}
+	function isSymbol(obj) {
+		if (hasShammedSymbols) return obj && typeof obj === "object" && obj instanceof Symbol;
+		if (typeof obj === "symbol") return true;
+		if (!obj || typeof obj !== "object" || !symToString) return false;
+		try {
+			symToString.call(obj);
+			return true;
+		} catch (e) {}
+		return false;
+	}
+	function isBigInt(obj) {
+		if (!obj || typeof obj !== "object" || !bigIntValueOf) return false;
+		try {
+			bigIntValueOf.call(obj);
+			return true;
+		} catch (e) {}
+		return false;
+	}
+	var hasOwn = Object.prototype.hasOwnProperty || function(key) {
+		return key in this;
+	};
+	function has(obj, key) {
+		return hasOwn.call(obj, key);
+	}
+	function toStr(obj) {
+		return objectToString.call(obj);
+	}
+	function nameOf(f) {
+		if (f.name) return f.name;
+		var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
+		if (m) return m[1];
+		return null;
+	}
+	function indexOf(xs, x) {
+		if (xs.indexOf) return xs.indexOf(x);
+		for (var i = 0, l = xs.length; i < l; i++) if (xs[i] === x) return i;
+		return -1;
+	}
+	function isMap(x) {
+		if (!mapSize || !x || typeof x !== "object") return false;
+		try {
+			mapSize.call(x);
+			try {
+				setSize.call(x);
+			} catch (s) {
+				return true;
+			}
+			return x instanceof Map;
+		} catch (e) {}
+		return false;
+	}
+	function isWeakMap(x) {
+		if (!weakMapHas || !x || typeof x !== "object") return false;
+		try {
+			weakMapHas.call(x, weakMapHas);
+			try {
+				weakSetHas.call(x, weakSetHas);
+			} catch (s) {
+				return true;
+			}
+			return x instanceof WeakMap;
+		} catch (e) {}
+		return false;
+	}
+	function isWeakRef(x) {
+		if (!weakRefDeref || !x || typeof x !== "object") return false;
+		try {
+			weakRefDeref.call(x);
+			return true;
+		} catch (e) {}
+		return false;
+	}
+	function isSet(x) {
+		if (!setSize || !x || typeof x !== "object") return false;
+		try {
+			setSize.call(x);
+			try {
+				mapSize.call(x);
+			} catch (m) {
+				return true;
+			}
+			return x instanceof Set;
+		} catch (e) {}
+		return false;
+	}
+	function isWeakSet(x) {
+		if (!weakSetHas || !x || typeof x !== "object") return false;
+		try {
+			weakSetHas.call(x, weakSetHas);
+			try {
+				weakMapHas.call(x, weakMapHas);
+			} catch (s) {
+				return true;
+			}
+			return x instanceof WeakSet;
+		} catch (e) {}
+		return false;
+	}
+	function isElement(x) {
+		if (!x || typeof x !== "object") return false;
+		if (typeof HTMLElement !== "undefined" && x instanceof HTMLElement) return true;
+		return typeof x.nodeName === "string" && typeof x.getAttribute === "function";
+	}
+	function inspectString(str, opts) {
+		if (str.length > opts.maxStringLength) {
+			var remaining = str.length - opts.maxStringLength;
+			var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : "");
+			return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
+		}
+		var quoteRE = quoteREs[opts.quoteStyle || "single"];
+		quoteRE.lastIndex = 0;
+		return wrapQuotes($replace.call($replace.call(str, quoteRE, "\\$1"), /[\x00-\x1f]/g, lowbyte), "single", opts);
+	}
+	function lowbyte(c) {
+		var n = c.charCodeAt(0);
+		var x = {
+			8: "b",
+			9: "t",
+			10: "n",
+			12: "f",
+			13: "r"
+		}[n];
+		if (x) return "\\" + x;
+		return "\\x" + (n < 16 ? "0" : "") + $toUpperCase.call(n.toString(16));
+	}
+	function markBoxed(str) {
+		return "Object(" + str + ")";
+	}
+	function weakCollectionOf(type) {
+		return type + " { ? }";
+	}
+	function collectionOf(type, size, entries, indent) {
+		var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
+		return type + " (" + size + ") {" + joinedEntries + "}";
+	}
+	function singleLineValues(xs) {
+		for (var i = 0; i < xs.length; i++) if (indexOf(xs[i], "\n") >= 0) return false;
+		return true;
+	}
+	function getIndent(opts, depth) {
+		var baseIndent;
+		if (opts.indent === "	") baseIndent = "	";
+		else if (typeof opts.indent === "number" && opts.indent > 0) baseIndent = $join.call(Array(opts.indent + 1), " ");
+		else return null;
+		return {
+			base: baseIndent,
+			prev: $join.call(Array(depth + 1), baseIndent)
+		};
+	}
+	function indentedJoin(xs, indent) {
+		if (xs.length === 0) return "";
+		var lineJoiner = "\n" + indent.prev + indent.base;
+		return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev;
+	}
+	function arrObjKeys(obj, inspect) {
+		var isArr = isArray(obj);
+		var xs = [];
+		if (isArr) {
+			xs.length = obj.length;
+			for (var i = 0; i < obj.length; i++) xs[i] = has(obj, i) ? inspect(obj[i], obj) : "";
+		}
+		var syms = typeof gOPS === "function" ? gOPS(obj) : [];
+		var symMap;
+		if (hasShammedSymbols) {
+			symMap = {};
+			for (var k = 0; k < syms.length; k++) symMap["$" + syms[k]] = syms[k];
+		}
+		for (var key in obj) {
+			if (!has(obj, key)) continue;
+			if (isArr && String(Number(key)) === key && key < obj.length) continue;
+			if (hasShammedSymbols && symMap["$" + key] instanceof Symbol) continue;
+			else if ($test.call(/[^\w$]/, key)) xs.push(inspect(key, obj) + ": " + inspect(obj[key], obj));
+			else xs.push(key + ": " + inspect(obj[key], obj));
+		}
+		if (typeof gOPS === "function") {
+			for (var j = 0; j < syms.length; j++) if (isEnumerable.call(obj, syms[j])) xs.push("[" + inspect(syms[j]) + "]: " + inspect(obj[syms[j]], obj));
+		}
+		return xs;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/side-channel-list@1.0.1/node_modules/side-channel-list/index.js
+var require_side_channel_list = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var inspect = require_object_inspect();
+	var $TypeError = require_type();
+	/** @type {import('./list.d.ts').listGetNode} */
+	var listGetNode = function(list, key, isDelete) {
+		/** @type {typeof list | NonNullable<(typeof list)['next']>} */
+		var prev = list;
+		/** @type {(typeof list)['next']} */
+		var curr;
+		for (; (curr = prev.next) != null; prev = curr) if (curr.key === key) {
+			prev.next = curr.next;
+			if (!isDelete) {
+				curr.next = list.next;
+				list.next = curr;
+			}
+			return curr;
+		}
+	};
+	/** @type {import('./list.d.ts').listGet} */
+	var listGet = function(objects, key) {
+		if (!objects) return;
+		var node = listGetNode(objects, key);
+		return node && node.value;
+	};
+	/** @type {import('./list.d.ts').listSet} */
+	var listSet = function(objects, key, value) {
+		var node = listGetNode(objects, key);
+		if (node) node.value = value;
+		else objects.next = {
+			key,
+			next: objects.next,
+			value
+		};
+	};
+	/** @type {import('./list.d.ts').listHas} */
+	var listHas = function(objects, key) {
+		if (!objects) return false;
+		return !!listGetNode(objects, key);
+	};
+	/** @type {import('./list.d.ts').listDelete} */
+	var listDelete = function(objects, key) {
+		if (objects) return listGetNode(objects, key, true);
+	};
+	/** @type {import('.')} */
+	module.exports = function getSideChannelList() {
+		/** @typedef {ReturnType<typeof getSideChannelList>} Channel */
+		/** @typedef {Parameters<Channel['get']>[0]} K */
+		/** @typedef {Parameters<Channel['set']>[1]} V */
+		/** @type {import('./list.d.ts').RootNode<V, K> | undefined} */ var $o;
+		/** @type {Channel} */
+		var channel = {
+			assert: function(key) {
+				if (!channel.has(key)) throw new $TypeError("Side channel does not contain " + inspect(key));
+			},
+			"delete": function(key) {
+				var deletedNode = listDelete($o, key);
+				if (deletedNode && $o && !$o.next) $o = void 0;
+				return !!deletedNode;
+			},
+			get: function(key) {
+				return listGet($o, key);
+			},
+			has: function(key) {
+				return listHas($o, key);
+			},
+			set: function(key, value) {
+				if (!$o) $o = { next: void 0 };
+				listSet($o, key, value);
+			}
+		};
+		return channel;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js
+var require_call_bound = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var GetIntrinsic = require_get_intrinsic();
+	var callBindBasic = require_call_bind_apply_helpers();
+	/** @type {(thisArg: string, searchString: string, position?: number) => number} */
+	var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
+	/** @type {import('.')} */
+	module.exports = function callBoundIntrinsic(name, allowMissing) {
+		var intrinsic = GetIntrinsic(name, !!allowMissing);
+		if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) return callBindBasic([intrinsic]);
+		return intrinsic;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/side-channel-map@1.0.1/node_modules/side-channel-map/index.js
+var require_side_channel_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var GetIntrinsic = require_get_intrinsic();
+	var callBound = require_call_bound();
+	var inspect = require_object_inspect();
+	var $TypeError = require_type();
+	var $Map = GetIntrinsic("%Map%", true);
+	/** @type {<K, V>(thisArg: Map<K, V>, key: K) => V} */
+	var $mapGet = callBound("Map.prototype.get", true);
+	/** @type {<K, V>(thisArg: Map<K, V>, key: K, value: V) => void} */
+	var $mapSet = callBound("Map.prototype.set", true);
+	/** @type {<K, V>(thisArg: Map<K, V>, key: K) => boolean} */
+	var $mapHas = callBound("Map.prototype.has", true);
+	/** @type {<K, V>(thisArg: Map<K, V>, key: K) => boolean} */
+	var $mapDelete = callBound("Map.prototype.delete", true);
+	/** @type {<K, V>(thisArg: Map<K, V>) => number} */
+	var $mapSize = callBound("Map.prototype.size", true);
+	/** @type {import('.')} */
+	module.exports = !!$Map && function getSideChannelMap() {
+		/** @typedef {ReturnType<typeof getSideChannelMap>} Channel */
+		/** @typedef {Parameters<Channel['get']>[0]} K */
+		/** @typedef {Parameters<Channel['set']>[1]} V */
+		/** @type {Map<K, V> | undefined} */ var $m;
+		/** @type {Channel} */
+		var channel = {
+			assert: function(key) {
+				if (!channel.has(key)) throw new $TypeError("Side channel does not contain " + inspect(key));
+			},
+			"delete": function(key) {
+				if ($m) {
+					var result = $mapDelete($m, key);
+					if ($mapSize($m) === 0) $m = void 0;
+					return result;
+				}
+				return false;
+			},
+			get: function(key) {
+				if ($m) return $mapGet($m, key);
+			},
+			has: function(key) {
+				if ($m) return $mapHas($m, key);
+				return false;
+			},
+			set: function(key, value) {
+				if (!$m) $m = new $Map();
+				$mapSet($m, key, value);
+			}
+		};
+		return channel;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/side-channel-weakmap@1.0.2/node_modules/side-channel-weakmap/index.js
+var require_side_channel_weakmap = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var GetIntrinsic = require_get_intrinsic();
+	var callBound = require_call_bound();
+	var inspect = require_object_inspect();
+	var getSideChannelMap = require_side_channel_map();
+	var $TypeError = require_type();
+	var $WeakMap = GetIntrinsic("%WeakMap%", true);
+	/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K) => V} */
+	var $weakMapGet = callBound("WeakMap.prototype.get", true);
+	/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K, value: V) => void} */
+	var $weakMapSet = callBound("WeakMap.prototype.set", true);
+	/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K) => boolean} */
+	var $weakMapHas = callBound("WeakMap.prototype.has", true);
+	/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K) => boolean} */
+	var $weakMapDelete = callBound("WeakMap.prototype.delete", true);
+	/** @type {import('.')} */
+	module.exports = $WeakMap ? function getSideChannelWeakMap() {
+		/** @typedef {ReturnType<typeof getSideChannelWeakMap>} Channel */
+		/** @typedef {Parameters<Channel['get']>[0]} K */
+		/** @typedef {Parameters<Channel['set']>[1]} V */
+		/** @type {WeakMap<K & object, V> | undefined} */ var $wm;
+		/** @type {Channel | undefined} */ var $m;
+		/** @type {Channel} */
+		var channel = {
+			assert: function(key) {
+				if (!channel.has(key)) throw new $TypeError("Side channel does not contain " + inspect(key));
+			},
+			"delete": function(key) {
+				if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+					if ($wm) return $weakMapDelete($wm, key);
+				} else if (getSideChannelMap) {
+					if ($m) return $m["delete"](key);
+				}
+				return false;
+			},
+			get: function(key) {
+				if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+					if ($wm) return $weakMapGet($wm, key);
+				}
+				return $m && $m.get(key);
+			},
+			has: function(key) {
+				if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+					if ($wm) return $weakMapHas($wm, key);
+				}
+				return !!$m && $m.has(key);
+			},
+			set: function(key, value) {
+				if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+					if (!$wm) $wm = new $WeakMap();
+					$weakMapSet($wm, key, value);
+				} else if (getSideChannelMap) {
+					if (!$m) $m = getSideChannelMap();
+					/** @type {NonNullable<typeof $m>} */ $m.set(key, value);
+				}
+			}
+		};
+		return channel;
+	} : getSideChannelMap;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/side-channel@1.1.0/node_modules/side-channel/index.js
+var require_side_channel = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $TypeError = require_type();
+	var inspect = require_object_inspect();
+	var getSideChannelList = require_side_channel_list();
+	var getSideChannelMap = require_side_channel_map();
+	var makeChannel = require_side_channel_weakmap() || getSideChannelMap || getSideChannelList;
+	/** @type {import('.')} */
+	module.exports = function getSideChannel() {
+		/** @typedef {ReturnType<typeof getSideChannel>} Channel */
+		/** @type {Channel | undefined} */ var $channelData;
+		/** @type {Channel} */
+		var channel = {
+			assert: function(key) {
+				if (!channel.has(key)) throw new $TypeError("Side channel does not contain " + inspect(key));
+			},
+			"delete": function(key) {
+				return !!$channelData && $channelData["delete"](key);
+			},
+			get: function(key) {
+				return $channelData && $channelData.get(key);
+			},
+			has: function(key) {
+				return !!$channelData && $channelData.has(key);
+			},
+			set: function(key, value) {
+				if (!$channelData) $channelData = makeChannel();
+				$channelData.set(key, value);
+			}
+		};
+		return channel;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qs@6.15.1/node_modules/qs/lib/formats.js
+var require_formats = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var replace = String.prototype.replace;
+	var percentTwenties = /%20/g;
+	var Format = {
+		RFC1738: "RFC1738",
+		RFC3986: "RFC3986"
+	};
+	module.exports = {
+		"default": Format.RFC3986,
+		formatters: {
+			RFC1738: function(value) {
+				return replace.call(value, percentTwenties, "+");
+			},
+			RFC3986: function(value) {
+				return String(value);
+			}
+		},
+		RFC1738: Format.RFC1738,
+		RFC3986: Format.RFC3986
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qs@6.15.1/node_modules/qs/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var formats = require_formats();
+	var getSideChannel = require_side_channel();
+	var has = Object.prototype.hasOwnProperty;
+	var isArray = Array.isArray;
+	var overflowChannel = getSideChannel();
+	var markOverflow = function markOverflow(obj, maxIndex) {
+		overflowChannel.set(obj, maxIndex);
+		return obj;
+	};
+	var isOverflow = function isOverflow(obj) {
+		return overflowChannel.has(obj);
+	};
+	var getMaxIndex = function getMaxIndex(obj) {
+		return overflowChannel.get(obj);
+	};
+	var setMaxIndex = function setMaxIndex(obj, maxIndex) {
+		overflowChannel.set(obj, maxIndex);
+	};
+	var hexTable = function() {
+		var array = [];
+		for (var i = 0; i < 256; ++i) array[array.length] = "%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase();
+		return array;
+	}();
+	var compactQueue = function compactQueue(queue) {
+		while (queue.length > 1) {
+			var item = queue.pop();
+			var obj = item.obj[item.prop];
+			if (isArray(obj)) {
+				var compacted = [];
+				for (var j = 0; j < obj.length; ++j) if (typeof obj[j] !== "undefined") compacted[compacted.length] = obj[j];
+				item.obj[item.prop] = compacted;
+			}
+		}
+	};
+	var arrayToObject = function arrayToObject(source, options) {
+		var obj = options && options.plainObjects ? { __proto__: null } : {};
+		for (var i = 0; i < source.length; ++i) if (typeof source[i] !== "undefined") obj[i] = source[i];
+		return obj;
+	};
+	var merge = function merge(target, source, options) {
+		if (!source) return target;
+		if (typeof source !== "object" && typeof source !== "function") {
+			if (isArray(target)) {
+				var nextIndex = target.length;
+				if (options && typeof options.arrayLimit === "number" && nextIndex > options.arrayLimit) return markOverflow(arrayToObject(target.concat(source), options), nextIndex);
+				target[nextIndex] = source;
+			} else if (target && typeof target === "object") {
+				if (isOverflow(target)) {
+					var newIndex = getMaxIndex(target) + 1;
+					target[newIndex] = source;
+					setMaxIndex(target, newIndex);
+				} else if (options && options.strictMerge) return [target, source];
+				else if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) target[source] = true;
+			} else return [target, source];
+			return target;
+		}
+		if (!target || typeof target !== "object") {
+			if (isOverflow(source)) {
+				var sourceKeys = Object.keys(source);
+				var result = options && options.plainObjects ? {
+					__proto__: null,
+					0: target
+				} : { 0: target };
+				for (var m = 0; m < sourceKeys.length; m++) {
+					var oldKey = parseInt(sourceKeys[m], 10);
+					result[oldKey + 1] = source[sourceKeys[m]];
+				}
+				return markOverflow(result, getMaxIndex(source) + 1);
+			}
+			var combined = [target].concat(source);
+			if (options && typeof options.arrayLimit === "number" && combined.length > options.arrayLimit) return markOverflow(arrayToObject(combined, options), combined.length - 1);
+			return combined;
+		}
+		var mergeTarget = target;
+		if (isArray(target) && !isArray(source)) mergeTarget = arrayToObject(target, options);
+		if (isArray(target) && isArray(source)) {
+			source.forEach(function(item, i) {
+				if (has.call(target, i)) {
+					var targetItem = target[i];
+					if (targetItem && typeof targetItem === "object" && item && typeof item === "object") target[i] = merge(targetItem, item, options);
+					else target[target.length] = item;
+				} else target[i] = item;
+			});
+			return target;
+		}
+		return Object.keys(source).reduce(function(acc, key) {
+			var value = source[key];
+			if (has.call(acc, key)) acc[key] = merge(acc[key], value, options);
+			else acc[key] = value;
+			if (isOverflow(source) && !isOverflow(acc)) markOverflow(acc, getMaxIndex(source));
+			if (isOverflow(acc)) {
+				var keyNum = parseInt(key, 10);
+				if (String(keyNum) === key && keyNum >= 0 && keyNum > getMaxIndex(acc)) setMaxIndex(acc, keyNum);
+			}
+			return acc;
+		}, mergeTarget);
+	};
+	var assign = function assignSingleSource(target, source) {
+		return Object.keys(source).reduce(function(acc, key) {
+			acc[key] = source[key];
+			return acc;
+		}, target);
+	};
+	var decode = function(str, defaultDecoder, charset) {
+		var strWithoutPlus = str.replace(/\+/g, " ");
+		if (charset === "iso-8859-1") return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+		try {
+			return decodeURIComponent(strWithoutPlus);
+		} catch (e) {
+			return strWithoutPlus;
+		}
+	};
+	var limit = 1024;
+	module.exports = {
+		arrayToObject,
+		assign,
+		combine: function combine(a, b, arrayLimit, plainObjects) {
+			if (isOverflow(a)) {
+				var newIndex = getMaxIndex(a) + 1;
+				a[newIndex] = b;
+				setMaxIndex(a, newIndex);
+				return a;
+			}
+			var result = [].concat(a, b);
+			if (result.length > arrayLimit) return markOverflow(arrayToObject(result, { plainObjects }), result.length - 1);
+			return result;
+		},
+		compact: function compact(value) {
+			var queue = [{
+				obj: { o: value },
+				prop: "o"
+			}];
+			var refs = [];
+			for (var i = 0; i < queue.length; ++i) {
+				var item = queue[i];
+				var obj = item.obj[item.prop];
+				var keys = Object.keys(obj);
+				for (var j = 0; j < keys.length; ++j) {
+					var key = keys[j];
+					var val = obj[key];
+					if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) {
+						queue[queue.length] = {
+							obj,
+							prop: key
+						};
+						refs[refs.length] = val;
+					}
+				}
+			}
+			compactQueue(queue);
+			return value;
+		},
+		decode,
+		encode: function encode(str, defaultEncoder, charset, kind, format) {
+			if (str.length === 0) return str;
+			var string = str;
+			if (typeof str === "symbol") string = Symbol.prototype.toString.call(str);
+			else if (typeof str !== "string") string = String(str);
+			if (charset === "iso-8859-1") return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) {
+				return "%26%23" + parseInt($0.slice(2), 16) + "%3B";
+			});
+			var out = "";
+			for (var j = 0; j < string.length; j += limit) {
+				var segment = string.length >= limit ? string.slice(j, j + limit) : string;
+				var arr = [];
+				for (var i = 0; i < segment.length; ++i) {
+					var c = segment.charCodeAt(i);
+					if (c === 45 || c === 46 || c === 95 || c === 126 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || format === formats.RFC1738 && (c === 40 || c === 41)) {
+						arr[arr.length] = segment.charAt(i);
+						continue;
+					}
+					if (c < 128) {
+						arr[arr.length] = hexTable[c];
+						continue;
+					}
+					if (c < 2048) {
+						arr[arr.length] = hexTable[192 | c >> 6] + hexTable[128 | c & 63];
+						continue;
+					}
+					if (c < 55296 || c >= 57344) {
+						arr[arr.length] = hexTable[224 | c >> 12] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
+						continue;
+					}
+					i += 1;
+					c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023);
+					arr[arr.length] = hexTable[240 | c >> 18] + hexTable[128 | c >> 12 & 63] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
+				}
+				out += arr.join("");
+			}
+			return out;
+		},
+		isBuffer: function isBuffer(obj) {
+			if (!obj || typeof obj !== "object") return false;
+			return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+		},
+		isOverflow,
+		isRegExp: function isRegExp(obj) {
+			return Object.prototype.toString.call(obj) === "[object RegExp]";
+		},
+		markOverflow,
+		maybeMap: function maybeMap(val, fn) {
+			if (isArray(val)) {
+				var mapped = [];
+				for (var i = 0; i < val.length; i += 1) mapped[mapped.length] = fn(val[i]);
+				return mapped;
+			}
+			return fn(val);
+		},
+		merge
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qs@6.15.1/node_modules/qs/lib/stringify.js
+var require_stringify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getSideChannel = require_side_channel();
+	var utils = require_utils();
+	var formats = require_formats();
+	var has = Object.prototype.hasOwnProperty;
+	var arrayPrefixGenerators = {
+		brackets: function brackets(prefix) {
+			return prefix + "[]";
+		},
+		comma: "comma",
+		indices: function indices(prefix, key) {
+			return prefix + "[" + key + "]";
+		},
+		repeat: function repeat(prefix) {
+			return prefix;
+		}
+	};
+	var isArray = Array.isArray;
+	var push = Array.prototype.push;
+	var pushToArray = function(arr, valueOrArray) {
+		push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
+	};
+	var toISO = Date.prototype.toISOString;
+	var defaultFormat = formats["default"];
+	var defaults = {
+		addQueryPrefix: false,
+		allowDots: false,
+		allowEmptyArrays: false,
+		arrayFormat: "indices",
+		charset: "utf-8",
+		charsetSentinel: false,
+		commaRoundTrip: false,
+		delimiter: "&",
+		encode: true,
+		encodeDotInKeys: false,
+		encoder: utils.encode,
+		encodeValuesOnly: false,
+		filter: void 0,
+		format: defaultFormat,
+		formatter: formats.formatters[defaultFormat],
+		indices: false,
+		serializeDate: function serializeDate(date) {
+			return toISO.call(date);
+		},
+		skipNulls: false,
+		strictNullHandling: false
+	};
+	var isNonNullishPrimitive = function isNonNullishPrimitive(v) {
+		return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint";
+	};
+	var sentinel = {};
+	var stringify = function stringify(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) {
+		var obj = object;
+		var tmpSc = sideChannel;
+		var step = 0;
+		var findFlag = false;
+		while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) {
+			var pos = tmpSc.get(object);
+			step += 1;
+			if (typeof pos !== "undefined") if (pos === step) throw new RangeError("Cyclic object value");
+			else findFlag = true;
+			if (typeof tmpSc.get(sentinel) === "undefined") step = 0;
+		}
+		if (typeof filter === "function") obj = filter(prefix, obj);
+		else if (obj instanceof Date) obj = serializeDate(obj);
+		else if (generateArrayPrefix === "comma" && isArray(obj)) obj = utils.maybeMap(obj, function(value) {
+			if (value instanceof Date) return serializeDate(value);
+			return value;
+		});
+		if (obj === null) {
+			if (strictNullHandling) return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, "key", format) : prefix;
+			obj = "";
+		}
+		if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {
+			if (encoder) return [formatter(encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format)) + "=" + formatter(encoder(obj, defaults.encoder, charset, "value", format))];
+			return [formatter(prefix) + "=" + formatter(String(obj))];
+		}
+		var values = [];
+		if (typeof obj === "undefined") return values;
+		var objKeys;
+		if (generateArrayPrefix === "comma" && isArray(obj)) {
+			if (encodeValuesOnly && encoder) obj = utils.maybeMap(obj, encoder);
+			objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }];
+		} else if (isArray(filter)) objKeys = filter;
+		else {
+			var keys = Object.keys(obj);
+			objKeys = sort ? keys.sort(sort) : keys;
+		}
+		var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix);
+		var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + "[]" : encodedPrefix;
+		if (allowEmptyArrays && isArray(obj) && obj.length === 0) return adjustedPrefix + "[]";
+		for (var j = 0; j < objKeys.length; ++j) {
+			var key = objKeys[j];
+			var value = typeof key === "object" && key && typeof key.value !== "undefined" ? key.value : obj[key];
+			if (skipNulls && value === null) continue;
+			var encodedKey = allowDots && encodeDotInKeys ? String(key).replace(/\./g, "%2E") : String(key);
+			var keyPrefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? "." + encodedKey : "[" + encodedKey + "]");
+			sideChannel.set(object, step);
+			var valueSideChannel = getSideChannel();
+			valueSideChannel.set(sentinel, sideChannel);
+			pushToArray(values, stringify(value, keyPrefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, valueSideChannel));
+		}
+		return values;
+	};
+	var normalizeStringifyOptions = function normalizeStringifyOptions(opts) {
+		if (!opts) return defaults;
+		if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
+		if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
+		if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") throw new TypeError("Encoder has to be a function.");
+		var charset = opts.charset || defaults.charset;
+		if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+		var format = formats["default"];
+		if (typeof opts.format !== "undefined") {
+			if (!has.call(formats.formatters, opts.format)) throw new TypeError("Unknown format option provided.");
+			format = opts.format;
+		}
+		var formatter = formats.formatters[format];
+		var filter = defaults.filter;
+		if (typeof opts.filter === "function" || isArray(opts.filter)) filter = opts.filter;
+		var arrayFormat;
+		if (opts.arrayFormat in arrayPrefixGenerators) arrayFormat = opts.arrayFormat;
+		else if ("indices" in opts) arrayFormat = opts.indices ? "indices" : "repeat";
+		else arrayFormat = defaults.arrayFormat;
+		if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
+		var allowDots = typeof opts.allowDots === "undefined" ? opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;
+		return {
+			addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix,
+			allowDots,
+			allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+			arrayFormat,
+			charset,
+			charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
+			commaRoundTrip: !!opts.commaRoundTrip,
+			delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter,
+			encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode,
+			encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
+			encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder,
+			encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
+			filter,
+			format,
+			formatter,
+			serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate,
+			skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls,
+			sort: typeof opts.sort === "function" ? opts.sort : null,
+			strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling
+		};
+	};
+	module.exports = function(object, opts) {
+		var obj = object;
+		var options = normalizeStringifyOptions(opts);
+		var objKeys;
+		var filter;
+		if (typeof options.filter === "function") {
+			filter = options.filter;
+			obj = filter("", obj);
+		} else if (isArray(options.filter)) {
+			filter = options.filter;
+			objKeys = filter;
+		}
+		var keys = [];
+		if (typeof obj !== "object" || obj === null) return "";
+		var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];
+		var commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip;
+		if (!objKeys) objKeys = Object.keys(obj);
+		if (options.sort) objKeys.sort(options.sort);
+		var sideChannel = getSideChannel();
+		for (var i = 0; i < objKeys.length; ++i) {
+			var key = objKeys[i];
+			var value = obj[key];
+			if (options.skipNulls && value === null) continue;
+			pushToArray(keys, stringify(value, key, generateArrayPrefix, commaRoundTrip, options.allowEmptyArrays, options.strictNullHandling, options.skipNulls, options.encodeDotInKeys, options.encode ? options.encoder : null, options.filter, options.sort, options.allowDots, options.serializeDate, options.format, options.formatter, options.encodeValuesOnly, options.charset, sideChannel));
+		}
+		var joined = keys.join(options.delimiter);
+		var prefix = options.addQueryPrefix === true ? "?" : "";
+		if (options.charsetSentinel) if (options.charset === "iso-8859-1") prefix += "utf8=%26%2310003%3B&";
+		else prefix += "utf8=%E2%9C%93&";
+		return joined.length > 0 ? prefix + joined : "";
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qs@6.15.1/node_modules/qs/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var utils = require_utils();
+	var has = Object.prototype.hasOwnProperty;
+	var isArray = Array.isArray;
+	var defaults = {
+		allowDots: false,
+		allowEmptyArrays: false,
+		allowPrototypes: false,
+		allowSparse: false,
+		arrayLimit: 20,
+		charset: "utf-8",
+		charsetSentinel: false,
+		comma: false,
+		decodeDotInKeys: false,
+		decoder: utils.decode,
+		delimiter: "&",
+		depth: 5,
+		duplicates: "combine",
+		ignoreQueryPrefix: false,
+		interpretNumericEntities: false,
+		parameterLimit: 1e3,
+		parseArrays: true,
+		plainObjects: false,
+		strictDepth: false,
+		strictMerge: true,
+		strictNullHandling: false,
+		throwOnLimitExceeded: false
+	};
+	var interpretNumericEntities = function(str) {
+		return str.replace(/&#(\d+);/g, function($0, numberStr) {
+			return String.fromCharCode(parseInt(numberStr, 10));
+		});
+	};
+	var parseArrayValue = function(val, options, currentArrayLength) {
+		if (val && typeof val === "string" && options.comma && val.indexOf(",") > -1) return val.split(",");
+		if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+		return val;
+	};
+	var isoSentinel = "utf8=%26%2310003%3B";
+	var charsetSentinel = "utf8=%E2%9C%93";
+	var parseValues = function parseQueryStringValues(str, options) {
+		var obj = { __proto__: null };
+		var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, "") : str;
+		cleanStr = cleanStr.replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+		var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;
+		var parts = cleanStr.split(options.delimiter, options.throwOnLimitExceeded && typeof limit !== "undefined" ? limit + 1 : limit);
+		if (options.throwOnLimitExceeded && typeof limit !== "undefined" && parts.length > limit) throw new RangeError("Parameter limit exceeded. Only " + limit + " parameter" + (limit === 1 ? "" : "s") + " allowed.");
+		var skipIndex = -1;
+		var i;
+		var charset = options.charset;
+		if (options.charsetSentinel) {
+			for (i = 0; i < parts.length; ++i) if (parts[i].indexOf("utf8=") === 0) {
+				if (parts[i] === charsetSentinel) charset = "utf-8";
+				else if (parts[i] === isoSentinel) charset = "iso-8859-1";
+				skipIndex = i;
+				i = parts.length;
+			}
+		}
+		for (i = 0; i < parts.length; ++i) {
+			if (i === skipIndex) continue;
+			var part = parts[i];
+			var bracketEqualsPos = part.indexOf("]=");
+			var pos = bracketEqualsPos === -1 ? part.indexOf("=") : bracketEqualsPos + 1;
+			var key;
+			var val;
+			if (pos === -1) {
+				key = options.decoder(part, defaults.decoder, charset, "key");
+				val = options.strictNullHandling ? null : "";
+			} else {
+				key = options.decoder(part.slice(0, pos), defaults.decoder, charset, "key");
+				if (key !== null) val = utils.maybeMap(parseArrayValue(part.slice(pos + 1), options, isArray(obj[key]) ? obj[key].length : 0), function(encodedVal) {
+					return options.decoder(encodedVal, defaults.decoder, charset, "value");
+				});
+			}
+			if (val && options.interpretNumericEntities && charset === "iso-8859-1") val = interpretNumericEntities(String(val));
+			if (part.indexOf("[]=") > -1) val = isArray(val) ? [val] : val;
+			if (options.comma && isArray(val) && val.length > options.arrayLimit) {
+				if (options.throwOnLimitExceeded) throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+				val = utils.combine([], val, options.arrayLimit, options.plainObjects);
+			}
+			if (key !== null) {
+				var existing = has.call(obj, key);
+				if (existing && (options.duplicates === "combine" || part.indexOf("[]=") > -1)) obj[key] = utils.combine(obj[key], val, options.arrayLimit, options.plainObjects);
+				else if (!existing || options.duplicates === "last") obj[key] = val;
+			}
+		}
+		return obj;
+	};
+	var parseObject = function(chain, val, options, valuesParsed) {
+		var currentArrayLength = 0;
+		if (chain.length > 0 && chain[chain.length - 1] === "[]") {
+			var parentKey = chain.slice(0, -1).join("");
+			currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0;
+		}
+		var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength);
+		for (var i = chain.length - 1; i >= 0; --i) {
+			var obj;
+			var root = chain[i];
+			if (root === "[]" && options.parseArrays) if (utils.isOverflow(leaf)) obj = leaf;
+			else obj = options.allowEmptyArrays && (leaf === "" || options.strictNullHandling && leaf === null) ? [] : utils.combine([], leaf, options.arrayLimit, options.plainObjects);
+			else {
+				obj = options.plainObjects ? { __proto__: null } : {};
+				var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root;
+				var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, ".") : cleanRoot;
+				var index = parseInt(decodedRoot, 10);
+				var isValidArrayIndex = !isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && options.parseArrays;
+				if (!options.parseArrays && decodedRoot === "") obj = { 0: leaf };
+				else if (isValidArrayIndex && index < options.arrayLimit) {
+					obj = [];
+					obj[index] = leaf;
+				} else if (isValidArrayIndex && options.throwOnLimitExceeded) throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+				else if (isValidArrayIndex) {
+					obj[index] = leaf;
+					utils.markOverflow(obj, index);
+				} else if (decodedRoot !== "__proto__") obj[decodedRoot] = leaf;
+			}
+			leaf = obj;
+		}
+		return leaf;
+	};
+	var splitKeyIntoSegments = function splitKeyIntoSegments(givenKey, options) {
+		var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, "[$1]") : givenKey;
+		if (options.depth <= 0) {
+			if (!options.plainObjects && has.call(Object.prototype, key)) {
+				if (!options.allowPrototypes) return;
+			}
+			return [key];
+		}
+		var brackets = /(\[[^[\]]*])/;
+		var child = /(\[[^[\]]*])/g;
+		var segment = brackets.exec(key);
+		var parent = segment ? key.slice(0, segment.index) : key;
+		var keys = [];
+		if (parent) {
+			if (!options.plainObjects && has.call(Object.prototype, parent)) {
+				if (!options.allowPrototypes) return;
+			}
+			keys[keys.length] = parent;
+		}
+		var i = 0;
+		while ((segment = child.exec(key)) !== null && i < options.depth) {
+			i += 1;
+			var segmentContent = segment[1].slice(1, -1);
+			if (!options.plainObjects && has.call(Object.prototype, segmentContent)) {
+				if (!options.allowPrototypes) return;
+			}
+			keys[keys.length] = segment[1];
+		}
+		if (segment) {
+			if (options.strictDepth === true) throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true");
+			keys[keys.length] = "[" + key.slice(segment.index) + "]";
+		}
+		return keys;
+	};
+	var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
+		if (!givenKey) return;
+		var keys = splitKeyIntoSegments(givenKey, options);
+		if (!keys) return;
+		return parseObject(keys, val, options, valuesParsed);
+	};
+	var normalizeParseOptions = function normalizeParseOptions(opts) {
+		if (!opts) return defaults;
+		if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
+		if (typeof opts.decodeDotInKeys !== "undefined" && typeof opts.decodeDotInKeys !== "boolean") throw new TypeError("`decodeDotInKeys` option can only be `true` or `false`, when provided");
+		if (opts.decoder !== null && typeof opts.decoder !== "undefined" && typeof opts.decoder !== "function") throw new TypeError("Decoder has to be a function.");
+		if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+		if (typeof opts.throwOnLimitExceeded !== "undefined" && typeof opts.throwOnLimitExceeded !== "boolean") throw new TypeError("`throwOnLimitExceeded` option must be a boolean");
+		var charset = typeof opts.charset === "undefined" ? defaults.charset : opts.charset;
+		var duplicates = typeof opts.duplicates === "undefined" ? defaults.duplicates : opts.duplicates;
+		if (duplicates !== "combine" && duplicates !== "first" && duplicates !== "last") throw new TypeError("The duplicates option must be either combine, first, or last");
+		return {
+			allowDots: typeof opts.allowDots === "undefined" ? opts.decodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots,
+			allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+			allowPrototypes: typeof opts.allowPrototypes === "boolean" ? opts.allowPrototypes : defaults.allowPrototypes,
+			allowSparse: typeof opts.allowSparse === "boolean" ? opts.allowSparse : defaults.allowSparse,
+			arrayLimit: typeof opts.arrayLimit === "number" ? opts.arrayLimit : defaults.arrayLimit,
+			charset,
+			charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
+			comma: typeof opts.comma === "boolean" ? opts.comma : defaults.comma,
+			decodeDotInKeys: typeof opts.decodeDotInKeys === "boolean" ? opts.decodeDotInKeys : defaults.decodeDotInKeys,
+			decoder: typeof opts.decoder === "function" ? opts.decoder : defaults.decoder,
+			delimiter: typeof opts.delimiter === "string" || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,
+			depth: typeof opts.depth === "number" || opts.depth === false ? +opts.depth : defaults.depth,
+			duplicates,
+			ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
+			interpretNumericEntities: typeof opts.interpretNumericEntities === "boolean" ? opts.interpretNumericEntities : defaults.interpretNumericEntities,
+			parameterLimit: typeof opts.parameterLimit === "number" ? opts.parameterLimit : defaults.parameterLimit,
+			parseArrays: opts.parseArrays !== false,
+			plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults.plainObjects,
+			strictDepth: typeof opts.strictDepth === "boolean" ? !!opts.strictDepth : defaults.strictDepth,
+			strictMerge: typeof opts.strictMerge === "boolean" ? !!opts.strictMerge : defaults.strictMerge,
+			strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling,
+			throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === "boolean" ? opts.throwOnLimitExceeded : false
+		};
+	};
+	module.exports = function(str, opts) {
+		var options = normalizeParseOptions(opts);
+		if (str === "" || str === null || typeof str === "undefined") return options.plainObjects ? { __proto__: null } : {};
+		var tempObj = typeof str === "string" ? parseValues(str, options) : str;
+		var obj = options.plainObjects ? { __proto__: null } : {};
+		var keys = Object.keys(tempObj);
+		for (var i = 0; i < keys.length; ++i) {
+			var key = keys[i];
+			var newObj = parseKeys(key, tempObj[key], options, typeof str === "string");
+			obj = utils.merge(obj, newObj, options);
+		}
+		if (options.allowSparse === true) return obj;
+		return utils.compact(obj);
+	};
+}));
+//#endregion
+//#region ../../packages/workflow-sdk/src/error.ts
+var import_lib = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var stringify = require_stringify();
+	var parse = require_parse();
+	module.exports = {
+		formats: require_formats(),
+		parse,
+		stringify
+	};
+})))(), 1);
+function isDeployCredentialErrorBody(body) {
+	return typeof body === "object" && body !== null && body.status === "credentials_required";
+}
+function formatDeployCredentialGateMessage(body) {
+	const lines = ["Deployment blocked: required credentials are missing, incomplete, or out of date with the active deployment."];
+	for (const m of body.missing ?? []) {
+		const label = m.displayName ?? m.resolvedCredentialSetId ?? "credential set";
+		const keyDetail = m.missingKeys && m.missingKeys.length > 0 ? ` (incomplete: missing keys ${m.missingKeys.join(", ")})` : "";
+		const fix = m.connectCommand ?? m.uploadCommand;
+		lines.push(fix ? `- ${label}${keyDetail}. Fix: ${fix}` : `- ${label}${keyDetail}. Connect or upload credentials for this credential set.`);
+	}
+	for (const d of body.schemaDrifts ?? []) if (d.message) lines.push(`- Schema drift: ${d.message}`);
+	return lines.join("\n");
+}
+const ISSUE_LIMIT = 5;
+const FALLBACK_MESSAGE = "An unexpected error occurred";
+/**
+* Formats Zod validation issues into a human-readable string.
+*/
+function formatZodIssues(error) {
+	return error.issues.slice(0, ISSUE_LIMIT).map((issue) => {
+		return `${issue.path.length > 0 ? issue.path.join(".") : "root"}: ${issue.message}`;
+	}).join("; ");
+}
+/**
+* Extracts a human-readable error message from various error types:
+* - API/HTTP errors (from ky): message/error from response body, or status text
+* - Zod validation errors: formatted path + message for each issue
+* - Network errors (TypeError, Failed to fetch): friendly network message
+* - Generic Error: uses error.message
+* - Unknown: fallback message
+*
+* @param error - Any error (unknown) thrown during SDK operations
+* @returns Human-readable error message string
+*/
+async function transformError(error) {
+	if (error instanceof ZodError) {
+		const formatted = formatZodIssues(error);
+		return formatted ? `Validation error: ${formatted}` : "Validation failed";
+	}
+	if (isHTTPError(error)) {
+		const { response } = error;
+		let message = response.statusText || `HTTP ${response.status}`;
+		try {
+			const body = await response.clone().json();
+			if (body?.code === "ORG_HEADER_REQUIRED") return [
+				"Organization context required: You belong to multiple organizations.",
+				"Pass organizationId to createClient(), set KEYSTROKE_ORG_ID env var,",
+				"or use the --org flag in the CLI.",
+				body.hint ? `Server hint: ${body.hint}` : ""
+			].filter(Boolean).join("\n");
+			if (isDeployCredentialErrorBody(body)) return `Keystroke API Error (${response.status}): ${formatDeployCredentialGateMessage(body)}`;
+			const bodyMessage = body?.message ?? body?.error;
+			if (typeof bodyMessage === "string") message = bodyMessage;
+		} catch {}
+		return `Keystroke API Error (${response.status}): ${message}`;
+	}
+	if (error instanceof TypeError) {
+		if (error.message.toLowerCase().includes("fetch")) return "Network error: Unable to reach the server. Check your connection and try again.";
+		return error.message || "A network error occurred";
+	}
+	if (error instanceof Error) return error.message || FALLBACK_MESSAGE;
+	return FALLBACK_MESSAGE;
+}
+function isHTTPError(error) {
+	return typeof error === "object" && error !== null && "response" in error && typeof error.response === "object";
+}
+//#endregion
+//#region ../../packages/workflow-sdk/src/http.ts
+const REQUEST_START_HEADER = "x-request-start";
+/** Default beforeRequest hook: injects bearer token and optional org header */
+const createAuthHook = (apiKey, getApiKey, organizationId, getOrganizationId) => {
+	return async (request) => {
+		try {
+			let key;
+			if (getApiKey) key = await getApiKey();
+			else if (apiKey) key = apiKey;
+			else throw new Error("Keystroke API Key is required (pass apiKey, getApiKey, or set KEYSTROKE_API_KEY)");
+			request.headers.set("Authorization", `Bearer ${key}`);
+			const orgId = getOrganizationId ? await getOrganizationId() : organizationId;
+			if (orgId) request.headers.set("X-Organization-Id", orgId);
+		} catch (error) {
+			console.error("Error creating auth hook:", error);
+		}
+	};
+};
+function headersToRecord(headers) {
+	const result = {};
+	headers.forEach((value, key) => {
+		result[key] = value;
+	});
+	return result;
+}
+async function tryParseBody(clone) {
+	try {
+		return await clone.json();
+	} catch {
+		return;
+	}
+}
+const createRequestLogHook = (onRequest) => {
+	return async (request) => {
+		request.headers.set(REQUEST_START_HEADER, String(Date.now()));
+		const body = await tryParseBody(request.clone());
+		onRequest({
+			method: request.method,
+			url: request.url,
+			headers: headersToRecord(request.headers),
+			body
+		});
+	};
+};
+const createResponseLogHook = (onResponse) => {
+	return async (request, _options, response) => {
+		const startRaw = request.headers.get(REQUEST_START_HEADER);
+		const durationMs = startRaw ? Date.now() - Number(startRaw) : 0;
+		const body = await tryParseBody(response.clone());
+		onResponse({
+			method: request.method,
+			url: request.url,
+			status: response.status,
+			durationMs,
+			headers: headersToRecord(response.headers),
+			body
+		});
+		return response;
+	};
+};
+/** Default beforeError hook: enriches HTTPError with human-readable message via transformError */
+const defaultBeforeErrorHook = async (error) => {
+	error.message = await transformError(error);
+	return error;
+};
+/**
+* Custom fetch wrapper that catches network-level errors (e.g. ECONNREFUSED, DNS failures)
+* and transforms them into clean error messages via transformError.
+*
+* ky's `beforeError` hook only fires for HTTPError (non-2xx responses).
+* Network errors like TypeError: fetch failed bypass hooks entirely,
+* so we intercept them here at the fetch level.
+*/
+const createFetchWithErrorTransform = () => {
+	return async (...args) => {
+		try {
+			return await globalThis.fetch(...args);
+		} catch (error) {
+			const url = extractUrl(args[0]);
+			const message = await transformError(error);
+			const detail = url ? `${message} (attempted: ${url})` : message;
+			throw new TypeError(detail, { cause: error });
+		}
+	};
+};
+/** Extract a displayable URL (origin + pathname) from fetch input, stripping query params */
+function extractUrl(input) {
+	try {
+		if (typeof input === "string") {
+			const parsed = new URL(input);
+			return `${parsed.origin}${parsed.pathname}`;
+		}
+		if (input instanceof URL) return `${input.origin}${input.pathname}`;
+		if (input instanceof Request) {
+			const parsed = new URL(input.url);
+			return `${parsed.origin}${parsed.pathname}`;
+		}
+	} catch {
+		if (typeof input === "string") return input;
+	}
+}
+/**
+* Builds a `URLSearchParams` from a plain params object, preserving the
+* caller's declared types end-to-end so call sites don't need casts.
+*
+* Rules:
+*   • `undefined` / `null` values are dropped (the field is absent from the
+*     query string rather than serialized as the literal string "undefined").
+*   • Array values become repeated keys (`status=a&status=b`), which is what
+*     Hono/`c.req.queries()` and Zod's array preprocessors expect.
+*   • Booleans stringify to the literal `"true"` / `"false"` — pair with
+*     `z.stringbool()` on the server, NOT `z.coerce.boolean()` (the latter
+*     treats the string "false" as truthy).
+*   • Numbers stringify via `String()`.
+*
+* `URLSearchParams` is a first-class member of ky's `SearchParamsOption`
+* union, so the returned value is passed to `api.get('…', { searchParams })`
+* without any casts. The shared `qsSearchParamsHook` below explicitly skips
+* `URLSearchParams` instances, so this path bypasses the hook entirely.
+*
+* Use this from any SDK namespace whose query type has array-valued fields
+* (e.g. `status: ConnectionStatus | ConnectionStatus[]`) — those are the
+* cases that otherwise require an `as unknown as Record<...>` cast at the
+* call site because ky's declared `Record<string, string | number | boolean
+* | undefined>` does not accept arrays.
+*/
+function buildSearchParams(params) {
+	if (!params) return void 0;
+	const sp = new URLSearchParams();
+	for (const [key, value] of Object.entries(params)) {
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) for (const entry of value) {
+			if (entry === void 0 || entry === null) continue;
+			sp.append(key, String(entry));
+		}
+		else sp.append(key, String(value));
+	}
+	return sp.size > 0 ? sp : void 0;
+}
+/**
+* beforeRequest hook that re-serializes searchParams with qs.
+* ky's built-in URLSearchParams serialization comma-joins arrays (e.g. `projectId=a,b`).
+* This hook fixes that by rebuilding the query string with repeated keys (e.g. `projectId=a&projectId=b`).
+*
+* Only triggers for plain objects — callers that pre-build a `URLSearchParams`
+* (e.g. via `buildSearchParams` above) bypass this hook.
+*
+* Note: NormalizedOptions doesn't declare `searchParams` in its type, but ky passes it through at runtime.
+*/
+const qsSearchParamsHook = (request, options) => {
+	const sp = options.searchParams;
+	if (sp && typeof sp === "object" && !Array.isArray(sp) && !(sp instanceof URLSearchParams)) {
+		const query = import_lib.default.stringify(sp, {
+			arrayFormat: "repeat",
+			skipNulls: true
+		});
+		const url = new URL(request.url);
+		url.search = query;
+		return new Request(url.toString(), request);
+	}
+};
+function createKyInstance(config) {
+	const { prefixUrl, auth, apiKey, getApiKey, organizationId, getOrganizationId, onRequest, onResponse } = config;
+	const authHooks = auth === false ? [] : [createAuthHook(apiKey, getApiKey, organizationId, getOrganizationId)];
+	return ky.create({
+		prefixUrl,
+		retry: 0,
+		timeout: 3e4,
+		fetch: createFetchWithErrorTransform(),
+		hooks: {
+			beforeRequest: [
+				...authHooks,
+				...onRequest ? [createRequestLogHook(onRequest)] : [],
+				qsSearchParamsHook
+			],
+			afterResponse: [...onResponse ? [createResponseLogHook(onResponse)] : []],
+			beforeError: [defaultBeforeErrorHook],
+			beforeRetry: []
+		}
+	});
+}
+//#endregion
+//#region ../../packages/workflow-sdk/src/v1/bundles.ts
+const bundles = (api) => ({
+	/** Check current deployment artifact metadata for workflows and agents. */
+	getHashes: (params) => api.post("public/bundles/hashes", { json: params }).json(),
+	/** Request presigned upload URLs for workflows and agents in one round-trip. */
+	getPresignedUrl: (params) => api.post("public/bundles/presigned-url", { json: params }).json(),
+	/** Sync project file metadata snapshot independently of bundle registration. */
+	syncFileMetadata: (params) => api.post("public/bundles/file-metadata", { json: params }).json(),
+	/** Upload workflow bundles to storage. Gets presigned URLs then uploads with retry. */
+	upload: async (workflows, purpose, options) => {
+		const { workflows: workflowUrls } = await api.post("public/bundles/presigned-url", { json: {
+			workflows: workflows.map((wf) => ({
+				workflowName: wf.workflowName,
+				bundleHash: wf.bundleHash,
+				bundleSize: wf.bundleSize,
+				bundleFileName: wf.bundleFileName
+			})),
+			purpose
+		} }).json();
+		const { batchUpload } = await import("./upload-CkU--iDC.mjs").then((n) => n.n);
+		return batchUpload(workflows.map((wf) => ({
+			name: wf.workflowName,
+			bundle: wf.bundle,
+			bundlePath: wf.bundlePath
+		})), workflowUrls, options);
+	}
+});
+//#endregion
+//#region ../../packages/workflow-sdk/src/v1/public/auth.ts
+const auth = (api) => ({
+	/** Verify that the current API key is valid. */
+	validate: () => api.get("public/auth/verify").json(),
+	/** Revoke an API key by ID. The caller must authenticate with the same key. */
+	revoke: (params) => api.delete("public/auth/revoke", { json: params }).json()
+});
+//#endregion
+//#region ../../packages/workflow-sdk/src/v1/public/projects.ts
+const projects = (api) => ({ deploy: (params) => api.post("public/projects/deployments", { json: params }).json() });
+//#endregion
+export { createKyInstance as a, buildSearchParams as i, auth as n, transformError as o, bundles as r, getClientEnv as s, projects as t };