@trycadence/cli 0.1.0

package/dist/cadence

@@ -0,0 +1,2417 @@
+#!/usr/bin/env bun
+// @bun
+
+// ../../packages/config/src/index.ts
+var cadenceServicePorts = {
+  api: 3000,
+  worker: 3100,
+  web: 3001,
+  gui: 3002,
+  mcp: 3003
+};
+function getDefaultPort(service) {
+  return cadenceServicePorts[service];
+}
+function getDefaultApiBaseUrl() {
+  return `http://localhost:${getDefaultPort("api")}`;
+}
+
+// ../../node_modules/.bun/@trpc+client@11.17.0+f02ef5e6ba82b535/node_modules/@trpc/client/dist/objectSpread2-BvkFp-_Y.mjs
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function")
+    for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key;i < n; i++) {
+      key = keys[i];
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: ((k) => from[k]).bind(null, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+    }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var require_typeof = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(exports, module) {
+  function _typeof$2(o) {
+    "@babel/helpers - typeof";
+    return module.exports = _typeof$2 = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o$1) {
+      return typeof o$1;
+    } : function(o$1) {
+      return o$1 && typeof Symbol == "function" && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof$2(o);
+  }
+  module.exports = _typeof$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPrimitive = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(exports, module) {
+  var _typeof$1 = require_typeof()["default"];
+  function toPrimitive$1(t, r) {
+    if (_typeof$1(t) != "object" || !t)
+      return t;
+    var e = t[Symbol.toPrimitive];
+    if (e !== undefined) {
+      var i = e.call(t, r || "default");
+      if (_typeof$1(i) != "object")
+        return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (r === "string" ? String : Number)(t);
+  }
+  module.exports = toPrimitive$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPropertyKey = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(exports, module) {
+  var _typeof = require_typeof()["default"];
+  var toPrimitive = require_toPrimitive();
+  function toPropertyKey$1(t) {
+    var i = toPrimitive(t, "string");
+    return _typeof(i) == "symbol" ? i : i + "";
+  }
+  module.exports = toPropertyKey$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_defineProperty = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(exports, module) {
+  var toPropertyKey = require_toPropertyKey();
+  function _defineProperty(e, r, t) {
+    return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t, e;
+  }
+  module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_objectSpread2 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(exports, module) {
+  var defineProperty = require_defineProperty();
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function(r$1) {
+        return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread2(e) {
+    for (var r = 1;r < arguments.length; r++) {
+      var t = arguments[r] != null ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), true).forEach(function(r$1) {
+        defineProperty(e, r$1, t[r$1]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+        Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+      });
+    }
+    return e;
+  }
+  module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
+// ../../node_modules/.bun/@trpc+server@11.17.0+1fb4c65d43e298b9/node_modules/@trpc/server/dist/observable-UMO3vUa_.mjs
+function observable(subscribe) {
+  const self = {
+    subscribe(observer) {
+      let teardownRef = null;
+      let isDone = false;
+      let unsubscribed = false;
+      let teardownImmediately = false;
+      function unsubscribe() {
+        if (teardownRef === null) {
+          teardownImmediately = true;
+          return;
+        }
+        if (unsubscribed)
+          return;
+        unsubscribed = true;
+        if (typeof teardownRef === "function")
+          teardownRef();
+        else if (teardownRef)
+          teardownRef.unsubscribe();
+      }
+      teardownRef = subscribe({
+        next(value) {
+          var _observer$next;
+          if (isDone)
+            return;
+          (_observer$next = observer.next) === null || _observer$next === undefined || _observer$next.call(observer, value);
+        },
+        error(err) {
+          var _observer$error;
+          if (isDone)
+            return;
+          isDone = true;
+          (_observer$error = observer.error) === null || _observer$error === undefined || _observer$error.call(observer, err);
+          unsubscribe();
+        },
+        complete() {
+          var _observer$complete;
+          if (isDone)
+            return;
+          isDone = true;
+          (_observer$complete = observer.complete) === null || _observer$complete === undefined || _observer$complete.call(observer);
+          unsubscribe();
+        }
+      });
+      if (teardownImmediately)
+        unsubscribe();
+      return { unsubscribe };
+    },
+    pipe(...operations) {
+      return operations.reduce(pipeReducer, self);
+    }
+  };
+  return self;
+}
+function pipeReducer(prev, fn) {
+  return fn(prev);
+}
+function observableToPromise(observable$1) {
+  const ac = new AbortController;
+  const promise = new Promise((resolve, reject) => {
+    let isDone = false;
+    function onDone() {
+      if (isDone)
+        return;
+      isDone = true;
+      obs$.unsubscribe();
+    }
+    ac.signal.addEventListener("abort", () => {
+      reject(ac.signal.reason);
+    });
+    const obs$ = observable$1.subscribe({
+      next(data) {
+        isDone = true;
+        resolve(data);
+        onDone();
+      },
+      error(data) {
+        reject(data);
+      },
+      complete() {
+        ac.abort();
+        onDone();
+      }
+    });
+  });
+  return promise;
+}
+
+// ../../node_modules/.bun/@trpc+server@11.17.0+1fb4c65d43e298b9/node_modules/@trpc/server/dist/observable-CUiPknO-.mjs
+function share(_opts) {
+  return (source) => {
+    let refCount = 0;
+    let subscription = null;
+    const observers = [];
+    function startIfNeeded() {
+      if (subscription)
+        return;
+      subscription = source.subscribe({
+        next(value) {
+          for (const observer of observers) {
+            var _observer$next;
+            (_observer$next = observer.next) === null || _observer$next === undefined || _observer$next.call(observer, value);
+          }
+        },
+        error(error) {
+          for (const observer of observers) {
+            var _observer$error;
+            (_observer$error = observer.error) === null || _observer$error === undefined || _observer$error.call(observer, error);
+          }
+        },
+        complete() {
+          for (const observer of observers) {
+            var _observer$complete;
+            (_observer$complete = observer.complete) === null || _observer$complete === undefined || _observer$complete.call(observer);
+          }
+        }
+      });
+    }
+    function resetIfNeeded() {
+      if (refCount === 0 && subscription) {
+        const _sub = subscription;
+        subscription = null;
+        _sub.unsubscribe();
+      }
+    }
+    return observable((subscriber) => {
+      refCount++;
+      observers.push(subscriber);
+      startIfNeeded();
+      return { unsubscribe() {
+        refCount--;
+        resetIfNeeded();
+        const index = observers.findIndex((v) => v === subscriber);
+        if (index > -1)
+          observers.splice(index, 1);
+      } };
+    });
+  };
+}
+var distinctUnsetMarker = Symbol();
+function behaviorSubject(initialValue) {
+  let value = initialValue;
+  const observerList = [];
+  const addObserver = (observer) => {
+    if (value !== undefined)
+      observer.next(value);
+    observerList.push(observer);
+  };
+  const removeObserver = (observer) => {
+    observerList.splice(observerList.indexOf(observer), 1);
+  };
+  const obs = observable((observer) => {
+    addObserver(observer);
+    return () => {
+      removeObserver(observer);
+    };
+  });
+  obs.next = (nextValue) => {
+    if (value === nextValue)
+      return;
+    value = nextValue;
+    for (const observer of observerList)
+      observer.next(nextValue);
+  };
+  obs.get = () => value;
+  return obs;
+}
+
+// ../../node_modules/.bun/@trpc+client@11.17.0+f02ef5e6ba82b535/node_modules/@trpc/client/dist/splitLink-B7Cuf2c_.mjs
+function createChain(opts) {
+  return observable((observer) => {
+    function execute(index = 0, op = opts.op) {
+      const next = opts.links[index];
+      if (!next)
+        throw new Error("No more links to execute - did you forget to add an ending link?");
+      const subscription = next({
+        op,
+        next(nextOp) {
+          const nextObserver = execute(index + 1, nextOp);
+          return nextObserver;
+        }
+      });
+      return subscription;
+    }
+    const obs$ = execute();
+    return obs$.subscribe(observer);
+  });
+}
+
+// ../../node_modules/.bun/@trpc+server@11.17.0+1fb4c65d43e298b9/node_modules/@trpc/server/dist/codes-DagpWZLc.mjs
+function isObject(value) {
+  return !!value && !Array.isArray(value) && typeof value === "object";
+}
+function emptyObject() {
+  return Object.create(null);
+}
+var TRPC_ERROR_CODES_BY_KEY = {
+  PARSE_ERROR: -32700,
+  BAD_REQUEST: -32600,
+  INTERNAL_SERVER_ERROR: -32603,
+  NOT_IMPLEMENTED: -32603,
+  BAD_GATEWAY: -32603,
+  SERVICE_UNAVAILABLE: -32603,
+  GATEWAY_TIMEOUT: -32603,
+  UNAUTHORIZED: -32001,
+  PAYMENT_REQUIRED: -32002,
+  FORBIDDEN: -32003,
+  NOT_FOUND: -32004,
+  METHOD_NOT_SUPPORTED: -32005,
+  TIMEOUT: -32008,
+  CONFLICT: -32009,
+  PRECONDITION_FAILED: -32012,
+  PAYLOAD_TOO_LARGE: -32013,
+  UNSUPPORTED_MEDIA_TYPE: -32015,
+  UNPROCESSABLE_CONTENT: -32022,
+  PRECONDITION_REQUIRED: -32028,
+  TOO_MANY_REQUESTS: -32029,
+  CLIENT_CLOSED_REQUEST: -32099
+};
+var retryableRpcCodes = [
+  TRPC_ERROR_CODES_BY_KEY.BAD_GATEWAY,
+  TRPC_ERROR_CODES_BY_KEY.SERVICE_UNAVAILABLE,
+  TRPC_ERROR_CODES_BY_KEY.GATEWAY_TIMEOUT,
+  TRPC_ERROR_CODES_BY_KEY.INTERNAL_SERVER_ERROR
+];
+
+// ../../node_modules/.bun/@trpc+server@11.17.0+1fb4c65d43e298b9/node_modules/@trpc/server/dist/getErrorShape-BPSzUA7W.mjs
+var __create2 = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __commonJS2 = (cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function")
+    for (var keys = __getOwnPropNames2(from), i = 0, n = keys.length, key;i < n; i++) {
+      key = keys[i];
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, {
+          get: ((k) => from[k]).bind(null, key),
+          enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
+        });
+    }
+  return to;
+};
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var noop = () => {};
+var freezeIfAvailable = (obj) => {
+  if (Object.freeze)
+    Object.freeze(obj);
+};
+function createInnerProxy(callback, path, memo) {
+  var _memo$cacheKey;
+  const cacheKey = path.join(".");
+  (_memo$cacheKey = memo[cacheKey]) !== null && _memo$cacheKey !== undefined || (memo[cacheKey] = new Proxy(noop, {
+    get(_obj, key) {
+      if (typeof key !== "string" || key === "then")
+        return;
+      return createInnerProxy(callback, [...path, key], memo);
+    },
+    apply(_1, _2, args) {
+      const lastOfPath = path[path.length - 1];
+      if (lastOfPath === "valueOf" || lastOfPath === "toString" || lastOfPath === "toJSON") {
+        const debugPath = path.slice(0, -1).join(".");
+        return `tRPC.proxy(${debugPath})`;
+      }
+      let opts = {
+        args,
+        path
+      };
+      if (lastOfPath === "call")
+        opts = {
+          args: args.length >= 2 ? [args[1]] : [],
+          path: path.slice(0, -1)
+        };
+      else if (lastOfPath === "apply")
+        opts = {
+          args: args.length >= 2 ? args[1] : [],
+          path: path.slice(0, -1)
+        };
+      freezeIfAvailable(opts.args);
+      freezeIfAvailable(opts.path);
+      return callback(opts);
+    }
+  }));
+  return memo[cacheKey];
+}
+var createRecursiveProxy = (callback) => createInnerProxy(callback, [], emptyObject());
+var createFlatProxy = (callback) => {
+  return new Proxy(noop, { get(_obj, name) {
+    if (name === "then")
+      return;
+    return callback(name);
+  } });
+};
+var require_typeof2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(exports, module) {
+  function _typeof$2(o) {
+    "@babel/helpers - typeof";
+    return module.exports = _typeof$2 = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o$1) {
+      return typeof o$1;
+    } : function(o$1) {
+      return o$1 && typeof Symbol == "function" && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof$2(o);
+  }
+  module.exports = _typeof$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPrimitive2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(exports, module) {
+  var _typeof$1 = require_typeof2()["default"];
+  function toPrimitive$1(t, r) {
+    if (_typeof$1(t) != "object" || !t)
+      return t;
+    var e = t[Symbol.toPrimitive];
+    if (e !== undefined) {
+      var i = e.call(t, r || "default");
+      if (_typeof$1(i) != "object")
+        return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (r === "string" ? String : Number)(t);
+  }
+  module.exports = toPrimitive$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPropertyKey2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(exports, module) {
+  var _typeof = require_typeof2()["default"];
+  var toPrimitive = require_toPrimitive2();
+  function toPropertyKey$1(t) {
+    var i = toPrimitive(t, "string");
+    return _typeof(i) == "symbol" ? i : i + "";
+  }
+  module.exports = toPropertyKey$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_defineProperty2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(exports, module) {
+  var toPropertyKey = require_toPropertyKey2();
+  function _defineProperty(e, r, t) {
+    return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t, e;
+  }
+  module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_objectSpread22 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(exports, module) {
+  var defineProperty = require_defineProperty2();
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function(r$1) {
+        return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread2(e) {
+    for (var r = 1;r < arguments.length; r++) {
+      var t = arguments[r] != null ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), true).forEach(function(r$1) {
+        defineProperty(e, r$1, t[r$1]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+        Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+      });
+    }
+    return e;
+  }
+  module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_objectSpread2 = __toESM2(require_objectSpread22(), 1);
+
+// ../../node_modules/.bun/@trpc+server@11.17.0+1fb4c65d43e298b9/node_modules/@trpc/server/dist/tracked-DWInO6EQ.mjs
+var import_defineProperty = __toESM2(require_defineProperty2(), 1);
+var import_objectSpread2$1 = __toESM2(require_objectSpread22(), 1);
+function transformResultInner(response, transformer) {
+  if ("error" in response) {
+    const error = transformer.deserialize(response.error);
+    return {
+      ok: false,
+      error: (0, import_objectSpread2$1.default)((0, import_objectSpread2$1.default)({}, response), {}, { error })
+    };
+  }
+  const result = (0, import_objectSpread2$1.default)((0, import_objectSpread2$1.default)({}, response.result), (!response.result.type || response.result.type === "data") && {
+    type: "data",
+    data: transformer.deserialize(response.result.data)
+  });
+  return {
+    ok: true,
+    result
+  };
+}
+var TransformResultError = class extends Error {
+  constructor() {
+    super("Unable to transform response from server");
+  }
+};
+function transformResult(response, transformer) {
+  let result;
+  try {
+    result = transformResultInner(response, transformer);
+  } catch (_unused) {
+    throw new TransformResultError;
+  }
+  if (!result.ok && (!isObject(result.error.error) || typeof result.error.error["code"] !== "number"))
+    throw new TransformResultError;
+  if (result.ok && !isObject(result.result))
+    throw new TransformResultError;
+  return result;
+}
+var import_objectSpread22 = __toESM2(require_objectSpread22(), 1);
+var trackedSymbol = Symbol();
+// ../../node_modules/.bun/@trpc+client@11.17.0+f02ef5e6ba82b535/node_modules/@trpc/client/dist/TRPCClientError-apv8gw59.mjs
+var import_defineProperty2 = __toESM(require_defineProperty(), 1);
+var import_objectSpread23 = __toESM(require_objectSpread2(), 1);
+function isTRPCClientError(cause) {
+  return cause instanceof TRPCClientError;
+}
+function isTRPCErrorResponse(obj) {
+  return isObject(obj) && isObject(obj["error"]) && typeof obj["error"]["code"] === "number" && typeof obj["error"]["message"] === "string";
+}
+function getMessageFromUnknownError(err, fallback) {
+  if (typeof err === "string")
+    return err;
+  if (isObject(err) && typeof err["message"] === "string")
+    return err["message"];
+  return fallback;
+}
+var TRPCClientError = class TRPCClientError2 extends Error {
+  constructor(message, opts) {
+    var _opts$result, _opts$result2;
+    const cause = opts === null || opts === undefined ? undefined : opts.cause;
+    super(message, { cause });
+    (0, import_defineProperty2.default)(this, "cause", undefined);
+    (0, import_defineProperty2.default)(this, "shape", undefined);
+    (0, import_defineProperty2.default)(this, "data", undefined);
+    (0, import_defineProperty2.default)(this, "meta", undefined);
+    this.meta = opts === null || opts === undefined ? undefined : opts.meta;
+    this.cause = cause;
+    this.shape = opts === null || opts === undefined || (_opts$result = opts.result) === null || _opts$result === undefined ? undefined : _opts$result.error;
+    this.data = opts === null || opts === undefined || (_opts$result2 = opts.result) === null || _opts$result2 === undefined ? undefined : _opts$result2.error.data;
+    this.name = "TRPCClientError";
+    Object.setPrototypeOf(this, TRPCClientError2.prototype);
+  }
+  static from(_cause, opts = {}) {
+    const cause = _cause;
+    if (isTRPCClientError(cause)) {
+      if (opts.meta)
+        cause.meta = (0, import_objectSpread23.default)((0, import_objectSpread23.default)({}, cause.meta), opts.meta);
+      return cause;
+    }
+    if (isTRPCErrorResponse(cause))
+      return new TRPCClientError2(cause.error.message, (0, import_objectSpread23.default)((0, import_objectSpread23.default)({}, opts), {}, {
+        result: cause,
+        cause: opts.cause
+      }));
+    return new TRPCClientError2(getMessageFromUnknownError(cause, "Unknown error"), (0, import_objectSpread23.default)((0, import_objectSpread23.default)({}, opts), {}, { cause }));
+  }
+};
+
+// ../../node_modules/.bun/@trpc+client@11.17.0+f02ef5e6ba82b535/node_modules/@trpc/client/dist/unstable-internals-Bg7n9BBj.mjs
+function getTransformer(transformer) {
+  const _transformer = transformer;
+  if (!_transformer)
+    return {
+      input: {
+        serialize: (data) => data,
+        deserialize: (data) => data
+      },
+      output: {
+        serialize: (data) => data,
+        deserialize: (data) => data
+      }
+    };
+  if ("input" in _transformer)
+    return _transformer;
+  return {
+    input: _transformer,
+    output: _transformer
+  };
+}
+
+// ../../node_modules/.bun/@trpc+client@11.17.0+f02ef5e6ba82b535/node_modules/@trpc/client/dist/httpUtils-pyf5RF99.mjs
+var isFunction2 = (fn) => typeof fn === "function";
+function getFetch(customFetchImpl) {
+  if (customFetchImpl)
+    return customFetchImpl;
+  if (typeof window !== "undefined" && isFunction2(window.fetch))
+    return window.fetch;
+  if (typeof globalThis !== "undefined" && isFunction2(globalThis.fetch))
+    return globalThis.fetch;
+  throw new Error("No fetch implementation found");
+}
+var import_objectSpread24 = __toESM(require_objectSpread2(), 1);
+function resolveHTTPLinkOptions(opts) {
+  return {
+    url: opts.url.toString(),
+    fetch: opts.fetch,
+    transformer: getTransformer(opts.transformer),
+    methodOverride: opts.methodOverride
+  };
+}
+function arrayToDict(array) {
+  const dict = {};
+  for (let index = 0;index < array.length; index++) {
+    const element = array[index];
+    dict[index] = element;
+  }
+  return dict;
+}
+var METHOD = {
+  query: "GET",
+  mutation: "POST",
+  subscription: "PATCH"
+};
+function getInput(opts) {
+  return "input" in opts ? opts.transformer.input.serialize(opts.input) : arrayToDict(opts.inputs.map((_input) => opts.transformer.input.serialize(_input)));
+}
+var getUrl = (opts) => {
+  const parts = opts.url.split("?");
+  const base = parts[0].replace(/\/$/, "");
+  let url = base + "/" + opts.path;
+  const queryParts = [];
+  if (parts[1])
+    queryParts.push(parts[1]);
+  if ("inputs" in opts)
+    queryParts.push("batch=1");
+  if (opts.type === "query" || opts.type === "subscription") {
+    const input = getInput(opts);
+    if (input !== undefined && opts.methodOverride !== "POST")
+      queryParts.push(`input=${encodeURIComponent(JSON.stringify(input))}`);
+  }
+  if (queryParts.length)
+    url += "?" + queryParts.join("&");
+  return url;
+};
+var getBody = (opts) => {
+  if (opts.type === "query" && opts.methodOverride !== "POST")
+    return;
+  const input = getInput(opts);
+  return input !== undefined ? JSON.stringify(input) : undefined;
+};
+var jsonHttpRequester = (opts) => {
+  return httpRequest((0, import_objectSpread24.default)((0, import_objectSpread24.default)({}, opts), {}, {
+    contentTypeHeader: "application/json",
+    getUrl,
+    getBody
+  }));
+};
+var AbortError = class extends Error {
+  constructor() {
+    const name = "AbortError";
+    super(name);
+    this.name = name;
+    this.message = name;
+  }
+};
+var throwIfAborted = (signal) => {
+  var _signal$throwIfAborte;
+  if (!(signal === null || signal === undefined ? undefined : signal.aborted))
+    return;
+  (_signal$throwIfAborte = signal.throwIfAborted) === null || _signal$throwIfAborte === undefined || _signal$throwIfAborte.call(signal);
+  if (typeof DOMException !== "undefined")
+    throw new DOMException("AbortError", "AbortError");
+  throw new AbortError;
+};
+async function fetchHTTPResponse(opts) {
+  var _opts$methodOverride, _opts$trpcAcceptHeade;
+  throwIfAborted(opts.signal);
+  const url = opts.getUrl(opts);
+  const body = opts.getBody(opts);
+  const method = (_opts$methodOverride = opts.methodOverride) !== null && _opts$methodOverride !== undefined ? _opts$methodOverride : METHOD[opts.type];
+  const resolvedHeaders = await (async () => {
+    const heads = await opts.headers();
+    if (Symbol.iterator in heads)
+      return Object.fromEntries(heads);
+    return heads;
+  })();
+  const headers = (0, import_objectSpread24.default)((0, import_objectSpread24.default)((0, import_objectSpread24.default)({}, opts.contentTypeHeader && method !== "GET" ? { "content-type": opts.contentTypeHeader } : {}), opts.trpcAcceptHeader ? { [(_opts$trpcAcceptHeade = opts.trpcAcceptHeaderKey) !== null && _opts$trpcAcceptHeade !== undefined ? _opts$trpcAcceptHeade : "trpc-accept"]: opts.trpcAcceptHeader } : undefined), resolvedHeaders);
+  return getFetch(opts.fetch)(url, {
+    method,
+    signal: opts.signal,
+    body,
+    headers
+  });
+}
+async function httpRequest(opts) {
+  const meta = {};
+  const res = await fetchHTTPResponse(opts);
+  meta.response = res;
+  const json = await res.json();
+  meta.responseJSON = json;
+  return {
+    json,
+    meta
+  };
+}
+
+// ../../node_modules/.bun/@trpc+client@11.17.0+f02ef5e6ba82b535/node_modules/@trpc/client/dist/httpLink-lG_6juPY.mjs
+var import_objectSpread25 = __toESM(require_objectSpread2(), 1);
+
+// ../../node_modules/.bun/@trpc+client@11.17.0+f02ef5e6ba82b535/node_modules/@trpc/client/dist/httpBatchLink-LhidKAPw.mjs
+var throwFatalError = () => {
+  throw new Error("Something went wrong. Please submit an issue at https://github.com/trpc/trpc/issues/new");
+};
+function dataLoader(batchLoader) {
+  let pendingItems = null;
+  let dispatchTimer = null;
+  const destroyTimerAndPendingItems = () => {
+    clearTimeout(dispatchTimer);
+    dispatchTimer = null;
+    pendingItems = null;
+  };
+  function groupItems(items) {
+    const groupedItems = [[]];
+    let index = 0;
+    while (true) {
+      const item = items[index];
+      if (!item)
+        break;
+      const lastGroup = groupedItems[groupedItems.length - 1];
+      if (item.aborted) {
+        var _item$reject;
+        (_item$reject = item.reject) === null || _item$reject === undefined || _item$reject.call(item, new Error("Aborted"));
+        index++;
+        continue;
+      }
+      const isValid = batchLoader.validate(lastGroup.concat(item).map((it) => it.key));
+      if (isValid) {
+        lastGroup.push(item);
+        index++;
+        continue;
+      }
+      if (lastGroup.length === 0) {
+        var _item$reject2;
+        (_item$reject2 = item.reject) === null || _item$reject2 === undefined || _item$reject2.call(item, new Error("Input is too big for a single dispatch"));
+        index++;
+        continue;
+      }
+      groupedItems.push([]);
+    }
+    return groupedItems;
+  }
+  function dispatch() {
+    const groupedItems = groupItems(pendingItems);
+    destroyTimerAndPendingItems();
+    for (const items of groupedItems) {
+      if (!items.length)
+        continue;
+      const batch = { items };
+      for (const item of items)
+        item.batch = batch;
+      const promise = batchLoader.fetch(batch.items.map((_item) => _item.key));
+      promise.then(async (result) => {
+        await Promise.all(result.map(async (valueOrPromise, index) => {
+          const item = batch.items[index];
+          try {
+            var _item$resolve;
+            const value = await Promise.resolve(valueOrPromise);
+            (_item$resolve = item.resolve) === null || _item$resolve === undefined || _item$resolve.call(item, value);
+          } catch (cause) {
+            var _item$reject3;
+            (_item$reject3 = item.reject) === null || _item$reject3 === undefined || _item$reject3.call(item, cause);
+          }
+          item.batch = null;
+          item.reject = null;
+          item.resolve = null;
+        }));
+        for (const item of batch.items) {
+          var _item$reject4;
+          (_item$reject4 = item.reject) === null || _item$reject4 === undefined || _item$reject4.call(item, new Error("Missing result"));
+          item.batch = null;
+        }
+      }).catch((cause) => {
+        for (const item of batch.items) {
+          var _item$reject5;
+          (_item$reject5 = item.reject) === null || _item$reject5 === undefined || _item$reject5.call(item, cause);
+          item.batch = null;
+        }
+      });
+    }
+  }
+  function load(key) {
+    var _dispatchTimer;
+    const item = {
+      aborted: false,
+      key,
+      batch: null,
+      resolve: throwFatalError,
+      reject: throwFatalError
+    };
+    const promise = new Promise((resolve, reject) => {
+      var _pendingItems;
+      item.reject = reject;
+      item.resolve = resolve;
+      (_pendingItems = pendingItems) !== null && _pendingItems !== undefined || (pendingItems = []);
+      pendingItems.push(item);
+    });
+    (_dispatchTimer = dispatchTimer) !== null && _dispatchTimer !== undefined || (dispatchTimer = setTimeout(dispatch));
+    return promise;
+  }
+  return { load };
+}
+function allAbortSignals(...signals) {
+  const ac = new AbortController;
+  const count = signals.length;
+  let abortedCount = 0;
+  const onAbort = () => {
+    if (++abortedCount === count)
+      ac.abort();
+  };
+  for (const signal of signals)
+    if (signal === null || signal === undefined ? undefined : signal.aborted)
+      onAbort();
+    else
+      signal === null || signal === undefined || signal.addEventListener("abort", onAbort, { once: true });
+  return ac.signal;
+}
+var import_objectSpread26 = __toESM(require_objectSpread2(), 1);
+function httpBatchLink(opts) {
+  var _opts$maxURLLength, _opts$maxItems;
+  const resolvedOpts = resolveHTTPLinkOptions(opts);
+  const maxURLLength = (_opts$maxURLLength = opts.maxURLLength) !== null && _opts$maxURLLength !== undefined ? _opts$maxURLLength : Infinity;
+  const maxItems = (_opts$maxItems = opts.maxItems) !== null && _opts$maxItems !== undefined ? _opts$maxItems : Infinity;
+  return () => {
+    const batchLoader = (type) => {
+      return {
+        validate(batchOps) {
+          if (maxURLLength === Infinity && maxItems === Infinity)
+            return true;
+          if (batchOps.length > maxItems)
+            return false;
+          const path = batchOps.map((op) => op.path).join(",");
+          const inputs = batchOps.map((op) => op.input);
+          const url = getUrl((0, import_objectSpread26.default)((0, import_objectSpread26.default)({}, resolvedOpts), {}, {
+            type,
+            path,
+            inputs,
+            signal: null
+          }));
+          return url.length <= maxURLLength;
+        },
+        async fetch(batchOps) {
+          const path = batchOps.map((op) => op.path).join(",");
+          const inputs = batchOps.map((op) => op.input);
+          const signal = allAbortSignals(...batchOps.map((op) => op.signal));
+          const res = await jsonHttpRequester((0, import_objectSpread26.default)((0, import_objectSpread26.default)({}, resolvedOpts), {}, {
+            path,
+            inputs,
+            type,
+            headers() {
+              if (!opts.headers)
+                return {};
+              if (typeof opts.headers === "function")
+                return opts.headers({ opList: batchOps });
+              return opts.headers;
+            },
+            signal
+          }));
+          const resJSON = Array.isArray(res.json) ? res.json : batchOps.map(() => res.json);
+          const result = resJSON.map((item) => ({
+            meta: res.meta,
+            json: item
+          }));
+          return result;
+        }
+      };
+    };
+    const query = dataLoader(batchLoader("query"));
+    const mutation = dataLoader(batchLoader("mutation"));
+    const loaders = {
+      query,
+      mutation
+    };
+    return ({ op }) => {
+      return observable((observer) => {
+        if (op.type === "subscription")
+          throw new Error("Subscriptions are unsupported by `httpLink` - use `httpSubscriptionLink` or `wsLink`");
+        const loader = loaders[op.type];
+        const promise = loader.load(op);
+        let _res = undefined;
+        promise.then((res) => {
+          _res = res;
+          const transformed = transformResult(res.json, resolvedOpts.transformer.output);
+          if (!transformed.ok) {
+            observer.error(TRPCClientError.from(transformed.error, { meta: res.meta }));
+            return;
+          }
+          observer.next({
+            context: res.meta,
+            result: transformed.result
+          });
+          observer.complete();
+        }).catch((err) => {
+          observer.error(TRPCClientError.from(err, { meta: _res === null || _res === undefined ? undefined : _res.meta }));
+        });
+        return () => {};
+      });
+    };
+  };
+}
+
+// ../../node_modules/.bun/@trpc+client@11.17.0+f02ef5e6ba82b535/node_modules/@trpc/client/dist/loggerLink-ineCN1PO.mjs
+var import_objectSpread27 = __toESM(require_objectSpread2(), 1);
+
+// ../../node_modules/.bun/@trpc+client@11.17.0+f02ef5e6ba82b535/node_modules/@trpc/client/dist/wsLink-DSf4KOdW.mjs
+var resultOf = (value, ...args) => {
+  return typeof value === "function" ? value(...args) : value;
+};
+var import_defineProperty$3 = __toESM(require_defineProperty(), 1);
+function withResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+async function prepareUrl(urlOptions) {
+  const url = await resultOf(urlOptions.url);
+  if (!urlOptions.connectionParams)
+    return url;
+  const prefix = url.includes("?") ? "&" : "?";
+  const connectionParams = `${prefix}connectionParams=1`;
+  return url + connectionParams;
+}
+async function buildConnectionMessage(connectionParams, encoder) {
+  const message = {
+    method: "connectionParams",
+    data: await resultOf(connectionParams)
+  };
+  return encoder.encode(message);
+}
+var import_defineProperty$2 = __toESM(require_defineProperty(), 1);
+var import_defineProperty$1 = __toESM(require_defineProperty(), 1);
+function asyncWsOpen(ws) {
+  const { promise, resolve, reject } = withResolvers();
+  ws.addEventListener("open", () => {
+    ws.removeEventListener("error", reject);
+    resolve();
+  });
+  ws.addEventListener("error", reject);
+  return promise;
+}
+function setupPingInterval(ws, { intervalMs, pongTimeoutMs }) {
+  let pingTimeout;
+  let pongTimeout;
+  function start() {
+    pingTimeout = setTimeout(() => {
+      ws.send("PING");
+      pongTimeout = setTimeout(() => {
+        ws.close();
+      }, pongTimeoutMs);
+    }, intervalMs);
+  }
+  function reset() {
+    clearTimeout(pingTimeout);
+    start();
+  }
+  function pong() {
+    clearTimeout(pongTimeout);
+    reset();
+  }
+  ws.addEventListener("open", start);
+  ws.addEventListener("message", ({ data }) => {
+    clearTimeout(pingTimeout);
+    start();
+    if (data === "PONG")
+      pong();
+  });
+  ws.addEventListener("close", () => {
+    clearTimeout(pingTimeout);
+    clearTimeout(pongTimeout);
+  });
+}
+var WsConnection = class WsConnection2 {
+  constructor(opts) {
+    var _opts$WebSocketPonyfi;
+    (0, import_defineProperty$1.default)(this, "id", ++WsConnection2.connectCount);
+    (0, import_defineProperty$1.default)(this, "WebSocketPonyfill", undefined);
+    (0, import_defineProperty$1.default)(this, "urlOptions", undefined);
+    (0, import_defineProperty$1.default)(this, "keepAliveOpts", undefined);
+    (0, import_defineProperty$1.default)(this, "encoder", undefined);
+    (0, import_defineProperty$1.default)(this, "wsObservable", behaviorSubject(null));
+    (0, import_defineProperty$1.default)(this, "openPromise", null);
+    this.WebSocketPonyfill = (_opts$WebSocketPonyfi = opts.WebSocketPonyfill) !== null && _opts$WebSocketPonyfi !== undefined ? _opts$WebSocketPonyfi : WebSocket;
+    if (!this.WebSocketPonyfill)
+      throw new Error("No WebSocket implementation found - you probably don't want to use this on the server, but if you do you need to pass a `WebSocket`-ponyfill");
+    this.urlOptions = opts.urlOptions;
+    this.keepAliveOpts = opts.keepAlive;
+    this.encoder = opts.encoder;
+  }
+  get ws() {
+    return this.wsObservable.get();
+  }
+  set ws(ws) {
+    this.wsObservable.next(ws);
+  }
+  isOpen() {
+    return !!this.ws && this.ws.readyState === this.WebSocketPonyfill.OPEN && !this.openPromise;
+  }
+  isClosed() {
+    return !!this.ws && (this.ws.readyState === this.WebSocketPonyfill.CLOSING || this.ws.readyState === this.WebSocketPonyfill.CLOSED);
+  }
+  async open() {
+    var _this = this;
+    if (_this.openPromise)
+      return _this.openPromise;
+    _this.id = ++WsConnection2.connectCount;
+    const wsPromise = prepareUrl(_this.urlOptions).then((url) => new _this.WebSocketPonyfill(url));
+    _this.openPromise = wsPromise.then(async (ws) => {
+      _this.ws = ws;
+      ws.binaryType = "arraybuffer";
+      ws.addEventListener("message", function({ data }) {
+        if (data === "PING")
+          this.send("PONG");
+      });
+      if (_this.keepAliveOpts.enabled)
+        setupPingInterval(ws, _this.keepAliveOpts);
+      ws.addEventListener("close", () => {
+        if (_this.ws === ws)
+          _this.ws = null;
+      });
+      await asyncWsOpen(ws);
+      if (_this.urlOptions.connectionParams)
+        ws.send(await buildConnectionMessage(_this.urlOptions.connectionParams, _this.encoder));
+    });
+    try {
+      await _this.openPromise;
+    } finally {
+      _this.openPromise = null;
+    }
+  }
+  async close() {
+    var _this2 = this;
+    try {
+      await _this2.openPromise;
+    } finally {
+      var _this$ws;
+      (_this$ws = _this2.ws) === null || _this$ws === undefined || _this$ws.close();
+    }
+  }
+};
+(0, import_defineProperty$1.default)(WsConnection, "connectCount", 0);
+var import_defineProperty3 = __toESM(require_defineProperty(), 1);
+var import_objectSpread28 = __toESM(require_objectSpread2(), 1);
+
+// ../../node_modules/.bun/@trpc+client@11.17.0+f02ef5e6ba82b535/node_modules/@trpc/client/dist/index.mjs
+var import_defineProperty4 = __toESM(require_defineProperty(), 1);
+var import_objectSpread2$4 = __toESM(require_objectSpread2(), 1);
+var TRPCUntypedClient = class {
+  constructor(opts) {
+    (0, import_defineProperty4.default)(this, "links", undefined);
+    (0, import_defineProperty4.default)(this, "runtime", undefined);
+    (0, import_defineProperty4.default)(this, "requestId", undefined);
+    this.requestId = 0;
+    this.runtime = {};
+    this.links = opts.links.map((link) => link(this.runtime));
+  }
+  $request(opts) {
+    var _opts$context;
+    const chain$ = createChain({
+      links: this.links,
+      op: (0, import_objectSpread2$4.default)((0, import_objectSpread2$4.default)({}, opts), {}, {
+        context: (_opts$context = opts.context) !== null && _opts$context !== undefined ? _opts$context : {},
+        id: ++this.requestId
+      })
+    });
+    return chain$.pipe(share());
+  }
+  async requestAsPromise(opts) {
+    var _this = this;
+    try {
+      const req$ = _this.$request(opts);
+      const envelope = await observableToPromise(req$);
+      const data = envelope.result.data;
+      return data;
+    } catch (err) {
+      throw TRPCClientError.from(err);
+    }
+  }
+  query(path, input, opts) {
+    return this.requestAsPromise({
+      type: "query",
+      path,
+      input,
+      context: opts === null || opts === undefined ? undefined : opts.context,
+      signal: opts === null || opts === undefined ? undefined : opts.signal
+    });
+  }
+  mutation(path, input, opts) {
+    return this.requestAsPromise({
+      type: "mutation",
+      path,
+      input,
+      context: opts === null || opts === undefined ? undefined : opts.context,
+      signal: opts === null || opts === undefined ? undefined : opts.signal
+    });
+  }
+  subscription(path, input, opts) {
+    const observable$ = this.$request({
+      type: "subscription",
+      path,
+      input,
+      context: opts.context,
+      signal: opts.signal
+    });
+    return observable$.subscribe({
+      next(envelope) {
+        switch (envelope.result.type) {
+          case "state": {
+            var _opts$onConnectionSta;
+            (_opts$onConnectionSta = opts.onConnectionStateChange) === null || _opts$onConnectionSta === undefined || _opts$onConnectionSta.call(opts, envelope.result);
+            break;
+          }
+          case "started": {
+            var _opts$onStarted;
+            (_opts$onStarted = opts.onStarted) === null || _opts$onStarted === undefined || _opts$onStarted.call(opts, { context: envelope.context });
+            break;
+          }
+          case "stopped": {
+            var _opts$onStopped;
+            (_opts$onStopped = opts.onStopped) === null || _opts$onStopped === undefined || _opts$onStopped.call(opts);
+            break;
+          }
+          case "data":
+          case undefined: {
+            var _opts$onData;
+            (_opts$onData = opts.onData) === null || _opts$onData === undefined || _opts$onData.call(opts, envelope.result.data);
+            break;
+          }
+        }
+      },
+      error(err) {
+        var _opts$onError;
+        (_opts$onError = opts.onError) === null || _opts$onError === undefined || _opts$onError.call(opts, err);
+      },
+      complete() {
+        var _opts$onComplete;
+        (_opts$onComplete = opts.onComplete) === null || _opts$onComplete === undefined || _opts$onComplete.call(opts);
+      }
+    });
+  }
+};
+var untypedClientSymbol = Symbol.for("trpc_untypedClient");
+var clientCallTypeMap = {
+  query: "query",
+  mutate: "mutation",
+  subscribe: "subscription"
+};
+var clientCallTypeToProcedureType = (clientCallType) => {
+  return clientCallTypeMap[clientCallType];
+};
+function createTRPCClientProxy(client) {
+  const proxy = createRecursiveProxy(({ path, args }) => {
+    const pathCopy = [...path];
+    const procedureType = clientCallTypeToProcedureType(pathCopy.pop());
+    const fullPath = pathCopy.join(".");
+    return client[procedureType](fullPath, ...args);
+  });
+  return createFlatProxy((key) => {
+    if (key === untypedClientSymbol)
+      return client;
+    return proxy[key];
+  });
+}
+function createTRPCClient(opts) {
+  const client = new TRPCUntypedClient(opts);
+  const proxy = createTRPCClientProxy(client);
+  return proxy;
+}
+var import_objectSpread2$3 = __toESM(require_objectSpread2(), 1);
+var import_objectSpread2$2 = __toESM(require_objectSpread2(), 1);
+var require_asyncIterator = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncIterator.js"(exports, module) {
+  function _asyncIterator$1(r) {
+    var n, t, o, e = 2;
+    for (typeof Symbol != "undefined" && (t = Symbol.asyncIterator, o = Symbol.iterator);e--; ) {
+      if (t && (n = r[t]) != null)
+        return n.call(r);
+      if (o && (n = r[o]) != null)
+        return new AsyncFromSyncIterator(n.call(r));
+      t = "@@asyncIterator", o = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+  }
+  function AsyncFromSyncIterator(r) {
+    function AsyncFromSyncIteratorContinuation(r$1) {
+      if (Object(r$1) !== r$1)
+        return Promise.reject(new TypeError(r$1 + " is not an object."));
+      var n = r$1.done;
+      return Promise.resolve(r$1.value).then(function(r$2) {
+        return {
+          value: r$2,
+          done: n
+        };
+      });
+    }
+    return AsyncFromSyncIterator = function AsyncFromSyncIterator$1(r$1) {
+      this.s = r$1, this.n = r$1.next;
+    }, AsyncFromSyncIterator.prototype = {
+      s: null,
+      n: null,
+      next: function next() {
+        return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+      },
+      return: function _return(r$1) {
+        var n = this.s["return"];
+        return n === undefined ? Promise.resolve({
+          value: r$1,
+          done: true
+        }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+      },
+      throw: function _throw(r$1) {
+        var n = this.s["return"];
+        return n === undefined ? Promise.reject(r$1) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+      }
+    }, new AsyncFromSyncIterator(r);
+  }
+  module.exports = _asyncIterator$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_asyncIterator = __toESM(require_asyncIterator(), 1);
+var import_objectSpread2$12 = __toESM(require_objectSpread2(), 1);
+var require_usingCtx = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js"(exports, module) {
+  function _usingCtx() {
+    var r = typeof SuppressedError == "function" ? SuppressedError : function(r$1, e$1) {
+      var n$1 = Error();
+      return n$1.name = "SuppressedError", n$1.error = r$1, n$1.suppressed = e$1, n$1;
+    }, e = {}, n = [];
+    function using(r$1, e$1) {
+      if (e$1 != null) {
+        if (Object(e$1) !== e$1)
+          throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+        if (r$1)
+          var o = e$1[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+        if (o === undefined && (o = e$1[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r$1))
+          var t = o;
+        if (typeof o != "function")
+          throw new TypeError("Object is not disposable.");
+        t && (o = function o$1() {
+          try {
+            t.call(e$1);
+          } catch (r$2) {
+            return Promise.reject(r$2);
+          }
+        }), n.push({
+          v: e$1,
+          d: o,
+          a: r$1
+        });
+      } else
+        r$1 && n.push({
+          d: e$1,
+          a: r$1
+        });
+      return e$1;
+    }
+    return {
+      e,
+      u: using.bind(null, false),
+      a: using.bind(null, true),
+      d: function d() {
+        var o, t = this.e, s = 0;
+        function next() {
+          for (;o = n.pop(); )
+            try {
+              if (!o.a && s === 1)
+                return s = 0, n.push(o), Promise.resolve().then(next);
+              if (o.d) {
+                var r$1 = o.d.call(o.v);
+                if (o.a)
+                  return s |= 2, Promise.resolve(r$1).then(next, err);
+              } else
+                s |= 1;
+            } catch (r$2) {
+              return err(r$2);
+            }
+          if (s === 1)
+            return t !== e ? Promise.reject(t) : Promise.resolve();
+          if (t !== e)
+            throw t;
+        }
+        function err(n$1) {
+          return t = t !== e ? new r(n$1, t) : n$1, next();
+        }
+        return next();
+      }
+    };
+  }
+  module.exports = _usingCtx, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_OverloadYield = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/OverloadYield.js"(exports, module) {
+  function _OverloadYield(e, d) {
+    this.v = e, this.k = d;
+  }
+  module.exports = _OverloadYield, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_awaitAsyncGenerator = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/awaitAsyncGenerator.js"(exports, module) {
+  var OverloadYield$1 = require_OverloadYield();
+  function _awaitAsyncGenerator$1(e) {
+    return new OverloadYield$1(e, 0);
+  }
+  module.exports = _awaitAsyncGenerator$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_wrapAsyncGenerator = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/wrapAsyncGenerator.js"(exports, module) {
+  var OverloadYield = require_OverloadYield();
+  function _wrapAsyncGenerator$1(e) {
+    return function() {
+      return new AsyncGenerator(e.apply(this, arguments));
+    };
+  }
+  function AsyncGenerator(e) {
+    var r, t;
+    function resume(r$1, t$1) {
+      try {
+        var n = e[r$1](t$1), o = n.value, u = o instanceof OverloadYield;
+        Promise.resolve(u ? o.v : o).then(function(t$2) {
+          if (u) {
+            var i = r$1 === "return" ? "return" : "next";
+            if (!o.k || t$2.done)
+              return resume(i, t$2);
+            t$2 = e[i](t$2).value;
+          }
+          settle(n.done ? "return" : "normal", t$2);
+        }, function(e$1) {
+          resume("throw", e$1);
+        });
+      } catch (e$1) {
+        settle("throw", e$1);
+      }
+    }
+    function settle(e$1, n) {
+      switch (e$1) {
+        case "return":
+          r.resolve({
+            value: n,
+            done: true
+          });
+          break;
+        case "throw":
+          r.reject(n);
+          break;
+        default:
+          r.resolve({
+            value: n,
+            done: false
+          });
+      }
+      (r = r.next) ? resume(r.key, r.arg) : t = null;
+    }
+    this._invoke = function(e$1, n) {
+      return new Promise(function(o, u) {
+        var i = {
+          key: e$1,
+          arg: n,
+          resolve: o,
+          reject: u,
+          next: null
+        };
+        t ? t = t.next = i : (r = t = i, resume(e$1, n));
+      });
+    }, typeof e["return"] != "function" && (this["return"] = undefined);
+  }
+  AsyncGenerator.prototype[typeof Symbol == "function" && Symbol.asyncIterator || "@@asyncIterator"] = function() {
+    return this;
+  }, AsyncGenerator.prototype.next = function(e) {
+    return this._invoke("next", e);
+  }, AsyncGenerator.prototype["throw"] = function(e) {
+    return this._invoke("throw", e);
+  }, AsyncGenerator.prototype["return"] = function(e) {
+    return this._invoke("return", e);
+  };
+  module.exports = _wrapAsyncGenerator$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_usingCtx = __toESM(require_usingCtx(), 1);
+var import_awaitAsyncGenerator = __toESM(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator = __toESM(require_wrapAsyncGenerator(), 1);
+var import_objectSpread29 = __toESM(require_objectSpread2(), 1);
+
+// ../../packages/sdk/src/index.ts
+async function createAuthorizationHeaders(getAuthToken) {
+  const token = await getAuthToken?.();
+  if (!token) {
+    return {};
+  }
+  return {
+    authorization: `Bearer ${token}`
+  };
+}
+async function getCadenceHealth(options = {}) {
+  const baseUrl = options.baseUrl ?? getDefaultApiBaseUrl();
+  const requestFetch = options.fetch ?? fetch;
+  const response = await requestFetch(`${baseUrl}/health`, {
+    headers: await createAuthorizationHeaders(options.getAuthToken)
+  });
+  if (!response.ok) {
+    throw new Error(`Cadence API health check failed with HTTP ${response.status}.`);
+  }
+  return await response.json();
+}
+function createCadenceClient(options = {}) {
+  const baseUrl = options.baseUrl ?? getDefaultApiBaseUrl();
+  const healthOptions = {
+    baseUrl,
+    ...options.getAuthToken ? { getAuthToken: options.getAuthToken } : {},
+    ...options.fetch ? { fetch: options.fetch } : {}
+  };
+  const rpc = createTRPCClient({
+    links: [
+      httpBatchLink({
+        url: `${baseUrl}/trpc`,
+        ...options.fetch ? { fetch: options.fetch } : {},
+        headers: () => createAuthorizationHeaders(options.getAuthToken)
+      })
+    ]
+  });
+  return {
+    packageName: "@cadence/sdk",
+    baseUrl,
+    rpc,
+    health: () => getCadenceHealth(healthOptions),
+    auth: {
+      login: (input) => rpc.auth.login.mutate(input)
+    },
+    events: {
+      list: (input) => rpc.events.list.query(input)
+    },
+    work: {
+      overview: (input) => rpc.work.overview.query(input)
+    },
+    tickets: {
+      get: (input) => rpc.tickets.get.query(input),
+      list: (input) => rpc.tickets.list.query(input),
+      create: (input) => rpc.tickets.create.mutate(input),
+      attach: (input) => rpc.tickets.attach.mutate(input),
+      update: (input) => rpc.tickets.update.mutate(input),
+      changeStatus: (input) => rpc.tickets.changeStatus.mutate(input),
+      complete: (input) => rpc.tickets.complete.mutate(input)
+    },
+    intake: {
+      create: (input) => rpc.intake.create.mutate(input),
+      dismiss: (input) => rpc.intake.dismiss.mutate(input)
+    },
+    sessions: {
+      start: (input) => rpc.sessions.start.mutate(input),
+      end: (input) => rpc.sessions.end.mutate(input),
+      current: (input) => rpc.sessions.current.query(input),
+      leases: {
+        create: (input) => rpc.sessions.leases.create.mutate(input),
+        release: (input) => rpc.sessions.leases.release.mutate(input)
+      }
+    },
+    changesets: {
+      create: (input) => rpc.changesets.create.mutate(input),
+      get: (input) => rpc.changesets.get.query(input),
+      list: (input) => rpc.changesets.list.query(input)
+    }
+  };
+}
+
+// src/index.ts
+import { spawnSync } from "child_process";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, join, parse } from "path";
+import { createInterface } from "readline/promises";
+var ticketPriorities = ["low", "normal", "high", "urgent"];
+var ticketStatuses = ["backlog", "ready", "in_progress", "blocked", "review", "done", "abandoned"];
+var defaultLeaseTtlSeconds = 5 * 60 * 60;
+var defaultCliApiBaseUrl = "https://cadenceapi.deploy.lvl8studios.com";
+
+class CliError extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.details = details;
+  }
+}
+function readFlagValue(argv, index, flag) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) {
+    throw new CliError("CLI_USAGE", `${flag} requires a value.`);
+  }
+  return value;
+}
+var knownCommandPaths = [
+  ["auth", "login"],
+  ["auth", "status"],
+  ["auth", "logout"],
+  ["changesets", "create"],
+  ["changesets", "list"],
+  ["changesets", "get"],
+  ["sessions", "start"],
+  ["sessions", "end"],
+  ["sessions", "current"],
+  ["intake", "dismiss"],
+  ["intake"],
+  ["tickets", "attach"],
+  ["tickets", "complete"],
+  ["tickets", "release"],
+  ["tickets", "claim"],
+  ["tickets", "update"],
+  ["tickets", "create"],
+  ["tickets", "list"],
+  ["tickets", "get"],
+  ["events", "list"],
+  ["work", "overview"],
+  ["init"],
+  ["status"],
+  ["help"]
+];
+function isCommandMatch(words, commandPath) {
+  return commandPath.every((part, index) => words[index] === part);
+}
+function resolveCommandPath(words) {
+  if (words.length === 0) {
+    return {
+      path: ["help"],
+      args: []
+    };
+  }
+  const commandPath = knownCommandPaths.find((candidate) => isCommandMatch(words, candidate));
+  if (!commandPath) {
+    return {
+      path: words,
+      args: []
+    };
+  }
+  return {
+    path: [...commandPath],
+    args: words.slice(commandPath.length)
+  };
+}
+function parseCliArgs(argv) {
+  const words = [];
+  const options = {};
+  let json = false;
+  let help = false;
+  let server;
+  let project;
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+      continue;
+    }
+    if (arg === "--server") {
+      server = readFlagValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--project") {
+      project = readFlagValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      options[arg.slice(2)] = readFlagValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    words.push(arg);
+  }
+  const command = resolveCommandPath(words);
+  return {
+    command: {
+      path: command.path,
+      name: command.path.join(".")
+    },
+    args: command.args,
+    flags: {
+      json,
+      help,
+      ...server ? { server } : {},
+      ...project ? { project } : {}
+    },
+    options
+  };
+}
+function safeJsonParse(source, filePath) {
+  const parsed = JSON.parse(source);
+  if (!parsed || typeof parsed !== "object") {
+    throw new CliError("CONFIG_ERROR", `${filePath} must contain a JSON object.`);
+  }
+  const record = parsed;
+  const server = typeof record.server === "string" ? record.server : undefined;
+  const projectId = typeof record.projectId === "string" ? record.projectId : typeof record.project === "string" ? record.project : undefined;
+  return {
+    ...server ? { server } : {},
+    ...projectId ? { projectId } : {}
+  };
+}
+async function readOptionalConfig(filePath) {
+  const file = Bun.file(filePath);
+  if (!await file.exists()) {
+    return {};
+  }
+  return safeJsonParse(await file.text(), filePath);
+}
+async function writeConfigFile(filePath, config) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(config, null, 2)}
+`);
+}
+async function mergeConfigFile(filePath, updates) {
+  const existing = await readOptionalConfig(filePath);
+  await writeConfigFile(filePath, {
+    ...existing,
+    ...updates
+  });
+}
+async function findRepoConfigPath(cwd) {
+  let current = cwd;
+  while (true) {
+    const candidate = join(current, ".cadence", "config.json");
+    if (await Bun.file(candidate).exists()) {
+      return candidate;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function getConfigHome(env) {
+  return env.CADENCE_CONFIG_HOME ?? (env.HOME ? join(env.HOME, ".config", "cadence") : join(parse(process.cwd()).root, ".config", "cadence"));
+}
+async function resolveCliConfig(flags, options = {}) {
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? process.cwd();
+  const globalConfigPath = join(getConfigHome(env), "config.json");
+  const repoConfigPath = await findRepoConfigPath(cwd);
+  const repoConfigPromise = repoConfigPath ? readOptionalConfig(repoConfigPath) : Promise.resolve({});
+  const [globalConfig, repoConfig] = await Promise.all([
+    readOptionalConfig(globalConfigPath),
+    repoConfigPromise
+  ]);
+  const server = flags.server ?? repoConfig.server ?? globalConfig.server ?? defaultCliApiBaseUrl;
+  const projectId = flags.project ?? repoConfig.projectId ?? globalConfig.projectId ?? null;
+  return {
+    server,
+    projectId,
+    repoConfigPath,
+    globalConfigPath
+  };
+}
+function runSecurity(args, input) {
+  return spawnSync("security", [...args], {
+    encoding: "utf8",
+    ...input ? { input } : {}
+  });
+}
+function createMacOsKeychainCredentialStore() {
+  const service = "cadence-cli";
+  return {
+    async isAvailable() {
+      if (process.platform !== "darwin") {
+        return false;
+      }
+      const result = runSecurity(["-h"]);
+      return result.error === undefined;
+    },
+    async getCredential(server) {
+      const result = runSecurity(["find-generic-password", "-a", server, "-s", service, "-w"]);
+      if (result.status !== 0) {
+        return null;
+      }
+      return result.stdout.trim() || null;
+    },
+    async setCredential(server, credential) {
+      const result = runSecurity(["add-generic-password", "-a", server, "-s", service, "-w", credential, "-U"]);
+      if (result.status !== 0) {
+        throw new CliError("CREDENTIAL_STORE_ERROR", "Could not store credential in the OS secure credential store.");
+      }
+    },
+    async deleteCredential(server) {
+      const result = runSecurity(["delete-generic-password", "-a", server, "-s", service]);
+      if (result.status !== 0 && !String(result.stderr).includes("could not be found")) {
+        throw new CliError("CREDENTIAL_STORE_ERROR", "Could not delete credential from the OS secure credential store.");
+      }
+    }
+  };
+}
+function getCredentialStore(options) {
+  return options.credentialStore ?? createMacOsKeychainCredentialStore();
+}
+async function readPromptText(options, message) {
+  return options.readText ? options.readText(message) : promptText(message);
+}
+async function readPromptSecret(options, message) {
+  return options.readSecret ? options.readSecret(message) : promptSecret(message);
+}
+function encodeCredential(credential) {
+  return JSON.stringify(credential);
+}
+function decodeCredential(rawCredential) {
+  try {
+    const parsed = JSON.parse(rawCredential);
+    if (parsed && typeof parsed === "object" && typeof parsed.accessToken === "string") {
+      const record = parsed;
+      return {
+        accessToken: record.accessToken,
+        ...typeof record.refreshToken === "string" ? { refreshToken: record.refreshToken } : {},
+        ...typeof record.expiresAt === "string" ? { expiresAt: record.expiresAt } : {},
+        ...typeof record.tokenType === "string" ? { tokenType: record.tokenType } : {}
+      };
+    }
+  } catch {}
+  return {
+    accessToken: rawCredential
+  };
+}
+async function readStoredCredential(store, server) {
+  if (!await store.isAvailable()) {
+    return null;
+  }
+  const rawCredential = await store.getCredential(server);
+  return rawCredential ? decodeCredential(rawCredential) : null;
+}
+async function requireCredentialStore(store) {
+  if (!await store.isAvailable()) {
+    throw new CliError("CREDENTIAL_STORE_UNAVAILABLE", "OS secure credential storage is unavailable.");
+  }
+}
+async function promptText(message) {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    throw new CliError("AUTH_INTERACTIVE_REQUIRED", "Interactive auth requires a TTY.");
+  }
+  const readline = createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  try {
+    return await readline.question(message);
+  } finally {
+    readline.close();
+  }
+}
+async function promptSecret(message) {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    throw new CliError("AUTH_INTERACTIVE_REQUIRED", "Interactive auth requires a TTY.");
+  }
+  spawnSync("stty", ["-echo"], { stdio: ["inherit", "ignore", "ignore"] });
+  try {
+    return await promptText(message);
+  } finally {
+    spawnSync("stty", ["echo"], { stdio: ["inherit", "ignore", "ignore"] });
+    process.stderr.write(`
+`);
+  }
+}
+function successEnvelope(data, meta) {
+  return {
+    success: true,
+    data,
+    error: null,
+    meta
+  };
+}
+function errorEnvelope(error, meta) {
+  const cliError = error instanceof CliError ? error : new CliError("API_ERROR", error.message || "Unexpected CLI error.");
+  return {
+    success: false,
+    data: null,
+    error: {
+      code: cliError.code,
+      message: cliError.message,
+      details: cliError.details
+    },
+    meta
+  };
+}
+function formatJson(envelope) {
+  return `${JSON.stringify(envelope, null, 2)}
+`;
+}
+function helpText() {
+  return [
+    "Cadence CLI",
+    "",
+    "Usage:",
+    "  cadence init --project <project-id> [--json]",
+    "  cadence auth login [--json]",
+    "  cadence auth status [--json]",
+    "  cadence auth logout [--json]",
+    "  cadence status [--project <project-id>] [--json]",
+    "  cadence work overview [--project <project-id>] [--json]",
+    "  cadence tickets get <ticket-id> [--project <project-id>] [--json]",
+    "  cadence tickets list [--project <project-id>] [--status <status>] [--json]",
+    '  cadence intake "<request>" [--project <project-id>] [--json]',
+    "  cadence tickets attach <ticket-id> --from-intake <intake-id> --if-version <version> [--project <project-id>] [--json]",
+    "  cadence tickets create --title <text> [--from-intake <intake-id>] [--project <project-id>] [--json]",
+    "  cadence tickets update <ticket-id> --if-version <version> [--title <text>] [--description <text>] [--priority <priority>] [--status <status>] [--project <project-id>] [--json]",
+    "  cadence tickets claim <ticket-id> --session <session-id> [--project <project-id>] [--json]",
+    "  cadence tickets release <ticket-id> --lease <lease-id> [--project <project-id>] [--json]",
+    "  cadence tickets complete <ticket-id> --if-version <version> [--summary <summary>] [--project <project-id>] [--json]",
+    "  cadence sessions start --ticket <ticket-id> [--changeset <changeset-id>] [--project <project-id>] [--json]",
+    "  cadence sessions end <session-id> --summary <summary> [--project <project-id>] [--json]",
+    "  cadence changesets create --ticket <ticket-id> --branch <branch> [--base-branch <branch>] [--project <project-id>] [--json]",
+    "  cadence intake dismiss <intake-id> --reason <reason> [--project <project-id>] [--json]",
+    "  cadence sessions current [--project <project-id>] [--ticket <ticket-id>] [--changeset <changeset-id>] [--json]",
+    "  cadence changesets get <changeset-id> [--project <project-id>] [--json]",
+    "  cadence changesets list [--project <project-id>] [--ticket <ticket-id>] [--status <status>] [--json]",
+    "  cadence events list [--project <project-id>] [--ticket <ticket-id>] [--changeset <changeset-id>] [--session <session-id>] [--json]",
+    "",
+    "Global flags:",
+    "  --project <id>       Cadence project ID",
+    "  --json               Print stable JSON envelope",
+    "",
+    "Auth options:",
+    "  --email <email>       Email for auth login"
+  ].join(`
+`);
+}
+async function createClient(config, options) {
+  if (options.client) {
+    return options.client;
+  }
+  const store = getCredentialStore(options);
+  const credential = await readStoredCredential(store, config.server);
+  return createCadenceClient({
+    baseUrl: config.server,
+    ...credential ? { getAuthToken: async () => (await readStoredCredential(store, config.server))?.accessToken ?? "" } : {},
+    ...options.fetch ? { fetch: options.fetch } : {}
+  });
+}
+function commandMeta(parsed, config) {
+  return {
+    command: parsed.command.name,
+    server: config.server,
+    projectId: config.projectId
+  };
+}
+function requireProjectId(config) {
+  if (!config.projectId) {
+    throw new CliError("CONFIG_ERROR", "Project ID is required. Pass --project or configure .cadence/config.json.");
+  }
+  return config.projectId;
+}
+function requireArg(parsed, index, label) {
+  const value = parsed.args[index];
+  if (!value) {
+    throw new CliError("CLI_USAGE", `${parsed.command.path.join(" ")} requires ${label}.`);
+  }
+  return value;
+}
+function requireOption(parsed, key, label = `--${key}`) {
+  const value = parsed.options[key];
+  if (!value) {
+    throw new CliError("CLI_USAGE", `${parsed.command.path.join(" ")} requires ${label}.`);
+  }
+  return value;
+}
+function parsePositiveInteger(value, flag) {
+  if (!value) {
+    return;
+  }
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit <= 0) {
+    throw new CliError("CLI_USAGE", `${flag} must be a positive integer.`);
+  }
+  return limit;
+}
+function parseRequiredPositiveInteger(value, flag) {
+  const parsed = parsePositiveInteger(value, flag);
+  if (!parsed) {
+    throw new CliError("CLI_USAGE", `${flag} must be a positive integer.`);
+  }
+  return parsed;
+}
+function parseLimit(value) {
+  return parsePositiveInteger(value, "--limit");
+}
+function parseTicketPriority(value) {
+  if (!value) {
+    return;
+  }
+  if (!ticketPriorities.includes(value)) {
+    throw new CliError("CLI_USAGE", "--priority must be one of low, normal, high, urgent.");
+  }
+  return value;
+}
+function parseTicketStatus(value) {
+  if (!value) {
+    return;
+  }
+  if (!ticketStatuses.includes(value)) {
+    throw new CliError("CLI_USAGE", "--status must be one of backlog, ready, in_progress, blocked, review, done, abandoned.");
+  }
+  return value;
+}
+function leaseExpiresAt(ttlSeconds) {
+  return new Date(Date.now() + ttlSeconds * 1000).toISOString();
+}
+function compactOptions(options) {
+  return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
+}
+function commandMetadata() {
+  return {
+    occurredAt: new Date().toISOString(),
+    source: "cli"
+  };
+}
+async function runStatus(parsed, options) {
+  const config = await resolveCliConfig(parsed.flags, options);
+  const store = getCredentialStore(options);
+  const credential = await readStoredCredential(store, config.server);
+  const client = await createClient(config, options);
+  const health = await client.health();
+  const data = {
+    server: config.server,
+    projectId: config.projectId,
+    credentialConfigured: Boolean(credential),
+    authTokenConfigured: Boolean(credential),
+    health,
+    config: {
+      repoConfigPath: config.repoConfigPath,
+      globalConfigPath: config.globalConfigPath
+    }
+  };
+  const meta = commandMeta(parsed, config);
+  if (parsed.flags.json) {
+    return {
+      stdout: formatJson(successEnvelope(data, meta)),
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  return {
+    stdout: `Cadence API ${health.ok ? "ok" : "unavailable"} at ${config.server}
+`,
+    stderr: "",
+    exitCode: 0
+  };
+}
+async function runInit(parsed, options) {
+  const cwd = options.cwd ?? process.cwd();
+  const repoConfigPath = join(cwd, ".cadence", "config.json");
+  const projectId = parsed.flags.project;
+  if (!projectId) {
+    throw new CliError("CLI_USAGE", "init requires --project.");
+  }
+  const updates = {
+    projectId,
+    ...parsed.flags.server ? { server: parsed.flags.server } : {}
+  };
+  await mergeConfigFile(repoConfigPath, updates);
+  const config = await resolveCliConfig(parsed.flags, {
+    ...options,
+    cwd
+  });
+  const data = {
+    repoConfigPath,
+    projectId,
+    ...parsed.flags.server ? { server: parsed.flags.server } : {}
+  };
+  const meta = commandMeta(parsed, config);
+  if (parsed.flags.json) {
+    return {
+      stdout: formatJson(successEnvelope(data, meta)),
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  return {
+    stdout: `Initialized Cadence config at ${repoConfigPath}
+`,
+    stderr: "",
+    exitCode: 0
+  };
+}
+async function runAuthCommand(parsed, options) {
+  const config = await resolveCliConfig(parsed.flags, options);
+  const store = getCredentialStore(options);
+  const meta = commandMeta(parsed, config);
+  let data;
+  switch (parsed.command.name) {
+    case "auth.login":
+      {
+        await requireCredentialStore(store);
+        const client = await createClient(config, options);
+        const credential = await client.auth.login({
+          email: parsed.options.email ?? await readPromptText(options, "Email: "),
+          password: await readPromptSecret(options, "Password: ")
+        });
+        await store.setCredential(config.server, encodeCredential(credential));
+        await mergeConfigFile(config.globalConfigPath, { server: config.server });
+        data = {
+          server: config.server,
+          credentialStored: true,
+          globalConfigPath: config.globalConfigPath
+        };
+      }
+      break;
+    case "auth.status":
+      {
+        const credentialStoreAvailable = await store.isAvailable();
+        const credential = credentialStoreAvailable ? await readStoredCredential(store, config.server) : null;
+        data = {
+          server: config.server,
+          projectId: config.projectId,
+          credentialStoreAvailable,
+          credentialConfigured: Boolean(credential),
+          config: {
+            repoConfigPath: config.repoConfigPath,
+            globalConfigPath: config.globalConfigPath
+          }
+        };
+      }
+      break;
+    case "auth.logout":
+      await requireCredentialStore(store);
+      await store.deleteCredential(config.server);
+      data = {
+        server: config.server,
+        credentialRemoved: true
+      };
+      break;
+    default:
+      throw new CliError("CLI_USAGE", `Unknown command: ${parsed.command.path.join(" ")}`);
+  }
+  if (parsed.flags.json) {
+    return {
+      stdout: formatJson(successEnvelope(data, meta)),
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  return {
+    stdout: `${JSON.stringify(data, null, 2)}
+`,
+    stderr: "",
+    exitCode: 0
+  };
+}
+async function runReadCommand(parsed, options) {
+  const config = await resolveCliConfig(parsed.flags, options);
+  const projectId = requireProjectId(config);
+  const client = await createClient(config, options);
+  const meta = commandMeta(parsed, config);
+  let data;
+  switch (parsed.command.name) {
+    case "events.list":
+      data = await client.events.list({
+        projectId,
+        filters: compactOptions({
+          type: parsed.options.type,
+          ticketId: parsed.options.ticket,
+          changesetId: parsed.options.changeset,
+          sessionId: parsed.options.session,
+          limit: parseLimit(parsed.options.limit)
+        })
+      });
+      break;
+    case "work.overview":
+      data = await client.work.overview({ projectId });
+      break;
+    case "tickets.get":
+      data = await client.tickets.get({
+        projectId,
+        ticketId: requireArg(parsed, 0, "<ticket-id>")
+      });
+      break;
+    case "tickets.list":
+      data = await client.tickets.list({
+        projectId,
+        filters: compactOptions({
+          status: parsed.options.status,
+          limit: parseLimit(parsed.options.limit)
+        })
+      });
+      break;
+    case "sessions.current":
+      data = await client.sessions.current({
+        projectId,
+        filters: compactOptions({
+          ticketId: parsed.options.ticket,
+          changesetId: parsed.options.changeset,
+          sessionId: parsed.options.session,
+          actorId: parsed.options.actor,
+          limit: parseLimit(parsed.options.limit)
+        })
+      });
+      break;
+    case "changesets.get":
+      data = await client.changesets.get({
+        projectId,
+        changesetId: requireArg(parsed, 0, "<changeset-id>")
+      });
+      break;
+    case "changesets.list":
+      data = await client.changesets.list({
+        projectId,
+        filters: compactOptions({
+          ticketId: parsed.options.ticket,
+          branchName: parsed.options.branch,
+          status: parsed.options.status,
+          limit: parseLimit(parsed.options.limit)
+        })
+      });
+      break;
+    default:
+      throw new CliError("CLI_USAGE", `Unknown command: ${parsed.command.path.join(" ")}`);
+  }
+  if (parsed.flags.json) {
+    return {
+      stdout: formatJson(successEnvelope(data, meta)),
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  return {
+    stdout: `${JSON.stringify(data, null, 2)}
+`,
+    stderr: "",
+    exitCode: 0
+  };
+}
+async function runIntakeCommand(parsed, options) {
+  const config = await resolveCliConfig(parsed.flags, options);
+  const projectId = requireProjectId(config);
+  const client = await createClient(config, options);
+  const meta = commandMeta(parsed, config);
+  let data;
+  const ifVersion = () => parseRequiredPositiveInteger(requireOption(parsed, "if-version"), "--if-version");
+  switch (parsed.command.name) {
+    case "intake":
+      data = await client.intake.create({
+        projectId,
+        intake: {
+          request: requireArg(parsed, 0, '"<request>"'),
+          ...commandMetadata()
+        }
+      });
+      break;
+    case "intake.dismiss":
+      data = await client.intake.dismiss({
+        projectId,
+        intakeId: requireArg(parsed, 0, "<intake-id>"),
+        dismissal: {
+          reason: requireOption(parsed, "reason"),
+          ...commandMetadata()
+        }
+      });
+      break;
+    case "tickets.attach":
+      data = await client.tickets.attach({
+        projectId,
+        ticketId: requireArg(parsed, 0, "<ticket-id>"),
+        fromIntakeId: requireOption(parsed, "from-intake"),
+        ifVersion: ifVersion()
+      });
+      break;
+    case "tickets.create":
+      {
+        const priority = parseTicketPriority(parsed.options.priority);
+        data = await client.tickets.create({
+          projectId,
+          ticket: {
+            title: requireOption(parsed, "title"),
+            ...parsed.options["from-intake"] ? { fromIntakeId: parsed.options["from-intake"] } : {},
+            ...parsed.options.description ? { description: parsed.options.description } : {},
+            ...priority ? { priority } : {},
+            ...commandMetadata()
+          }
+        });
+      }
+      break;
+    case "tickets.update":
+      {
+        const ticketId = requireArg(parsed, 0, "<ticket-id>");
+        const priority = parseTicketPriority(parsed.options.priority);
+        const status = parseTicketStatus(parsed.options.status);
+        const hasUpdateFields = Boolean(parsed.options.title) || Boolean(parsed.options.description) || Boolean(priority) || Boolean(parsed.options["current-summary"]);
+        if (status && hasUpdateFields) {
+          throw new CliError("CLI_USAGE", "tickets update cannot combine --status with field updates.");
+        }
+        if (status) {
+          data = await client.tickets.changeStatus({
+            projectId,
+            ticketId,
+            ifVersion: ifVersion(),
+            status: {
+              toStatus: status,
+              ...parsed.options.reason ? { reason: parsed.options.reason } : {},
+              ...commandMetadata()
+            }
+          });
+          break;
+        }
+        if (!hasUpdateFields) {
+          throw new CliError("CLI_USAGE", "tickets update requires at least one update field.");
+        }
+        data = await client.tickets.update({
+          projectId,
+          ticketId,
+          ifVersion: ifVersion(),
+          ticket: {
+            ...parsed.options.title ? { title: parsed.options.title } : {},
+            ...parsed.options.description ? { description: parsed.options.description } : {},
+            ...priority ? { priority } : {},
+            ...parsed.options["current-summary"] ? { currentSummary: parsed.options["current-summary"] } : {},
+            ...commandMetadata()
+          }
+        });
+      }
+      break;
+    case "tickets.claim":
+      data = await client.sessions.leases.create({
+        projectId,
+        lease: {
+          ticketId: requireArg(parsed, 0, "<ticket-id>"),
+          sessionId: requireOption(parsed, "session"),
+          ...parsed.options.changeset ? { changesetId: parsed.options.changeset } : {},
+          expiresAt: leaseExpiresAt(parsePositiveInteger(parsed.options["ttl-seconds"], "--ttl-seconds") ?? defaultLeaseTtlSeconds),
+          ...commandMetadata()
+        }
+      });
+      break;
+    case "tickets.release":
+      requireArg(parsed, 0, "<ticket-id>");
+      data = await client.sessions.leases.release({
+        projectId,
+        leaseId: requireOption(parsed, "lease"),
+        lease: {
+          ...parsed.options.reason ? { reason: parsed.options.reason } : {},
+          ...commandMetadata()
+        }
+      });
+      break;
+    case "tickets.complete":
+      data = await client.tickets.complete({
+        projectId,
+        ticketId: requireArg(parsed, 0, "<ticket-id>"),
+        ifVersion: ifVersion(),
+        completion: {
+          ...parsed.options.summary ? { currentSummary: parsed.options.summary } : {},
+          ...commandMetadata()
+        }
+      });
+      break;
+    case "sessions.start":
+      data = await client.sessions.start({
+        projectId,
+        session: {
+          ticketId: requireOption(parsed, "ticket"),
+          ...parsed.options.changeset ? { changesetId: parsed.options.changeset } : {},
+          ...parsed.options["local-session-ref"] ? { localSessionRef: parsed.options["local-session-ref"] } : {},
+          ...commandMetadata()
+        }
+      });
+      break;
+    case "sessions.end":
+      data = await client.sessions.end({
+        projectId,
+        sessionId: requireArg(parsed, 0, "<session-id>"),
+        session: {
+          summary: requireOption(parsed, "summary"),
+          ...commandMetadata()
+        }
+      });
+      break;
+    case "changesets.create":
+      data = await client.changesets.create({
+        projectId,
+        changeset: {
+          ticketId: requireOption(parsed, "ticket"),
+          branchName: requireOption(parsed, "branch"),
+          baseBranch: parsed.options["base-branch"] ?? "main",
+          ...parsed.options.session ? { sessionId: parsed.options.session } : {},
+          ...commandMetadata()
+        }
+      });
+      break;
+    default:
+      throw new CliError("CLI_USAGE", `Unknown command: ${parsed.command.path.join(" ")}`);
+  }
+  if (parsed.flags.json) {
+    return {
+      stdout: formatJson(successEnvelope(data, meta)),
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  return {
+    stdout: `${JSON.stringify(data, null, 2)}
+`,
+    stderr: "",
+    exitCode: 0
+  };
+}
+function normalizeError(error) {
+  if (error instanceof CliError) {
+    return error;
+  }
+  if (error.message === "INTAKE_ALREADY_DECIDED" || error.message.includes("INTAKE_ALREADY_DECIDED")) {
+    return new CliError("INTAKE_ALREADY_DECIDED", "INTAKE_ALREADY_DECIDED");
+  }
+  return new CliError("API_ERROR", error.message || "Unexpected CLI error.");
+}
+function commandNameFromArgv(argv) {
+  try {
+    return parseCliArgs(argv).command.name;
+  } catch {
+    return argv.filter((arg) => !arg.startsWith("--"))[0] ?? "unknown";
+  }
+}
+async function runCli(argv, options = {}) {
+  const wantsJson = argv.includes("--json");
+  try {
+    const parsed = parseCliArgs(argv);
+    const meta = {
+      command: parsed.command.name
+    };
+    if (parsed.flags.help || parsed.command.name === "help") {
+      if (parsed.flags.json) {
+        return {
+          stdout: formatJson(successEnvelope({ help: helpText() }, meta)),
+          stderr: "",
+          exitCode: 0
+        };
+      }
+      return {
+        stdout: `${helpText()}
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    if (parsed.command.name === "status") {
+      return await runStatus(parsed, options);
+    }
+    if (parsed.command.name === "init") {
+      return await runInit(parsed, options);
+    }
+    if (parsed.command.name === "auth.login" || parsed.command.name === "auth.status" || parsed.command.name === "auth.logout") {
+      return await runAuthCommand(parsed, options);
+    }
+    if (parsed.command.name === "events.list" || parsed.command.name === "work.overview" || parsed.command.name === "tickets.get" || parsed.command.name === "tickets.list" || parsed.command.name === "sessions.current" || parsed.command.name === "changesets.get" || parsed.command.name === "changesets.list") {
+      return await runReadCommand(parsed, options);
+    }
+    if (parsed.command.name === "intake" || parsed.command.name === "intake.dismiss" || parsed.command.name === "tickets.attach" || parsed.command.name === "tickets.create" || parsed.command.name === "tickets.update" || parsed.command.name === "tickets.claim" || parsed.command.name === "tickets.release" || parsed.command.name === "tickets.complete" || parsed.command.name === "sessions.start" || parsed.command.name === "sessions.end" || parsed.command.name === "changesets.create") {
+      return await runIntakeCommand(parsed, options);
+    }
+    throw new CliError("CLI_USAGE", `Unknown command: ${parsed.command.path.join(" ")}`);
+  } catch (error) {
+    const normalized = error instanceof Error ? normalizeError(error) : new CliError("API_ERROR", "Unexpected CLI error.");
+    const meta = {
+      command: commandNameFromArgv(argv)
+    };
+    if (wantsJson) {
+      return {
+        stdout: formatJson(errorEnvelope(normalized, meta)),
+        stderr: "",
+        exitCode: 1
+      };
+    }
+    return {
+      stdout: "",
+      stderr: `${normalized.message}
+`,
+      exitCode: 1
+    };
+  }
+}
+if (import.meta.main) {
+  const result = await runCli(Bun.argv.slice(2));
+  if (result.stdout) {
+    process.stdout.write(result.stdout);
+  }
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+  process.exit(result.exitCode);
+}
+export {
+  runCli,
+  resolveCliConfig,
+  parseCliArgs
+};