yourskills 0.1.0 → 0.1.2

package/dist/main.js

@@ -13,7 +13,7 @@ import { chmodSync, mkdirSync, rmSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-var DEFAULT_URL = "http://localhost:3000";
+var DEFAULT_URL = "https://api.yourskills.store";
 function configDir() {
   const xdg = process.env.XDG_CONFIG_HOME;
   return join(xdg && xdg.length > 0 ? xdg : join(homedir(), ".config"), "yourskills");
@@ -2069,8 +2069,1395 @@ import { mkdirSync as mkdirSync3 } from "node:fs";
 import { appendFile, readFile as readFile3, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join7 } from "node:path";
 
+// ../../node_modules/.bun/@trpc+client@11.18.0+acc6907a906fa511/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.18.0+7524df1edfed9f02/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((resolve3, 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;
+        resolve3(data);
+        onDone();
+      },
+      error(data) {
+        reject(data);
+      },
+      complete() {
+        ac.abort();
+        onDone();
+      }
+    });
+  });
+  return promise;
+}
+
+// ../../node_modules/.bun/@trpc+server@11.18.0+7524df1edfed9f02/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.18.0+acc6907a906fa511/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.18.0+7524df1edfed9f02/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.18.0+7524df1edfed9f02/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.18.0+7524df1edfed9f02/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.18.0+acc6907a906fa511/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.18.0+acc6907a906fa511/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.18.0+acc6907a906fa511/node_modules/@trpc/client/dist/httpUtils-BNq9QC3d.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());
+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.18.0+acc6907a906fa511/node_modules/@trpc/client/dist/httpLink-oiU8eqFi.mjs
+var import_objectSpread25 = __toESM(require_objectSpread2(), 1);
+
+// ../../node_modules/.bun/@trpc+client@11.18.0+acc6907a906fa511/node_modules/@trpc/client/dist/httpBatchLink-CaWjh1oW.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((resolve3, reject) => {
+      var _pendingItems;
+      item.reject = reject;
+      item.resolve = resolve3;
+      (_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.18.0+acc6907a906fa511/node_modules/@trpc/client/dist/loggerLink-ineCN1PO.mjs
+var import_objectSpread27 = __toESM(require_objectSpread2(), 1);
+
+// ../../node_modules/.bun/@trpc+client@11.18.0+acc6907a906fa511/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 resolve3;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve3 = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve: resolve3,
+    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: resolve3, reject } = withResolvers();
+  ws.addEventListener("open", () => {
+    ws.removeEventListener("error", reject);
+    resolve3();
+  });
+  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.18.0+acc6907a906fa511/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);
+
 // src/client.ts
-import { createTRPCClient, httpBatchLink } from "@trpc/client";
 async function createClient(server) {
   const { token, base } = await requireToken(server);
   return createTRPCClient({
@@ -2855,6 +4242,7 @@ function updateCheckDue(last, now = Date.now()) {
   return Number.isNaN(at) || now - at >= DAY_MS;
 }
 async function sessionStart() {
+  await flushQuietly();
   const config = await readConfig();
   if (!updateCheckDue(config.lastUpdateCheck))
     return;
@@ -2868,8 +4256,6 @@ async function sessionStart() {
       console.log(`yourskills: ${moved} skill(s) behind your registry — run \`yourskills update\``);
     }
   }
-  if (await trackingEnabled())
-    await flush(client);
 }
 async function runHook(event) {
   try {
@@ -3449,7 +4835,7 @@ Options:
   -h, --help              Show this help
 
 Environment:
-  YOURSKILLS_URL          Registry base URL (default localhost:3000)
+  YOURSKILLS_URL          Registry base URL (default api.yourskills.store)
   YOURSKILLS_NO_TRACK     Set to 1 to disable usage counting outright`;
 function configCommand(rest) {
   const [action, key, ...value] = rest;
@@ -3622,12 +5008,11 @@ function parseArgv(args, interactive = true) {
 }
 
 // src/client.ts
-import { createTRPCClient as createTRPCClient2, httpBatchLink as httpBatchLink2 } from "@trpc/client";
 async function createClient2(server) {
   const { token, base } = await requireToken(server);
-  return createTRPCClient2({
+  return createTRPCClient({
     links: [
-      httpBatchLink2({
+      httpBatchLink({
         url: `${base.replace(/\/$/, "")}/trpc`,
         headers: () => ({ authorization: `Bearer ${token}` })
       })
@@ -3861,14 +5246,12 @@ function HelpScreen({ text }) {
 // package.json
 var package_default = {
   name: "yourskills",
-  version: "0.1.0",
+  version: "0.1.2",
   description: "Browse, install and keep up to date the agent skills and bundles your team publishes on yourskills.",
-  license: "MIT",
-  homepage: "https://github.com/xiduzo/yourskills/tree/main/apps/cli#readme",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/xiduzo/yourskills.git",
-    directory: "apps/cli"
+  license: "UNLICENSED",
+  homepage: "https://yourskills.store",
+  bugs: {
+    url: "https://yourskills.store"
   },
   keywords: [
     "agent-skills",
@@ -3900,8 +5283,6 @@ var package_default = {
     prepublishOnly: "bun run build"
   },
   dependencies: {
-    "@trpc/client": "^11.18.0",
-    "@trpc/server": "^11.18.0",
     ink: "^7.1.1",
     react: "^19.2.8",
     skills: "^1.5.25"