@hyperauth/vue 0.1.0

package/dist/index.js

@@ -0,0 +1,4248 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/provider.ts
+import { reactive } from "vue";
+import { createClient } from "@hyperauth/client";
+
+// src/injection-key.ts
+var HyperAuthKey = Symbol("hyperauth");
+
+// src/store.ts
+var initialState = {
+  client: null,
+  status: "initializing",
+  error: null,
+  user: null,
+  authStatus: "unauthenticated",
+  session: null,
+  provider: "unknown",
+  policy: null,
+  chain: "base",
+  pendingTransaction: {
+    phase: "idle",
+    error: null,
+    result: null,
+    userOp: null
+  },
+  settlement: {
+    phase: "idle",
+    steps: [],
+    params: null,
+    txHash: null,
+    error: null
+  },
+  accountState: null,
+  restartAttempts: 0
+};
+function createStore(seed = {}) {
+  let state = { ...initialState, ...seed };
+  const listeners = new Set;
+  return {
+    getState: () => state,
+    setState: (patch) => {
+      const next = typeof patch === "function" ? patch(state) : patch;
+      state = { ...state, ...next };
+      listeners.forEach((l) => l());
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+// src/env.ts
+var isBrowser = () => typeof window !== "undefined" && typeof navigator !== "undefined";
+var hasWebAuthn = () => isBrowser() && typeof window.PublicKeyCredential !== "undefined";
+function getOrigin() {
+  if (!isBrowser())
+    return null;
+  return window.location.origin;
+}
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/is.js
+var objectTypeNames = [
+  "Object",
+  "RegExp",
+  "Date",
+  "Error",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "DataView",
+  "Promise",
+  "URL",
+  "HTMLElement",
+  "Int8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "Tagged"
+];
+function is(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === undefined) {
+    return "undefined";
+  }
+  if (value === true || value === false) {
+    return "boolean";
+  }
+  const typeOf = typeof value;
+  if (typeOf === "string" || typeOf === "number" || typeOf === "bigint" || typeOf === "symbol") {
+    return typeOf;
+  }
+  if (typeOf === "function") {
+    return "Function";
+  }
+  if (Array.isArray(value)) {
+    return "Array";
+  }
+  if (value instanceof Uint8Array) {
+    return "Uint8Array";
+  }
+  if (value.constructor === Object) {
+    return "Object";
+  }
+  const objectType = getObjectType(value);
+  if (objectType) {
+    return objectType;
+  }
+  return "Object";
+}
+function getObjectType(value) {
+  const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
+  if (objectTypeNames.includes(objectTypeName)) {
+    return objectTypeName;
+  }
+  return;
+}
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/token.js
+class Type {
+  constructor(major, name, terminal) {
+    this.major = major;
+    this.majorEncoded = major << 5;
+    this.name = name;
+    this.terminal = terminal;
+  }
+  toString() {
+    return `Type[${this.major}].${this.name}`;
+  }
+  compare(typ) {
+    return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
+  }
+  static equals(a, b) {
+    return a === b || a.major === b.major && a.name === b.name;
+  }
+}
+Type.uint = new Type(0, "uint", true);
+Type.negint = new Type(1, "negint", true);
+Type.bytes = new Type(2, "bytes", true);
+Type.string = new Type(3, "string", true);
+Type.array = new Type(4, "array", false);
+Type.map = new Type(5, "map", false);
+Type.tag = new Type(6, "tag", false);
+Type.float = new Type(7, "float", true);
+Type.false = new Type(7, "false", true);
+Type.true = new Type(7, "true", true);
+Type.null = new Type(7, "null", true);
+Type.undefined = new Type(7, "undefined", true);
+Type.break = new Type(7, "break", true);
+
+class Token {
+  constructor(type, value, encodedLength) {
+    this.type = type;
+    this.value = value;
+    this.encodedLength = encodedLength;
+    this.encodedBytes = undefined;
+    this.byteValue = undefined;
+  }
+  toString() {
+    return `Token[${this.type}].${this.value}`;
+  }
+}
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/byte-utils.js
+var useBuffer = globalThis.process && !globalThis.process.browser && globalThis.Buffer && typeof globalThis.Buffer.isBuffer === "function";
+var textEncoder = new TextEncoder;
+function isBuffer(buf) {
+  return useBuffer && globalThis.Buffer.isBuffer(buf);
+}
+function asU8A(buf) {
+  if (!(buf instanceof Uint8Array)) {
+    return Uint8Array.from(buf);
+  }
+  return isBuffer(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf;
+}
+var FROM_STRING_THRESHOLD_BUFFER = 24;
+var FROM_STRING_THRESHOLD_TEXTENCODER = 200;
+var fromString = useBuffer ? (string) => {
+  return string.length >= FROM_STRING_THRESHOLD_BUFFER ? globalThis.Buffer.from(string) : utf8ToBytes(string);
+} : (string) => {
+  return string.length >= FROM_STRING_THRESHOLD_TEXTENCODER ? textEncoder.encode(string) : utf8ToBytes(string);
+};
+var fromArray = (arr) => {
+  return Uint8Array.from(arr);
+};
+var slice = useBuffer ? (bytes, start, end) => {
+  if (isBuffer(bytes)) {
+    return new Uint8Array(bytes.subarray(start, end));
+  }
+  return bytes.slice(start, end);
+} : (bytes, start, end) => {
+  return bytes.slice(start, end);
+};
+var concat = useBuffer ? (chunks, length) => {
+  chunks = chunks.map((c) => c instanceof Uint8Array ? c : globalThis.Buffer.from(c));
+  return asU8A(globalThis.Buffer.concat(chunks, length));
+} : (chunks, length) => {
+  const out = new Uint8Array(length);
+  let off = 0;
+  for (let b of chunks) {
+    if (off + b.length > out.length) {
+      b = b.subarray(0, out.length - off);
+    }
+    out.set(b, off);
+    off += b.length;
+  }
+  return out;
+};
+var alloc = useBuffer ? (size) => {
+  return globalThis.Buffer.allocUnsafe(size);
+} : (size) => {
+  return new Uint8Array(size);
+};
+function compare(b1, b2) {
+  if (isBuffer(b1) && isBuffer(b2)) {
+    return b1.compare(b2);
+  }
+  for (let i = 0;i < b1.length; i++) {
+    if (b1[i] === b2[i]) {
+      continue;
+    }
+    return b1[i] < b2[i] ? -1 : 1;
+  }
+  return 0;
+}
+function utf8ToBytes(str) {
+  const out = [];
+  let p = 0;
+  for (let i = 0;i < str.length; i++) {
+    let c = str.charCodeAt(i);
+    if (c < 128) {
+      out[p++] = c;
+    } else if (c < 2048) {
+      out[p++] = c >> 6 | 192;
+      out[p++] = c & 63 | 128;
+    } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
+      c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
+      out[p++] = c >> 18 | 240;
+      out[p++] = c >> 12 & 63 | 128;
+      out[p++] = c >> 6 & 63 | 128;
+      out[p++] = c & 63 | 128;
+    } else {
+      if (c >= 55296 && c <= 57343) {
+        c = 65533;
+      }
+      out[p++] = c >> 12 | 224;
+      out[p++] = c >> 6 & 63 | 128;
+      out[p++] = c & 63 | 128;
+    }
+  }
+  return out;
+}
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/bl.js
+var defaultChunkSize = 256;
+
+class Bl {
+  constructor(chunkSize = defaultChunkSize) {
+    this.chunkSize = chunkSize;
+    this.cursor = 0;
+    this.maxCursor = -1;
+    this.chunks = [];
+    this._initReuseChunk = null;
+  }
+  reset() {
+    this.cursor = 0;
+    this.maxCursor = -1;
+    if (this.chunks.length) {
+      this.chunks = [];
+    }
+    if (this._initReuseChunk !== null) {
+      this.chunks.push(this._initReuseChunk);
+      this.maxCursor = this._initReuseChunk.length - 1;
+    }
+  }
+  push(bytes) {
+    let topChunk = this.chunks[this.chunks.length - 1];
+    const newMax = this.cursor + bytes.length;
+    if (newMax <= this.maxCursor + 1) {
+      const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
+      topChunk.set(bytes, chunkPos);
+    } else {
+      if (topChunk) {
+        const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
+        if (chunkPos < topChunk.length) {
+          this.chunks[this.chunks.length - 1] = topChunk.subarray(0, chunkPos);
+          this.maxCursor = this.cursor - 1;
+        }
+      }
+      if (bytes.length < 64 && bytes.length < this.chunkSize) {
+        topChunk = alloc(this.chunkSize);
+        this.chunks.push(topChunk);
+        this.maxCursor += topChunk.length;
+        if (this._initReuseChunk === null) {
+          this._initReuseChunk = topChunk;
+        }
+        topChunk.set(bytes, 0);
+      } else {
+        this.chunks.push(bytes);
+        this.maxCursor += bytes.length;
+      }
+    }
+    this.cursor += bytes.length;
+  }
+  toBytes(reset = false) {
+    let byts;
+    if (this.chunks.length === 1) {
+      const chunk = this.chunks[0];
+      if (reset && this.cursor > chunk.length / 2) {
+        byts = this.cursor === chunk.length ? chunk : chunk.subarray(0, this.cursor);
+        this._initReuseChunk = null;
+        this.chunks = [];
+      } else {
+        byts = slice(chunk, 0, this.cursor);
+      }
+    } else {
+      byts = concat(this.chunks, this.cursor);
+    }
+    if (reset) {
+      this.reset();
+    }
+    return byts;
+  }
+}
+
+class U8Bl {
+  constructor(dest) {
+    this.dest = dest;
+    this.cursor = 0;
+    this.chunks = [dest];
+  }
+  reset() {
+    this.cursor = 0;
+  }
+  push(bytes) {
+    if (this.cursor + bytes.length > this.dest.length) {
+      throw new Error("write out of bounds, destination buffer is too small");
+    }
+    this.dest.set(bytes, this.cursor);
+    this.cursor += bytes.length;
+  }
+  toBytes(reset = false) {
+    const byts = this.dest.subarray(0, this.cursor);
+    if (reset) {
+      this.reset();
+    }
+    return byts;
+  }
+}
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/common.js
+var decodeErrPrefix = "CBOR decode error:";
+var encodeErrPrefix = "CBOR encode error:";
+var uintMinorPrefixBytes = [];
+uintMinorPrefixBytes[23] = 1;
+uintMinorPrefixBytes[24] = 2;
+uintMinorPrefixBytes[25] = 3;
+uintMinorPrefixBytes[26] = 5;
+uintMinorPrefixBytes[27] = 9;
+function assertEnoughData(data, pos, need) {
+  if (data.length - pos < need) {
+    throw new Error(`${decodeErrPrefix} not enough data for type`);
+  }
+}
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/0uint.js
+var uintBoundaries = [24, 256, 65536, 4294967296, BigInt("18446744073709551616")];
+function readUint8(data, offset, options) {
+  assertEnoughData(data, offset, 1);
+  const value = data[offset];
+  if (options.strict === true && value < uintBoundaries[0]) {
+    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
+  }
+  return value;
+}
+function readUint16(data, offset, options) {
+  assertEnoughData(data, offset, 2);
+  const value = data[offset] << 8 | data[offset + 1];
+  if (options.strict === true && value < uintBoundaries[1]) {
+    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
+  }
+  return value;
+}
+function readUint32(data, offset, options) {
+  assertEnoughData(data, offset, 4);
+  const value = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
+  if (options.strict === true && value < uintBoundaries[2]) {
+    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
+  }
+  return value;
+}
+function readUint64(data, offset, options) {
+  assertEnoughData(data, offset, 8);
+  const hi = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
+  const lo = data[offset + 4] * 16777216 + (data[offset + 5] << 16) + (data[offset + 6] << 8) + data[offset + 7];
+  const value = (BigInt(hi) << BigInt(32)) + BigInt(lo);
+  if (options.strict === true && value < uintBoundaries[3]) {
+    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
+  }
+  if (value <= Number.MAX_SAFE_INTEGER) {
+    return Number(value);
+  }
+  if (options.allowBigInt === true) {
+    return value;
+  }
+  throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
+}
+function decodeUint8(data, pos, _minor, options) {
+  return new Token(Type.uint, readUint8(data, pos + 1, options), 2);
+}
+function decodeUint16(data, pos, _minor, options) {
+  return new Token(Type.uint, readUint16(data, pos + 1, options), 3);
+}
+function decodeUint32(data, pos, _minor, options) {
+  return new Token(Type.uint, readUint32(data, pos + 1, options), 5);
+}
+function decodeUint64(data, pos, _minor, options) {
+  return new Token(Type.uint, readUint64(data, pos + 1, options), 9);
+}
+function encodeUint(writer, token) {
+  return encodeUintValue(writer, 0, token.value);
+}
+function encodeUintValue(writer, major, uint) {
+  if (uint < uintBoundaries[0]) {
+    const nuint = Number(uint);
+    writer.push([major | nuint]);
+  } else if (uint < uintBoundaries[1]) {
+    const nuint = Number(uint);
+    writer.push([major | 24, nuint]);
+  } else if (uint < uintBoundaries[2]) {
+    const nuint = Number(uint);
+    writer.push([major | 25, nuint >>> 8, nuint & 255]);
+  } else if (uint < uintBoundaries[3]) {
+    const nuint = Number(uint);
+    writer.push([major | 26, nuint >>> 24 & 255, nuint >>> 16 & 255, nuint >>> 8 & 255, nuint & 255]);
+  } else {
+    const buint = BigInt(uint);
+    if (buint < uintBoundaries[4]) {
+      const set = [major | 27, 0, 0, 0, 0, 0, 0, 0];
+      let lo = Number(buint & BigInt(4294967295));
+      let hi = Number(buint >> BigInt(32) & BigInt(4294967295));
+      set[8] = lo & 255;
+      lo = lo >> 8;
+      set[7] = lo & 255;
+      lo = lo >> 8;
+      set[6] = lo & 255;
+      lo = lo >> 8;
+      set[5] = lo & 255;
+      set[4] = hi & 255;
+      hi = hi >> 8;
+      set[3] = hi & 255;
+      hi = hi >> 8;
+      set[2] = hi & 255;
+      hi = hi >> 8;
+      set[1] = hi & 255;
+      writer.push(set);
+    } else {
+      throw new Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`);
+    }
+  }
+}
+encodeUint.encodedSize = function encodedSize(token) {
+  return encodeUintValue.encodedSize(token.value);
+};
+encodeUintValue.encodedSize = function encodedSize2(uint) {
+  if (uint < uintBoundaries[0]) {
+    return 1;
+  }
+  if (uint < uintBoundaries[1]) {
+    return 2;
+  }
+  if (uint < uintBoundaries[2]) {
+    return 3;
+  }
+  if (uint < uintBoundaries[3]) {
+    return 5;
+  }
+  return 9;
+};
+encodeUint.compareTokens = function compareTokens(tok1, tok2) {
+  return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : 0;
+};
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/1negint.js
+function decodeNegint8(data, pos, _minor, options) {
+  return new Token(Type.negint, -1 - readUint8(data, pos + 1, options), 2);
+}
+function decodeNegint16(data, pos, _minor, options) {
+  return new Token(Type.negint, -1 - readUint16(data, pos + 1, options), 3);
+}
+function decodeNegint32(data, pos, _minor, options) {
+  return new Token(Type.negint, -1 - readUint32(data, pos + 1, options), 5);
+}
+var neg1b = BigInt(-1);
+var pos1b = BigInt(1);
+function decodeNegint64(data, pos, _minor, options) {
+  const int = readUint64(data, pos + 1, options);
+  if (typeof int !== "bigint") {
+    const value = -1 - int;
+    if (value >= Number.MIN_SAFE_INTEGER) {
+      return new Token(Type.negint, value, 9);
+    }
+  }
+  if (options.allowBigInt !== true) {
+    throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
+  }
+  return new Token(Type.negint, neg1b - BigInt(int), 9);
+}
+function encodeNegint(writer, token) {
+  const negint = token.value;
+  const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
+  encodeUintValue(writer, token.type.majorEncoded, unsigned);
+}
+encodeNegint.encodedSize = function encodedSize3(token) {
+  const negint = token.value;
+  const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
+  if (unsigned < uintBoundaries[0]) {
+    return 1;
+  }
+  if (unsigned < uintBoundaries[1]) {
+    return 2;
+  }
+  if (unsigned < uintBoundaries[2]) {
+    return 3;
+  }
+  if (unsigned < uintBoundaries[3]) {
+    return 5;
+  }
+  return 9;
+};
+encodeNegint.compareTokens = function compareTokens2(tok1, tok2) {
+  return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : 0;
+};
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/2bytes.js
+function toToken(data, pos, prefix, length) {
+  assertEnoughData(data, pos, prefix + length);
+  const buf = data.slice(pos + prefix, pos + prefix + length);
+  return new Token(Type.bytes, buf, prefix + length);
+}
+function decodeBytesCompact(data, pos, minor, _options) {
+  return toToken(data, pos, 1, minor);
+}
+function decodeBytes8(data, pos, _minor, options) {
+  return toToken(data, pos, 2, readUint8(data, pos + 1, options));
+}
+function decodeBytes16(data, pos, _minor, options) {
+  return toToken(data, pos, 3, readUint16(data, pos + 1, options));
+}
+function decodeBytes32(data, pos, _minor, options) {
+  return toToken(data, pos, 5, readUint32(data, pos + 1, options));
+}
+function decodeBytes64(data, pos, _minor, options) {
+  const l = readUint64(data, pos + 1, options);
+  if (typeof l === "bigint") {
+    throw new Error(`${decodeErrPrefix} 64-bit integer bytes lengths not supported`);
+  }
+  return toToken(data, pos, 9, l);
+}
+function tokenBytes(token) {
+  if (token.encodedBytes === undefined) {
+    token.encodedBytes = Type.equals(token.type, Type.string) ? fromString(token.value) : token.value;
+  }
+  return token.encodedBytes;
+}
+function encodeBytes(writer, token) {
+  const bytes = tokenBytes(token);
+  encodeUintValue(writer, token.type.majorEncoded, bytes.length);
+  writer.push(bytes);
+}
+encodeBytes.encodedSize = function encodedSize4(token) {
+  const bytes = tokenBytes(token);
+  return encodeUintValue.encodedSize(bytes.length) + bytes.length;
+};
+encodeBytes.compareTokens = function compareTokens3(tok1, tok2) {
+  return compareBytes(tokenBytes(tok1), tokenBytes(tok2));
+};
+function compareBytes(b1, b2) {
+  return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare(b1, b2);
+}
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/3string.js
+var textDecoder = new TextDecoder;
+var ASCII_THRESHOLD = 32;
+function toStr(bytes, start, end) {
+  const len = end - start;
+  if (len < ASCII_THRESHOLD) {
+    let str = "";
+    for (let i = start;i < end; i++) {
+      const c = bytes[i];
+      if (c & 128) {
+        return textDecoder.decode(bytes.subarray(start, end));
+      }
+      str += String.fromCharCode(c);
+    }
+    return str;
+  }
+  return textDecoder.decode(bytes.subarray(start, end));
+}
+function toToken2(data, pos, prefix, length, options) {
+  const totLength = prefix + length;
+  assertEnoughData(data, pos, totLength);
+  const tok = new Token(Type.string, toStr(data, pos + prefix, pos + totLength), totLength);
+  if (options.retainStringBytes === true) {
+    tok.byteValue = data.slice(pos + prefix, pos + totLength);
+  }
+  return tok;
+}
+function decodeStringCompact(data, pos, minor, options) {
+  return toToken2(data, pos, 1, minor, options);
+}
+function decodeString8(data, pos, _minor, options) {
+  return toToken2(data, pos, 2, readUint8(data, pos + 1, options), options);
+}
+function decodeString16(data, pos, _minor, options) {
+  return toToken2(data, pos, 3, readUint16(data, pos + 1, options), options);
+}
+function decodeString32(data, pos, _minor, options) {
+  return toToken2(data, pos, 5, readUint32(data, pos + 1, options), options);
+}
+function decodeString64(data, pos, _minor, options) {
+  const l = readUint64(data, pos + 1, options);
+  if (typeof l === "bigint") {
+    throw new Error(`${decodeErrPrefix} 64-bit integer string lengths not supported`);
+  }
+  return toToken2(data, pos, 9, l, options);
+}
+var encodeString = encodeBytes;
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/4array.js
+function toToken3(_data, _pos, prefix, length) {
+  return new Token(Type.array, length, prefix);
+}
+function decodeArrayCompact(data, pos, minor, _options) {
+  return toToken3(data, pos, 1, minor);
+}
+function decodeArray8(data, pos, _minor, options) {
+  return toToken3(data, pos, 2, readUint8(data, pos + 1, options));
+}
+function decodeArray16(data, pos, _minor, options) {
+  return toToken3(data, pos, 3, readUint16(data, pos + 1, options));
+}
+function decodeArray32(data, pos, _minor, options) {
+  return toToken3(data, pos, 5, readUint32(data, pos + 1, options));
+}
+function decodeArray64(data, pos, _minor, options) {
+  const l = readUint64(data, pos + 1, options);
+  if (typeof l === "bigint") {
+    throw new Error(`${decodeErrPrefix} 64-bit integer array lengths not supported`);
+  }
+  return toToken3(data, pos, 9, l);
+}
+function decodeArrayIndefinite(data, pos, _minor, options) {
+  if (options.allowIndefinite === false) {
+    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
+  }
+  return toToken3(data, pos, 1, Infinity);
+}
+function encodeArray(writer, token) {
+  encodeUintValue(writer, Type.array.majorEncoded, token.value);
+}
+encodeArray.compareTokens = encodeUint.compareTokens;
+encodeArray.encodedSize = function encodedSize5(token) {
+  return encodeUintValue.encodedSize(token.value);
+};
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/5map.js
+function toToken4(_data, _pos, prefix, length) {
+  return new Token(Type.map, length, prefix);
+}
+function decodeMapCompact(data, pos, minor, _options) {
+  return toToken4(data, pos, 1, minor);
+}
+function decodeMap8(data, pos, _minor, options) {
+  return toToken4(data, pos, 2, readUint8(data, pos + 1, options));
+}
+function decodeMap16(data, pos, _minor, options) {
+  return toToken4(data, pos, 3, readUint16(data, pos + 1, options));
+}
+function decodeMap32(data, pos, _minor, options) {
+  return toToken4(data, pos, 5, readUint32(data, pos + 1, options));
+}
+function decodeMap64(data, pos, _minor, options) {
+  const l = readUint64(data, pos + 1, options);
+  if (typeof l === "bigint") {
+    throw new Error(`${decodeErrPrefix} 64-bit integer map lengths not supported`);
+  }
+  return toToken4(data, pos, 9, l);
+}
+function decodeMapIndefinite(data, pos, _minor, options) {
+  if (options.allowIndefinite === false) {
+    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
+  }
+  return toToken4(data, pos, 1, Infinity);
+}
+function encodeMap(writer, token) {
+  encodeUintValue(writer, Type.map.majorEncoded, token.value);
+}
+encodeMap.compareTokens = encodeUint.compareTokens;
+encodeMap.encodedSize = function encodedSize6(token) {
+  return encodeUintValue.encodedSize(token.value);
+};
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/6tag.js
+function decodeTagCompact(_data, _pos, minor, _options) {
+  return new Token(Type.tag, minor, 1);
+}
+function decodeTag8(data, pos, _minor, options) {
+  return new Token(Type.tag, readUint8(data, pos + 1, options), 2);
+}
+function decodeTag16(data, pos, _minor, options) {
+  return new Token(Type.tag, readUint16(data, pos + 1, options), 3);
+}
+function decodeTag32(data, pos, _minor, options) {
+  return new Token(Type.tag, readUint32(data, pos + 1, options), 5);
+}
+function decodeTag64(data, pos, _minor, options) {
+  return new Token(Type.tag, readUint64(data, pos + 1, options), 9);
+}
+function encodeTag(writer, token) {
+  encodeUintValue(writer, Type.tag.majorEncoded, token.value);
+}
+encodeTag.compareTokens = encodeUint.compareTokens;
+encodeTag.encodedSize = function encodedSize7(token) {
+  return encodeUintValue.encodedSize(token.value);
+};
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/7float.js
+var MINOR_FALSE = 20;
+var MINOR_TRUE = 21;
+var MINOR_NULL = 22;
+var MINOR_UNDEFINED = 23;
+function decodeUndefined(_data, _pos, _minor, options) {
+  if (options.allowUndefined === false) {
+    throw new Error(`${decodeErrPrefix} undefined values are not supported`);
+  } else if (options.coerceUndefinedToNull === true) {
+    return new Token(Type.null, null, 1);
+  }
+  return new Token(Type.undefined, undefined, 1);
+}
+function decodeBreak(_data, _pos, _minor, options) {
+  if (options.allowIndefinite === false) {
+    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
+  }
+  return new Token(Type.break, undefined, 1);
+}
+function createToken(value, bytes, options) {
+  if (options) {
+    if (options.allowNaN === false && Number.isNaN(value)) {
+      throw new Error(`${decodeErrPrefix} NaN values are not supported`);
+    }
+    if (options.allowInfinity === false && (value === Infinity || value === -Infinity)) {
+      throw new Error(`${decodeErrPrefix} Infinity values are not supported`);
+    }
+  }
+  return new Token(Type.float, value, bytes);
+}
+function decodeFloat16(data, pos, _minor, options) {
+  return createToken(readFloat16(data, pos + 1), 3, options);
+}
+function decodeFloat32(data, pos, _minor, options) {
+  return createToken(readFloat32(data, pos + 1), 5, options);
+}
+function decodeFloat64(data, pos, _minor, options) {
+  return createToken(readFloat64(data, pos + 1), 9, options);
+}
+function encodeFloat(writer, token, options) {
+  const float = token.value;
+  if (float === false) {
+    writer.push([Type.float.majorEncoded | MINOR_FALSE]);
+  } else if (float === true) {
+    writer.push([Type.float.majorEncoded | MINOR_TRUE]);
+  } else if (float === null) {
+    writer.push([Type.float.majorEncoded | MINOR_NULL]);
+  } else if (float === undefined) {
+    writer.push([Type.float.majorEncoded | MINOR_UNDEFINED]);
+  } else {
+    let decoded;
+    let success = false;
+    if (!options || options.float64 !== true) {
+      encodeFloat16(float);
+      decoded = readFloat16(ui8a, 1);
+      if (float === decoded || Number.isNaN(float)) {
+        ui8a[0] = 249;
+        writer.push(ui8a.slice(0, 3));
+        success = true;
+      } else {
+        encodeFloat32(float);
+        decoded = readFloat32(ui8a, 1);
+        if (float === decoded) {
+          ui8a[0] = 250;
+          writer.push(ui8a.slice(0, 5));
+          success = true;
+        }
+      }
+    }
+    if (!success) {
+      encodeFloat64(float);
+      decoded = readFloat64(ui8a, 1);
+      ui8a[0] = 251;
+      writer.push(ui8a.slice(0, 9));
+    }
+  }
+}
+encodeFloat.encodedSize = function encodedSize8(token, options) {
+  const float = token.value;
+  if (float === false || float === true || float === null || float === undefined) {
+    return 1;
+  }
+  if (!options || options.float64 !== true) {
+    encodeFloat16(float);
+    let decoded = readFloat16(ui8a, 1);
+    if (float === decoded || Number.isNaN(float)) {
+      return 3;
+    }
+    encodeFloat32(float);
+    decoded = readFloat32(ui8a, 1);
+    if (float === decoded) {
+      return 5;
+    }
+  }
+  return 9;
+};
+var buffer = new ArrayBuffer(9);
+var dataView = new DataView(buffer, 1);
+var ui8a = new Uint8Array(buffer, 0);
+function encodeFloat16(inp) {
+  if (inp === Infinity) {
+    dataView.setUint16(0, 31744, false);
+  } else if (inp === -Infinity) {
+    dataView.setUint16(0, 64512, false);
+  } else if (Number.isNaN(inp)) {
+    dataView.setUint16(0, 32256, false);
+  } else {
+    dataView.setFloat32(0, inp);
+    const valu32 = dataView.getUint32(0);
+    const exponent = (valu32 & 2139095040) >> 23;
+    const mantissa = valu32 & 8388607;
+    if (exponent === 255) {
+      dataView.setUint16(0, 31744, false);
+    } else if (exponent === 0) {
+      dataView.setUint16(0, (valu32 & 2147483648) >> 16 | mantissa >> 13, false);
+    } else {
+      const logicalExponent = exponent - 127;
+      if (logicalExponent < -24) {
+        dataView.setUint16(0, 0);
+      } else if (logicalExponent < -14) {
+        dataView.setUint16(0, (valu32 & 2147483648) >> 16 | 1 << 24 + logicalExponent, false);
+      } else {
+        dataView.setUint16(0, (valu32 & 2147483648) >> 16 | logicalExponent + 15 << 10 | mantissa >> 13, false);
+      }
+    }
+  }
+}
+function readFloat16(ui8a2, pos) {
+  if (ui8a2.length - pos < 2) {
+    throw new Error(`${decodeErrPrefix} not enough data for float16`);
+  }
+  const half = (ui8a2[pos] << 8) + ui8a2[pos + 1];
+  if (half === 31744) {
+    return Infinity;
+  }
+  if (half === 64512) {
+    return -Infinity;
+  }
+  if (half === 32256) {
+    return NaN;
+  }
+  const exp = half >> 10 & 31;
+  const mant = half & 1023;
+  let val;
+  if (exp === 0) {
+    val = mant * 2 ** -24;
+  } else if (exp !== 31) {
+    val = (mant + 1024) * 2 ** (exp - 25);
+  } else {
+    val = mant === 0 ? Infinity : NaN;
+  }
+  return half & 32768 ? -val : val;
+}
+function encodeFloat32(inp) {
+  dataView.setFloat32(0, inp, false);
+}
+function readFloat32(ui8a2, pos) {
+  if (ui8a2.length - pos < 4) {
+    throw new Error(`${decodeErrPrefix} not enough data for float32`);
+  }
+  const offset = (ui8a2.byteOffset || 0) + pos;
+  return new DataView(ui8a2.buffer, offset, 4).getFloat32(0, false);
+}
+function encodeFloat64(inp) {
+  dataView.setFloat64(0, inp, false);
+}
+function readFloat64(ui8a2, pos) {
+  if (ui8a2.length - pos < 8) {
+    throw new Error(`${decodeErrPrefix} not enough data for float64`);
+  }
+  const offset = (ui8a2.byteOffset || 0) + pos;
+  return new DataView(ui8a2.buffer, offset, 8).getFloat64(0, false);
+}
+encodeFloat.compareTokens = encodeUint.compareTokens;
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/jump.js
+function invalidMinor(data, pos, minor) {
+  throw new Error(`${decodeErrPrefix} encountered invalid minor (${minor}) for major ${data[pos] >>> 5}`);
+}
+function errorer(msg) {
+  return () => {
+    throw new Error(`${decodeErrPrefix} ${msg}`);
+  };
+}
+var jump = [];
+for (let i = 0;i <= 23; i++) {
+  jump[i] = invalidMinor;
+}
+jump[24] = decodeUint8;
+jump[25] = decodeUint16;
+jump[26] = decodeUint32;
+jump[27] = decodeUint64;
+jump[28] = invalidMinor;
+jump[29] = invalidMinor;
+jump[30] = invalidMinor;
+jump[31] = invalidMinor;
+for (let i = 32;i <= 55; i++) {
+  jump[i] = invalidMinor;
+}
+jump[56] = decodeNegint8;
+jump[57] = decodeNegint16;
+jump[58] = decodeNegint32;
+jump[59] = decodeNegint64;
+jump[60] = invalidMinor;
+jump[61] = invalidMinor;
+jump[62] = invalidMinor;
+jump[63] = invalidMinor;
+for (let i = 64;i <= 87; i++) {
+  jump[i] = decodeBytesCompact;
+}
+jump[88] = decodeBytes8;
+jump[89] = decodeBytes16;
+jump[90] = decodeBytes32;
+jump[91] = decodeBytes64;
+jump[92] = invalidMinor;
+jump[93] = invalidMinor;
+jump[94] = invalidMinor;
+jump[95] = errorer("indefinite length bytes/strings are not supported");
+for (let i = 96;i <= 119; i++) {
+  jump[i] = decodeStringCompact;
+}
+jump[120] = decodeString8;
+jump[121] = decodeString16;
+jump[122] = decodeString32;
+jump[123] = decodeString64;
+jump[124] = invalidMinor;
+jump[125] = invalidMinor;
+jump[126] = invalidMinor;
+jump[127] = errorer("indefinite length bytes/strings are not supported");
+for (let i = 128;i <= 151; i++) {
+  jump[i] = decodeArrayCompact;
+}
+jump[152] = decodeArray8;
+jump[153] = decodeArray16;
+jump[154] = decodeArray32;
+jump[155] = decodeArray64;
+jump[156] = invalidMinor;
+jump[157] = invalidMinor;
+jump[158] = invalidMinor;
+jump[159] = decodeArrayIndefinite;
+for (let i = 160;i <= 183; i++) {
+  jump[i] = decodeMapCompact;
+}
+jump[184] = decodeMap8;
+jump[185] = decodeMap16;
+jump[186] = decodeMap32;
+jump[187] = decodeMap64;
+jump[188] = invalidMinor;
+jump[189] = invalidMinor;
+jump[190] = invalidMinor;
+jump[191] = decodeMapIndefinite;
+for (let i = 192;i <= 215; i++) {
+  jump[i] = decodeTagCompact;
+}
+jump[216] = decodeTag8;
+jump[217] = decodeTag16;
+jump[218] = decodeTag32;
+jump[219] = decodeTag64;
+jump[220] = invalidMinor;
+jump[221] = invalidMinor;
+jump[222] = invalidMinor;
+jump[223] = invalidMinor;
+for (let i = 224;i <= 243; i++) {
+  jump[i] = errorer("simple values are not supported");
+}
+jump[244] = invalidMinor;
+jump[245] = invalidMinor;
+jump[246] = invalidMinor;
+jump[247] = decodeUndefined;
+jump[248] = errorer("simple values are not supported");
+jump[249] = decodeFloat16;
+jump[250] = decodeFloat32;
+jump[251] = decodeFloat64;
+jump[252] = invalidMinor;
+jump[253] = invalidMinor;
+jump[254] = invalidMinor;
+jump[255] = decodeBreak;
+var quick = [];
+for (let i = 0;i < 24; i++) {
+  quick[i] = new Token(Type.uint, i, 1);
+}
+for (let i = -1;i >= -24; i--) {
+  quick[31 - i] = new Token(Type.negint, i, 1);
+}
+quick[64] = new Token(Type.bytes, new Uint8Array(0), 1);
+quick[96] = new Token(Type.string, "", 1);
+quick[128] = new Token(Type.array, 0, 1);
+quick[160] = new Token(Type.map, 0, 1);
+quick[244] = new Token(Type.false, false, 1);
+quick[245] = new Token(Type.true, true, 1);
+quick[246] = new Token(Type.null, null, 1);
+function quickEncodeToken(token) {
+  switch (token.type) {
+    case Type.false:
+      return fromArray([244]);
+    case Type.true:
+      return fromArray([245]);
+    case Type.null:
+      return fromArray([246]);
+    case Type.bytes:
+      if (!token.value.length) {
+        return fromArray([64]);
+      }
+      return;
+    case Type.string:
+      if (token.value === "") {
+        return fromArray([96]);
+      }
+      return;
+    case Type.array:
+      if (token.value === 0) {
+        return fromArray([128]);
+      }
+      return;
+    case Type.map:
+      if (token.value === 0) {
+        return fromArray([160]);
+      }
+      return;
+    case Type.uint:
+      if (token.value < 24) {
+        return fromArray([Number(token.value)]);
+      }
+      return;
+    case Type.negint:
+      if (token.value >= -24) {
+        return fromArray([31 - Number(token.value)]);
+      }
+  }
+}
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/encode.js
+var defaultEncodeOptions = {
+  float64: false,
+  mapSorter,
+  quickEncodeToken
+};
+var rfc8949EncodeOptions = Object.freeze({
+  float64: true,
+  mapSorter: rfc8949MapSorter,
+  quickEncodeToken
+});
+function makeCborEncoders() {
+  const encoders = [];
+  encoders[Type.uint.major] = encodeUint;
+  encoders[Type.negint.major] = encodeNegint;
+  encoders[Type.bytes.major] = encodeBytes;
+  encoders[Type.string.major] = encodeString;
+  encoders[Type.array.major] = encodeArray;
+  encoders[Type.map.major] = encodeMap;
+  encoders[Type.tag.major] = encodeTag;
+  encoders[Type.float.major] = encodeFloat;
+  return encoders;
+}
+var cborEncoders = makeCborEncoders();
+var defaultWriter = new Bl;
+
+class Ref {
+  constructor(obj, parent) {
+    this.obj = obj;
+    this.parent = parent;
+  }
+  includes(obj) {
+    let p = this;
+    do {
+      if (p.obj === obj) {
+        return true;
+      }
+    } while (p = p.parent);
+    return false;
+  }
+  static createCheck(stack, obj) {
+    if (stack && stack.includes(obj)) {
+      throw new Error(`${encodeErrPrefix} object contains circular references`);
+    }
+    return new Ref(obj, stack);
+  }
+}
+var simpleTokens = {
+  null: new Token(Type.null, null),
+  undefined: new Token(Type.undefined, undefined),
+  true: new Token(Type.true, true),
+  false: new Token(Type.false, false),
+  emptyArray: new Token(Type.array, 0),
+  emptyMap: new Token(Type.map, 0)
+};
+var typeEncoders = {
+  number(obj, _typ, _options, _refStack) {
+    if (!Number.isInteger(obj) || !Number.isSafeInteger(obj)) {
+      return new Token(Type.float, obj);
+    } else if (obj >= 0) {
+      return new Token(Type.uint, obj);
+    } else {
+      return new Token(Type.negint, obj);
+    }
+  },
+  bigint(obj, _typ, _options, _refStack) {
+    if (obj >= BigInt(0)) {
+      return new Token(Type.uint, obj);
+    } else {
+      return new Token(Type.negint, obj);
+    }
+  },
+  Uint8Array(obj, _typ, _options, _refStack) {
+    return new Token(Type.bytes, obj);
+  },
+  string(obj, _typ, _options, _refStack) {
+    return new Token(Type.string, obj);
+  },
+  boolean(obj, _typ, _options, _refStack) {
+    return obj ? simpleTokens.true : simpleTokens.false;
+  },
+  null(_obj, _typ, _options, _refStack) {
+    return simpleTokens.null;
+  },
+  undefined(_obj, _typ, _options, _refStack) {
+    return simpleTokens.undefined;
+  },
+  ArrayBuffer(obj, _typ, _options, _refStack) {
+    return new Token(Type.bytes, new Uint8Array(obj));
+  },
+  DataView(obj, _typ, _options, _refStack) {
+    return new Token(Type.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength));
+  },
+  Array(obj, _typ, options, refStack) {
+    if (!obj.length) {
+      if (options.addBreakTokens === true) {
+        return [simpleTokens.emptyArray, new Token(Type.break)];
+      }
+      return simpleTokens.emptyArray;
+    }
+    refStack = Ref.createCheck(refStack, obj);
+    const entries = [];
+    let i = 0;
+    for (const e of obj) {
+      entries[i++] = objectToTokens(e, options, refStack);
+    }
+    if (options.addBreakTokens) {
+      return [new Token(Type.array, obj.length), entries, new Token(Type.break)];
+    }
+    return [new Token(Type.array, obj.length), entries];
+  },
+  Object(obj, typ, options, refStack) {
+    const isMap = typ !== "Object";
+    const keys = isMap ? obj.keys() : Object.keys(obj);
+    const maxLength = isMap ? obj.size : keys.length;
+    let entries;
+    if (maxLength) {
+      entries = new Array(maxLength);
+      refStack = Ref.createCheck(refStack, obj);
+      const skipUndefined = !isMap && options.ignoreUndefinedProperties;
+      let i = 0;
+      for (const key of keys) {
+        const value = isMap ? obj.get(key) : obj[key];
+        if (skipUndefined && value === undefined) {
+          continue;
+        }
+        entries[i++] = [
+          objectToTokens(key, options, refStack),
+          objectToTokens(value, options, refStack)
+        ];
+      }
+      if (i < maxLength) {
+        entries.length = i;
+      }
+    }
+    if (!entries?.length) {
+      if (options.addBreakTokens === true) {
+        return [simpleTokens.emptyMap, new Token(Type.break)];
+      }
+      return simpleTokens.emptyMap;
+    }
+    sortMapEntries(entries, options);
+    if (options.addBreakTokens) {
+      return [new Token(Type.map, entries.length), entries, new Token(Type.break)];
+    }
+    return [new Token(Type.map, entries.length), entries];
+  },
+  Tagged(obj, _typ, options, refStack) {
+    return [
+      new Token(Type.tag, obj.tag),
+      objectToTokens(obj.value, options, refStack)
+    ];
+  }
+};
+typeEncoders.Map = typeEncoders.Object;
+typeEncoders.Buffer = typeEncoders.Uint8Array;
+for (const typ of "Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64".split(" ")) {
+  typeEncoders[`${typ}Array`] = typeEncoders.DataView;
+}
+function objectToTokens(obj, options = {}, refStack) {
+  const typ = is(obj);
+  const customTypeEncoder = options && options.typeEncoders && options.typeEncoders[typ] || typeEncoders[typ];
+  if (typeof customTypeEncoder === "function") {
+    const tokens = customTypeEncoder(obj, typ, options, refStack);
+    if (tokens != null) {
+      return tokens;
+    }
+  }
+  const typeEncoder = typeEncoders[typ];
+  if (!typeEncoder) {
+    throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`);
+  }
+  return typeEncoder(obj, typ, options, refStack);
+}
+function sortMapEntries(entries, options) {
+  if (options.mapSorter) {
+    entries.sort(options.mapSorter);
+  }
+}
+function mapSorter(e1, e2) {
+  const keyToken1 = Array.isArray(e1[0]) ? e1[0][0] : e1[0];
+  const keyToken2 = Array.isArray(e2[0]) ? e2[0][0] : e2[0];
+  if (keyToken1.type !== keyToken2.type) {
+    return keyToken1.type.compare(keyToken2.type);
+  }
+  const major = keyToken1.type.major;
+  const tcmp = cborEncoders[major].compareTokens(keyToken1, keyToken2);
+  if (tcmp === 0) {
+    console.warn("WARNING: complex key types used, CBOR key sorting guarantees are gone");
+  }
+  return tcmp;
+}
+function rfc8949MapSorter(e1, e2) {
+  if (e1[0] instanceof Token && e2[0] instanceof Token) {
+    const t1 = e1[0];
+    const t2 = e2[0];
+    if (!t1._keyBytes) {
+      t1._keyBytes = encodeRfc8949(t1.value);
+    }
+    if (!t2._keyBytes) {
+      t2._keyBytes = encodeRfc8949(t2.value);
+    }
+    return compare(t1._keyBytes, t2._keyBytes);
+  }
+  throw new Error("rfc8949MapSorter: complex key types are not supported yet");
+}
+function encodeRfc8949(data) {
+  return encodeCustom(data, cborEncoders, rfc8949EncodeOptions);
+}
+function tokensToEncoded(writer, tokens, encoders, options) {
+  if (Array.isArray(tokens)) {
+    for (const token of tokens) {
+      tokensToEncoded(writer, token, encoders, options);
+    }
+  } else {
+    encoders[tokens.type.major](writer, tokens, options);
+  }
+}
+var MAJOR_UINT = Type.uint.majorEncoded;
+var MAJOR_NEGINT = Type.negint.majorEncoded;
+var MAJOR_BYTES = Type.bytes.majorEncoded;
+var MAJOR_STRING = Type.string.majorEncoded;
+var MAJOR_ARRAY = Type.array.majorEncoded;
+var SIMPLE_FALSE = Type.float.majorEncoded | MINOR_FALSE;
+var SIMPLE_TRUE = Type.float.majorEncoded | MINOR_TRUE;
+var SIMPLE_NULL = Type.float.majorEncoded | MINOR_NULL;
+var SIMPLE_UNDEFINED = Type.float.majorEncoded | MINOR_UNDEFINED;
+var neg1b2 = BigInt(-1);
+var pos1b2 = BigInt(1);
+function canDirectEncode(options) {
+  return options.addBreakTokens !== true;
+}
+function directEncode(writer, data, options, refStack) {
+  const typ = is(data);
+  const customEncoder = options.typeEncoders && options.typeEncoders[typ];
+  if (customEncoder) {
+    const tokens = customEncoder(data, typ, options, refStack);
+    if (tokens != null) {
+      tokensToEncoded(writer, tokens, cborEncoders, options);
+      return;
+    }
+  }
+  switch (typ) {
+    case "null":
+      writer.push([SIMPLE_NULL]);
+      return;
+    case "undefined":
+      writer.push([SIMPLE_UNDEFINED]);
+      return;
+    case "boolean":
+      writer.push([data ? SIMPLE_TRUE : SIMPLE_FALSE]);
+      return;
+    case "number":
+      if (!Number.isInteger(data) || !Number.isSafeInteger(data)) {
+        encodeFloat(writer, new Token(Type.float, data), options);
+      } else if (data >= 0) {
+        encodeUintValue(writer, MAJOR_UINT, data);
+      } else {
+        encodeUintValue(writer, MAJOR_NEGINT, data * -1 - 1);
+      }
+      return;
+    case "bigint":
+      if (data >= BigInt(0)) {
+        encodeUintValue(writer, MAJOR_UINT, data);
+      } else {
+        encodeUintValue(writer, MAJOR_NEGINT, data * neg1b2 - pos1b2);
+      }
+      return;
+    case "string": {
+      const bytes = fromString(data);
+      encodeUintValue(writer, MAJOR_STRING, bytes.length);
+      writer.push(bytes);
+      return;
+    }
+    case "Uint8Array":
+      encodeUintValue(writer, MAJOR_BYTES, data.length);
+      writer.push(data);
+      return;
+    case "Array":
+      if (!data.length) {
+        writer.push([MAJOR_ARRAY]);
+        return;
+      }
+      refStack = Ref.createCheck(refStack, data);
+      encodeUintValue(writer, MAJOR_ARRAY, data.length);
+      for (const elem of data) {
+        directEncode(writer, elem, options, refStack);
+      }
+      return;
+    case "Object":
+    case "Map":
+      {
+        const tokens = typeEncoders.Object(data, typ, options, refStack);
+        tokensToEncoded(writer, tokens, cborEncoders, options);
+      }
+      return;
+    default: {
+      const typeEncoder = typeEncoders[typ];
+      if (!typeEncoder) {
+        throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`);
+      }
+      const tokens = typeEncoder(data, typ, options, refStack);
+      tokensToEncoded(writer, tokens, cborEncoders, options);
+    }
+  }
+}
+function encodeCustom(data, encoders, options, destination) {
+  const hasDest = destination instanceof Uint8Array;
+  let writeTo = hasDest ? new U8Bl(destination) : defaultWriter;
+  const tokens = objectToTokens(data, options);
+  if (!Array.isArray(tokens) && options.quickEncodeToken) {
+    const quickBytes = options.quickEncodeToken(tokens);
+    if (quickBytes) {
+      if (hasDest) {
+        writeTo.push(quickBytes);
+        return writeTo.toBytes();
+      }
+      return quickBytes;
+    }
+    const encoder = encoders[tokens.type.major];
+    if (encoder.encodedSize) {
+      const size = encoder.encodedSize(tokens, options);
+      if (!hasDest) {
+        writeTo = new Bl(size);
+      }
+      encoder(writeTo, tokens, options);
+      if (writeTo.chunks.length !== 1) {
+        throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
+      }
+      return hasDest ? writeTo.toBytes() : asU8A(writeTo.chunks[0]);
+    }
+  }
+  writeTo.reset();
+  tokensToEncoded(writeTo, tokens, encoders, options);
+  return writeTo.toBytes(true);
+}
+function encode(data, options) {
+  options = Object.assign({}, defaultEncodeOptions, options);
+  if (canDirectEncode(options)) {
+    defaultWriter.reset();
+    directEncode(defaultWriter, data, options, undefined);
+    return defaultWriter.toBytes(true);
+  }
+  return encodeCustom(data, cborEncoders, options);
+}
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/decode.js
+var defaultDecodeOptions = {
+  strict: false,
+  allowIndefinite: true,
+  allowUndefined: true,
+  allowBigInt: true
+};
+
+class Tokeniser {
+  constructor(data, options = {}) {
+    this._pos = 0;
+    this.data = data;
+    this.options = options;
+  }
+  pos() {
+    return this._pos;
+  }
+  done() {
+    return this._pos >= this.data.length;
+  }
+  next() {
+    const byt = this.data[this._pos];
+    let token = quick[byt];
+    if (token === undefined) {
+      const decoder = jump[byt];
+      if (!decoder) {
+        throw new Error(`${decodeErrPrefix} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, "0")})`);
+      }
+      const minor = byt & 31;
+      token = decoder(this.data, this._pos, minor, this.options);
+    }
+    this._pos += token.encodedLength;
+    return token;
+  }
+}
+var DONE = Symbol.for("DONE");
+var BREAK = Symbol.for("BREAK");
+function tokenToArray(token, tokeniser, options) {
+  const arr = [];
+  for (let i = 0;i < token.value; i++) {
+    const value = tokensToObject(tokeniser, options);
+    if (value === BREAK) {
+      if (token.value === Infinity) {
+        break;
+      }
+      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed array`);
+    }
+    if (value === DONE) {
+      throw new Error(`${decodeErrPrefix} found array but not enough entries (got ${i}, expected ${token.value})`);
+    }
+    arr[i] = value;
+  }
+  return arr;
+}
+function tokenToMap(token, tokeniser, options) {
+  const useMaps = options.useMaps === true;
+  const rejectDuplicateMapKeys = options.rejectDuplicateMapKeys === true;
+  const obj = useMaps ? undefined : {};
+  const m = useMaps ? new Map : undefined;
+  for (let i = 0;i < token.value; i++) {
+    const key = tokensToObject(tokeniser, options);
+    if (key === BREAK) {
+      if (token.value === Infinity) {
+        break;
+      }
+      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed map`);
+    }
+    if (key === DONE) {
+      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
+    }
+    if (!useMaps && typeof key !== "string") {
+      throw new Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`);
+    }
+    if (rejectDuplicateMapKeys) {
+      if (useMaps && m.has(key) || !useMaps && Object.hasOwn(obj, key)) {
+        throw new Error(`${decodeErrPrefix} found repeat map key "${key}"`);
+      }
+    }
+    const value = tokensToObject(tokeniser, options);
+    if (value === DONE) {
+      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
+    }
+    if (useMaps) {
+      m.set(key, value);
+    } else {
+      obj[key] = value;
+    }
+  }
+  return useMaps ? m : obj;
+}
+function* tokenToMapEntries(token, tokeniser, options) {
+  for (let i = 0;i < token.value; i++) {
+    const key = tokensToObject(tokeniser, options);
+    if (key === BREAK) {
+      if (token.value === Infinity) {
+        break;
+      }
+      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed map`);
+    }
+    if (key === DONE) {
+      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
+    }
+    const value = tokensToObject(tokeniser, options);
+    if (value === DONE) {
+      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
+    }
+    yield [key, value];
+  }
+}
+function createTagDecodeControl(tokeniser, options) {
+  let called = false;
+  const decode = function() {
+    if (called) {
+      throw new Error(`${decodeErrPrefix} tag decode() may only be called once`);
+    }
+    called = true;
+    const value = tokensToObject(tokeniser, options);
+    if (value === DONE) {
+      throw new Error(`${decodeErrPrefix} tag content missing`);
+    }
+    if (value === BREAK) {
+      throw new Error(`${decodeErrPrefix} got unexpected break in tag content`);
+    }
+    return value;
+  };
+  decode.entries = function() {
+    if (called) {
+      throw new Error(`${decodeErrPrefix} tag decode() may only be called once`);
+    }
+    called = true;
+    const token = tokeniser.next();
+    if (!Type.equals(token.type, Type.map)) {
+      throw new Error(`${decodeErrPrefix} entries() requires map content, got ${token.type.name}`);
+    }
+    const entries = [];
+    for (const entry of tokenToMapEntries(token, tokeniser, options)) {
+      entries.push(entry);
+    }
+    return entries;
+  };
+  Object.defineProperty(decode, "_called", {
+    get() {
+      return called;
+    },
+    enumerable: false
+  });
+  return decode;
+}
+function tokensToObject(tokeniser, options) {
+  if (tokeniser.done()) {
+    return DONE;
+  }
+  const token = tokeniser.next();
+  if (Type.equals(token.type, Type.break)) {
+    return BREAK;
+  }
+  if (token.type.terminal) {
+    return token.value;
+  }
+  if (Type.equals(token.type, Type.array)) {
+    return tokenToArray(token, tokeniser, options);
+  }
+  if (Type.equals(token.type, Type.map)) {
+    return tokenToMap(token, tokeniser, options);
+  }
+  if (Type.equals(token.type, Type.tag)) {
+    if (options.tags && typeof options.tags[token.value] === "function") {
+      const decodeControl = createTagDecodeControl(tokeniser, options);
+      const result = options.tags[token.value](decodeControl);
+      if (!decodeControl._called) {
+        throw new Error(`${decodeErrPrefix} tag decoder must call decode() or entries()`);
+      }
+      return result;
+    }
+    throw new Error(`${decodeErrPrefix} tag not supported (${token.value})`);
+  }
+  throw new Error("unsupported");
+}
+function decodeFirst(data, options) {
+  if (!(data instanceof Uint8Array)) {
+    throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`);
+  }
+  options = Object.assign({}, defaultDecodeOptions, options);
+  const u8aData = asU8A(data);
+  const tokeniser = options.tokenizer || new Tokeniser(u8aData, options);
+  const decoded = tokensToObject(tokeniser, options);
+  if (decoded === DONE) {
+    throw new Error(`${decodeErrPrefix} did not find any content to decode`);
+  }
+  if (decoded === BREAK) {
+    throw new Error(`${decodeErrPrefix} got unexpected break`);
+  }
+  return [decoded, data.subarray(tokeniser.pos())];
+}
+function decode(data, options) {
+  const [decoded, remainder] = decodeFirst(data, options);
+  if (remainder.length > 0) {
+    throw new Error(`${decodeErrPrefix} too many terminals, data makes no sense`);
+  }
+  return decoded;
+}
+
+// ../../node_modules/.bun/cborg@5.1.1/node_modules/cborg/lib/tagged.js
+class Tagged {
+  constructor(tag, value) {
+    if (typeof tag !== "number" || !Number.isInteger(tag) || tag < 0) {
+      throw new TypeError("Tagged: tag must be a non-negative integer");
+    }
+    this.tag = tag;
+    this.value = value;
+  }
+  static decoder(tag) {
+    return (decode2) => new Tagged(tag, decode2());
+  }
+  static preserve(...tagNumbers) {
+    const tags = {};
+    for (const tag of tagNumbers) {
+      tags[tag] = Tagged.decoder(tag);
+    }
+    return tags;
+  }
+}
+Object.defineProperty(Tagged.prototype, Symbol.toStringTag, {
+  value: "Tagged"
+});
+
+// ../../node_modules/.bun/multiformats@13.4.2/node_modules/multiformats/dist/src/bytes.js
+var empty = new Uint8Array(0);
+function equals(aa, bb) {
+  if (aa === bb) {
+    return true;
+  }
+  if (aa.byteLength !== bb.byteLength) {
+    return false;
+  }
+  for (let ii = 0;ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
+  }
+  return true;
+}
+function coerce(o) {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") {
+    return o;
+  }
+  if (o instanceof ArrayBuffer) {
+    return new Uint8Array(o);
+  }
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+}
+
+// ../../node_modules/.bun/multiformats@13.4.2/node_modules/multiformats/dist/src/vendor/base-x.js
+function base(ALPHABET, name) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0;j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0;i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode2(source) {
+    if (source instanceof Uint8Array)
+      ;
+    else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    var zeroes = 0;
+    var length = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i2 = 0;
+      for (var it1 = size - 1;(carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i2;
+      pbegin++;
+    }
+    var it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    var str = LEADER.repeat(zeroes);
+    for (;it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array;
+    }
+    var psz = 0;
+    if (source[psz] === " ") {
+      return;
+    }
+    var zeroes = 0;
+    var length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i2 = 0;
+      for (var it3 = size - 1;(carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode2(string) {
+    var buffer2 = decodeUnsafe(string);
+    if (buffer2) {
+      return buffer2;
+    }
+    throw new Error(`Non-${name} character`);
+  }
+  return {
+    encode: encode2,
+    decodeUnsafe,
+    decode: decode2
+  };
+}
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../node_modules/.bun/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base.js
+class Encoder {
+  name;
+  prefix;
+  baseEncode;
+  constructor(name, prefix, baseEncode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+  encode(bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`;
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+}
+
+class Decoder {
+  name;
+  prefix;
+  baseDecode;
+  prefixCodePoint;
+  constructor(name, prefix, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    const prefixCodePoint = prefix.codePointAt(0);
+    if (prefixCodePoint === undefined) {
+      throw new Error("Invalid prefix character");
+    }
+    this.prefixCodePoint = prefixCodePoint;
+    this.baseDecode = baseDecode;
+  }
+  decode(text) {
+    if (typeof text === "string") {
+      if (text.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+      }
+      return this.baseDecode(text.slice(this.prefix.length));
+    } else {
+      throw Error("Can only multibase decode strings");
+    }
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+}
+
+class ComposedDecoder {
+  decoders;
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder != null) {
+      return decoder.decode(input);
+    } else {
+      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+    }
+  }
+}
+function or(left, right) {
+  return new ComposedDecoder({
+    ...left.decoders ?? { [left.prefix]: left },
+    ...right.decoders ?? { [right.prefix]: right }
+  });
+}
+
+class Codec {
+  name;
+  prefix;
+  baseEncode;
+  baseDecode;
+  encoder;
+  decoder;
+  constructor(name, prefix, baseEncode, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name, prefix, baseEncode);
+    this.decoder = new Decoder(name, prefix, baseDecode);
+  }
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+}
+function from({ name, prefix, encode: encode2, decode: decode2 }) {
+  return new Codec(name, prefix, encode2, decode2);
+}
+function baseX({ name, prefix, alphabet }) {
+  const { encode: encode2, decode: decode2 } = base_x_default(alphabet, name);
+  return from({
+    prefix,
+    name,
+    encode: encode2,
+    decode: (text) => coerce(decode2(text))
+  });
+}
+function decode2(string, alphabetIdx, bitsPerChar, name) {
+  let end = string.length;
+  while (string[end - 1] === "=") {
+    --end;
+  }
+  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+  let bits = 0;
+  let buffer2 = 0;
+  let written = 0;
+  for (let i = 0;i < end; ++i) {
+    const value = alphabetIdx[string[i]];
+    if (value === undefined) {
+      throw new SyntaxError(`Non-${name} character`);
+    }
+    buffer2 = buffer2 << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer2 >> bits;
+    }
+  }
+  if (bits >= bitsPerChar || (255 & buffer2 << 8 - bits) !== 0) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+}
+function encode2(data, alphabet, bitsPerChar) {
+  const pad = alphabet[alphabet.length - 1] === "=";
+  const mask = (1 << bitsPerChar) - 1;
+  let out = "";
+  let bits = 0;
+  let buffer2 = 0;
+  for (let i = 0;i < data.length; ++i) {
+    buffer2 = buffer2 << 8 | data[i];
+    bits += 8;
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet[mask & buffer2 >> bits];
+    }
+  }
+  if (bits !== 0) {
+    out += alphabet[mask & buffer2 << bitsPerChar - bits];
+  }
+  if (pad) {
+    while ((out.length * bitsPerChar & 7) !== 0) {
+      out += "=";
+    }
+  }
+  return out;
+}
+function createAlphabetIdx(alphabet) {
+  const alphabetIdx = {};
+  for (let i = 0;i < alphabet.length; ++i) {
+    alphabetIdx[alphabet[i]] = i;
+  }
+  return alphabetIdx;
+}
+function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+  const alphabetIdx = createAlphabetIdx(alphabet);
+  return from({
+    prefix,
+    name,
+    encode(input) {
+      return encode2(input, alphabet, bitsPerChar);
+    },
+    decode(input) {
+      return decode2(input, alphabetIdx, bitsPerChar, name);
+    }
+  });
+}
+
+// ../../node_modules/.bun/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base32.js
+var base32 = rfc4648({
+  prefix: "b",
+  name: "base32",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+  bitsPerChar: 5
+});
+var base32upper = rfc4648({
+  prefix: "B",
+  name: "base32upper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  bitsPerChar: 5
+});
+var base32pad = rfc4648({
+  prefix: "c",
+  name: "base32pad",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
+  bitsPerChar: 5
+});
+var base32padupper = rfc4648({
+  prefix: "C",
+  name: "base32padupper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+  bitsPerChar: 5
+});
+var base32hex = rfc4648({
+  prefix: "v",
+  name: "base32hex",
+  alphabet: "0123456789abcdefghijklmnopqrstuv",
+  bitsPerChar: 5
+});
+var base32hexupper = rfc4648({
+  prefix: "V",
+  name: "base32hexupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+  bitsPerChar: 5
+});
+var base32hexpad = rfc4648({
+  prefix: "t",
+  name: "base32hexpad",
+  alphabet: "0123456789abcdefghijklmnopqrstuv=",
+  bitsPerChar: 5
+});
+var base32hexpadupper = rfc4648({
+  prefix: "T",
+  name: "base32hexpadupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
+  bitsPerChar: 5
+});
+var base32z = rfc4648({
+  prefix: "h",
+  name: "base32z",
+  alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
+  bitsPerChar: 5
+});
+
+// ../../node_modules/.bun/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base36.js
+var base36 = baseX({
+  prefix: "k",
+  name: "base36",
+  alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
+});
+var base36upper = baseX({
+  prefix: "K",
+  name: "base36upper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+});
+
+// ../../node_modules/.bun/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base58.js
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+// ../../node_modules/.bun/multiformats@13.4.2/node_modules/multiformats/dist/src/vendor/varint.js
+var encode_1 = encode3;
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+function encode3(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+  while (num >= INT) {
+    out[offset++] = num & 255 | MSB;
+    num /= 128;
+  }
+  while (num & MSBALL) {
+    out[offset++] = num & 255 | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  encode3.bytes = offset - oldOffset + 1;
+  return out;
+}
+var decode3 = read;
+var MSB$1 = 128;
+var REST$1 = 127;
+function read(buf, offset) {
+  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError("Could not decode varint");
+    }
+    b = buf[counter++];
+    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1);
+  read.bytes = counter - offset;
+  return res;
+}
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var length = function(value) {
+  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
+};
+var varint = {
+  encode: encode_1,
+  decode: decode3,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+var varint_default = _brrp_varint;
+
+// ../../node_modules/.bun/multiformats@13.4.2/node_modules/multiformats/dist/src/varint.js
+function decode4(data, offset = 0) {
+  const code = varint_default.decode(data, offset);
+  return [code, varint_default.decode.bytes];
+}
+function encodeTo(int, target, offset = 0) {
+  varint_default.encode(int, target, offset);
+  return target;
+}
+function encodingLength(int) {
+  return varint_default.encodingLength(int);
+}
+
+// ../../node_modules/.bun/multiformats@13.4.2/node_modules/multiformats/dist/src/hashes/digest.js
+function create(code, digest) {
+  const size = digest.byteLength;
+  const sizeOffset = encodingLength(code);
+  const digestOffset = sizeOffset + encodingLength(size);
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+  return new Digest(code, size, digest, bytes);
+}
+function decode5(multihash) {
+  const bytes = coerce(multihash);
+  const [code, sizeOffset] = decode4(bytes);
+  const [size, digestOffset] = decode4(bytes.subarray(sizeOffset));
+  const digest = bytes.subarray(sizeOffset + digestOffset);
+  if (digest.byteLength !== size) {
+    throw new Error("Incorrect length");
+  }
+  return new Digest(code, size, digest, bytes);
+}
+function equals2(a, b) {
+  if (a === b) {
+    return true;
+  } else {
+    const data = b;
+    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
+  }
+}
+
+class Digest {
+  code;
+  size;
+  digest;
+  bytes;
+  constructor(code, size, digest, bytes) {
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+}
+
+// ../../node_modules/.bun/multiformats@13.4.2/node_modules/multiformats/dist/src/cid.js
+function format(link, base2) {
+  const { bytes, version } = link;
+  switch (version) {
+    case 0:
+      return toStringV0(bytes, baseCache(link), base2 ?? base58btc.encoder);
+    default:
+      return toStringV1(bytes, baseCache(link), base2 ?? base32.encoder);
+  }
+}
+var cache = new WeakMap;
+function baseCache(cid) {
+  const baseCache2 = cache.get(cid);
+  if (baseCache2 == null) {
+    const baseCache3 = new Map;
+    cache.set(cid, baseCache3);
+    return baseCache3;
+  }
+  return baseCache2;
+}
+
+class CID {
+  code;
+  version;
+  multihash;
+  bytes;
+  "/";
+  constructor(version, code, multihash, bytes) {
+    this.code = code;
+    this.version = version;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this["/"] = bytes;
+  }
+  get asCID() {
+    return this;
+  }
+  get byteOffset() {
+    return this.bytes.byteOffset;
+  }
+  get byteLength() {
+    return this.bytes.byteLength;
+  }
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return this;
+      }
+      case 1: {
+        const { code, multihash } = this;
+        if (code !== DAG_PB_CODE) {
+          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+        }
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+        }
+        return CID.createV0(multihash);
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+      }
+    }
+  }
+  toV1() {
+    switch (this.version) {
+      case 0: {
+        const { code, digest } = this.multihash;
+        const multihash = create(code, digest);
+        return CID.createV1(this.code, multihash);
+      }
+      case 1: {
+        return this;
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
+      }
+    }
+  }
+  equals(other) {
+    return CID.equals(this, other);
+  }
+  static equals(self, other) {
+    const unknown = other;
+    return unknown != null && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
+  }
+  toString(base2) {
+    return format(this, base2);
+  }
+  toJSON() {
+    return { "/": format(this) };
+  }
+  link() {
+    return this;
+  }
+  [Symbol.toStringTag] = "CID";
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `CID(${this.toString()})`;
+  }
+  static asCID(input) {
+    if (input == null) {
+      return null;
+    }
+    const value = input;
+    if (value instanceof CID) {
+      return value;
+    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
+      const { version, code, multihash, bytes } = value;
+      return new CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
+    } else if (value[cidSymbol] === true) {
+      const { version, multihash, code } = value;
+      const digest = decode5(multihash);
+      return CID.create(version, code, digest);
+    } else {
+      return null;
+    }
+  }
+  static create(version, code, digest) {
+    if (typeof code !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    if (!(digest.bytes instanceof Uint8Array)) {
+      throw new Error("Invalid digest");
+    }
+    switch (version) {
+      case 0: {
+        if (code !== DAG_PB_CODE) {
+          throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+        } else {
+          return new CID(version, code, digest, digest.bytes);
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version, code, digest.bytes);
+        return new CID(version, code, digest, bytes);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
+  }
+  static createV0(digest) {
+    return CID.create(0, DAG_PB_CODE, digest);
+  }
+  static createV1(code, digest) {
+    return CID.create(1, code, digest);
+  }
+  static decode(bytes) {
+    const [cid, remainder] = CID.decodeFirst(bytes);
+    if (remainder.length !== 0) {
+      throw new Error("Incorrect length");
+    }
+    return cid;
+  }
+  static decodeFirst(bytes) {
+    const specs = CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error("Incorrect length");
+    }
+    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+    const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+    const cid = specs.version === 0 ? CID.createV0(digest) : CID.createV1(specs.codec, digest);
+    return [cid, bytes.subarray(specs.size)];
+  }
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length2] = decode4(initialBytes.subarray(offset));
+      offset += length2;
+      return i;
+    };
+    let version = next();
+    let codec = DAG_PB_CODE;
+    if (version === 18) {
+      version = 0;
+      offset = 0;
+    } else {
+      codec = next();
+    }
+    if (version !== 0 && version !== 1) {
+      throw new RangeError(`Invalid CID version ${version}`);
+    }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return { version, codec, multihashCode, digestSize, multihashSize, size };
+  }
+  static parse(source, base2) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base2);
+    const cid = CID.decode(bytes);
+    if (cid.version === 0 && source[0] !== "Q") {
+      throw Error("Version 0 CID string must not include multibase prefix");
+    }
+    baseCache(cid).set(prefix, source);
+    return cid;
+  }
+}
+function parseCIDtoBytes(source, base2) {
+  switch (source[0]) {
+    case "Q": {
+      const decoder = base2 ?? base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base2 ?? base58btc;
+      return [base58btc.prefix, decoder.decode(source)];
+    }
+    case base32.prefix: {
+      const decoder = base2 ?? base32;
+      return [base32.prefix, decoder.decode(source)];
+    }
+    case base36.prefix: {
+      const decoder = base2 ?? base36;
+      return [base36.prefix, decoder.decode(source)];
+    }
+    default: {
+      if (base2 == null) {
+        throw Error("To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided");
+      }
+      return [source[0], base2.decode(source)];
+    }
+  }
+}
+function toStringV0(bytes, cache2, base2) {
+  const { prefix } = base2;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base2.name} encoding`);
+  }
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes).slice(1);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+function toStringV1(bytes, cache2, base2) {
+  const { prefix } = base2;
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+function encodeCID(version, code, multihash) {
+  const codeOffset = encodingLength(version);
+  const hashOffset = codeOffset + encodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version, bytes, 0);
+  encodeTo(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+}
+var cidSymbol = Symbol.for("@ipld/js-cid/CID");
+
+// ../../node_modules/.bun/@ipld+dag-cbor@9.2.6/node_modules/@ipld/dag-cbor/src/index.js
+var CID_CBOR_TAG = 42;
+function toByteView(buf) {
+  if (buf instanceof ArrayBuffer) {
+    return new Uint8Array(buf, 0, buf.byteLength);
+  }
+  return buf;
+}
+function cidEncoder(obj) {
+  if (obj.asCID !== obj && obj["/"] !== obj.bytes) {
+    return null;
+  }
+  const cid = CID.asCID(obj);
+  if (!cid) {
+    return null;
+  }
+  const bytes = new Uint8Array(cid.bytes.byteLength + 1);
+  bytes.set(cid.bytes, 1);
+  return [
+    new Token(Type.tag, CID_CBOR_TAG),
+    new Token(Type.bytes, bytes)
+  ];
+}
+function undefinedEncoder() {
+  throw new Error("`undefined` is not supported by the IPLD Data Model and cannot be encoded");
+}
+function numberEncoder(num) {
+  if (Number.isNaN(num)) {
+    throw new Error("`NaN` is not supported by the IPLD Data Model and cannot be encoded");
+  }
+  if (num === Infinity || num === -Infinity) {
+    throw new Error("`Infinity` and `-Infinity` is not supported by the IPLD Data Model and cannot be encoded");
+  }
+  return null;
+}
+function mapEncoder(map) {
+  for (const key of map.keys()) {
+    if (typeof key !== "string" || key.length === 0) {
+      throw new Error("Non-string Map keys are not supported by the IPLD Data Model and cannot be encoded");
+    }
+  }
+  return null;
+}
+var _encodeOptions = {
+  float64: true,
+  typeEncoders: {
+    Map: mapEncoder,
+    Object: cidEncoder,
+    undefined: undefinedEncoder,
+    number: numberEncoder
+  }
+};
+var encodeOptions = {
+  ..._encodeOptions,
+  typeEncoders: {
+    ..._encodeOptions.typeEncoders
+  }
+};
+function cidDecoder(decode6) {
+  const bytes = decode6();
+  if (bytes[0] !== 0) {
+    throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
+  }
+  return CID.decode(bytes.subarray(1));
+}
+var _decodeOptions = {
+  allowIndefinite: false,
+  coerceUndefinedToNull: true,
+  allowNaN: false,
+  allowInfinity: false,
+  allowBigInt: true,
+  strict: true,
+  useMaps: false,
+  rejectDuplicateMapKeys: true,
+  tags: { [CID_CBOR_TAG]: cidDecoder }
+};
+var decodeOptions = {
+  ..._decodeOptions,
+  tags: { ..._decodeOptions.tags }
+};
+var encode4 = (node) => encode(node, _encodeOptions);
+var decode6 = (data) => decode(toByteView(data), _decodeOptions);
+
+// src/policy.ts
+function parsePolicy(token) {
+  const segments = token.split(".");
+  if (segments.length < 2) {
+    throw new Error("Invalid policy token: expected at least 2 segments");
+  }
+  const payload = decodePayload(segments[1]);
+  const allowedOrigins = extractOrigins(payload);
+  const capabilities = extractCapabilities(payload);
+  return { token, allowedOrigins, capabilities };
+}
+function assertOriginAllowed(policy, origin) {
+  if (policy.allowedOrigins.length === 0)
+    return;
+  const ok = policy.allowedOrigins.some((allowed) => matchesOrigin(allowed, origin));
+  if (!ok) {
+    throw new Error(`Origin "${origin}" is not authorized by the project policy. ` + `Allowed origins: ${policy.allowedOrigins.join(", ")}`);
+  }
+}
+function matchesOrigin(allowed, origin) {
+  if (allowed === "*" || allowed === origin)
+    return true;
+  if (allowed.startsWith("*.")) {
+    const suffix = allowed.slice(1);
+    try {
+      const host = new URL(origin).host;
+      return host.endsWith(suffix.slice(1));
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function decodePayload(seg) {
+  try {
+    const padded = seg.padEnd(seg.length + (4 - seg.length % 4) % 4, "=");
+    const normalized = padded.replace(/-/g, "+").replace(/_/g, "/");
+    const decoded = atob(normalized);
+    return JSON.parse(decoded);
+  } catch {
+    return {};
+  }
+}
+function extractOrigins(payload) {
+  const origins = payload.origins ?? payload.aud ?? payload.prf;
+  if (Array.isArray(origins))
+    return origins.filter((o) => typeof o === "string");
+  if (typeof origins === "string")
+    return [origins];
+  return [];
+}
+function extractCapabilities(payload) {
+  const att = payload.att;
+  if (!Array.isArray(att))
+    return [];
+  return att.map((entry) => {
+    if (typeof entry === "string")
+      return entry;
+    if (entry && typeof entry === "object" && "cmd" in entry) {
+      return String(entry.cmd);
+    }
+    return null;
+  }).filter((c) => c !== null);
+}
+
+class PolicyTokenParseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PolicyTokenParseError";
+  }
+}
+function parsePolicyToken(raw) {
+  const trimmed = raw.trim();
+  const segments = trimmed.split(".");
+  if (segments.length !== 3) {
+    throw new PolicyTokenParseError(`expected JWT-style token with 3 segments, got ${segments.length}`);
+  }
+  const [headerSeg, payloadSeg, envelopeSeg] = segments;
+  const header = parseJsonSegment(headerSeg, "header");
+  if (typeof header.alg !== "string" || typeof header.typ !== "string") {
+    throw new PolicyTokenParseError("header missing alg/typ");
+  }
+  const payload = parseJsonSegment(payloadSeg, "payload");
+  if (typeof payload.iss !== "string") {
+    throw new PolicyTokenParseError("payload missing iss");
+  }
+  const envelopeBytes = base64UrlDecode(envelopeSeg);
+  let envelope;
+  try {
+    envelope = decode6(envelopeBytes);
+  } catch (err) {
+    throw new PolicyTokenParseError(`envelope is not valid DAG-CBOR: ${err.message}`);
+  }
+  if (!Array.isArray(envelope) || envelope.length !== 2) {
+    throw new PolicyTokenParseError("envelope must be a 2-item list");
+  }
+  const [signature, sigPayload] = envelope;
+  if (!(signature instanceof Uint8Array)) {
+    throw new PolicyTokenParseError("envelope[0] must be byte string");
+  }
+  const signedBytes = encode4(sigPayload);
+  const publicKeyHex = pubKeyHexFromDIDKey(payload.iss);
+  return {
+    raw: trimmed,
+    header: { alg: header.alg, typ: header.typ },
+    payload,
+    signature,
+    signedBytes,
+    publicKeyHex
+  };
+}
+function getPolicyFacts(payload) {
+  const first = payload.fct?.[0];
+  const facts = first ? first["hyperauth/policy"] : undefined;
+  if (!facts)
+    return null;
+  const origins = Array.isArray(facts.origins) ? facts.origins.filter((o) => typeof o === "string") : [];
+  return {
+    origins,
+    chainId: typeof facts.chain_id === "number" ? facts.chain_id : 0,
+    paymaster: typeof facts.paymaster === "string" ? facts.paymaster : "",
+    maxFeePerUserUsd: typeof facts.max_fee_per_user_usd === "number" ? facts.max_fee_per_user_usd : 0
+  };
+}
+function isPolicyExpired(payload, nowSeconds = Date.now() / 1000) {
+  return nowSeconds >= payload.exp;
+}
+function isOriginAllowedByFacts(facts, origin) {
+  if (facts.origins.length === 0)
+    return true;
+  return facts.origins.some((allowed) => matchesOrigin(allowed, origin));
+}
+function pubKeyHexFromDIDKey(did) {
+  if (!did.startsWith("did:key:z")) {
+    throw new PolicyTokenParseError(`unsupported DID format: ${did}`);
+  }
+  const decoded = base58btcDecode(did.slice("did:key:z".length));
+  if (decoded.length < 3 || decoded[0] !== 231 || decoded[1] !== 1) {
+    throw new PolicyTokenParseError("issuer is not a secp256k1-pub did:key");
+  }
+  const pub = decoded.slice(2);
+  return [...pub].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58btcDecode(input) {
+  const map = new Map;
+  for (let i = 0;i < BASE58_ALPHABET.length; i++)
+    map.set(BASE58_ALPHABET[i], i);
+  const bytes = [];
+  for (const ch of input) {
+    const value = map.get(ch);
+    if (value === undefined) {
+      throw new PolicyTokenParseError(`invalid base58 character: ${ch}`);
+    }
+    let carry = value;
+    for (let j = 0;j < bytes.length; j++) {
+      carry += (bytes[j] ?? 0) * 58;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  for (let i = 0;i < input.length && input[i] === "1"; i++)
+    bytes.push(0);
+  return new Uint8Array(bytes.reverse());
+}
+function parseJsonSegment(seg, label) {
+  let text;
+  try {
+    text = new TextDecoder().decode(base64UrlDecode(seg));
+  } catch (err) {
+    throw new PolicyTokenParseError(`${label} segment is not base64url: ${err.message}`);
+  }
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    throw new PolicyTokenParseError(`${label} segment is not valid JSON: ${err.message}`);
+  }
+}
+function base64UrlDecode(input) {
+  const padded = input.padEnd(input.length + (4 - input.length % 4) % 4, "=");
+  const normalized = padded.replace(/-/g, "+").replace(/_/g, "/");
+  const binary = atob(normalized);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++)
+    out[i] = binary.charCodeAt(i);
+  return out;
+}
+
+// src/iframe-bridge.ts
+var nextId = 1;
+async function mountIframeBridge(opts) {
+  if (!isBrowser()) {
+    throw new Error("mountIframeBridge can only be called in the browser");
+  }
+  const { origin, path = "/embed", readyTimeoutMs = 1e4 } = opts;
+  const url = new URL(path, origin).toString();
+  const iframe = document.createElement("iframe");
+  iframe.src = url;
+  iframe.style.cssText = "position:absolute;width:0;height:0;border:0;visibility:hidden;pointer-events:none";
+  iframe.setAttribute("aria-hidden", "true");
+  iframe.setAttribute("title", "HyperAuth Enclave Host");
+  document.body.appendChild(iframe);
+  const pending = new Map;
+  let ready = false;
+  const onMessage = (event) => {
+    if (event.origin !== origin)
+      return;
+    const data = event.data;
+    if (!data || typeof data !== "object")
+      return;
+    if (data.type === "hyperauth:ready") {
+      ready = true;
+      return;
+    }
+    if (data.type === "hyperauth:reply" && typeof data.id === "number") {
+      const handler = pending.get(data.id);
+      if (!handler)
+        return;
+      pending.delete(data.id);
+      if (data.error)
+        handler.reject(new Error(data.error));
+      else
+        handler.resolve(data.result);
+    }
+  };
+  window.addEventListener("message", onMessage);
+  await new Promise((resolve, reject) => {
+    const start = Date.now();
+    const tick = () => {
+      if (ready)
+        return resolve();
+      if (Date.now() - start > readyTimeoutMs) {
+        return reject(new Error(`Iframe enclave at ${origin} did not signal ready within ${readyTimeoutMs}ms`));
+      }
+      setTimeout(tick, 50);
+    };
+    tick();
+  });
+  const bridge = {
+    iframe,
+    isReady: () => ready,
+    call(method, payload, timeoutMs = 30000) {
+      const id = nextId++;
+      const target = iframe.contentWindow;
+      if (!target) {
+        return Promise.reject(new Error("Iframe contentWindow is unavailable"));
+      }
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          pending.delete(id);
+          reject(new Error(`Iframe call "${method}" timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        pending.set(id, {
+          resolve: (v) => {
+            clearTimeout(timeout);
+            resolve(v);
+          },
+          reject: (e) => {
+            clearTimeout(timeout);
+            reject(e);
+          }
+        });
+        target.postMessage({ type: "hyperauth:call", id, method, payload }, origin);
+      });
+    },
+    destroy() {
+      window.removeEventListener("message", onMessage);
+      pending.forEach((h) => h.reject(new Error("Iframe bridge destroyed")));
+      pending.clear();
+      if (iframe.parentNode)
+        iframe.parentNode.removeChild(iframe);
+      bridge.iframe = null;
+      ready = false;
+    }
+  };
+  return bridge;
+}
+
+// src/provider.ts
+var DEFAULT_MAX_RESTARTS = 3;
+function createHyperAuth(options = {}) {
+  const {
+    projectId,
+    chain = "base",
+    config,
+    enclaveOrigin,
+    maxRestartAttempts = DEFAULT_MAX_RESTARTS,
+    autoRestart = true
+  } = options;
+  return {
+    install(app) {
+      const store = createStore({ chain });
+      const ctx = reactive({
+        client: null,
+        status: "initializing",
+        error: null,
+        isReady: false,
+        user: null,
+        address: null,
+        authStatus: "unauthenticated",
+        session: null,
+        provider: "unknown",
+        policy: null,
+        chain,
+        store
+      });
+      function syncFromStore() {
+        const s = store.getState();
+        ctx.client = s.client;
+        ctx.status = s.status;
+        ctx.error = s.error;
+        ctx.isReady = s.status === "ready" && s.client !== null;
+        ctx.user = s.user;
+        ctx.address = s.user?.smartAccountAddress ? s.user.smartAccountAddress : null;
+        ctx.authStatus = s.authStatus;
+        ctx.session = s.session;
+        ctx.provider = s.provider;
+        ctx.policy = s.policy;
+        ctx.chain = s.chain;
+      }
+      const unsubscribe = store.subscribe(syncFromStore);
+      syncFromStore();
+      app.provide(HyperAuthKey, ctx);
+      let iframe = null;
+      let instance;
+      let disposed = false;
+      async function bootClient(attempt) {
+        try {
+          store.setState({
+            status: attempt === 0 ? "initializing" : "restarting",
+            error: null
+          });
+          if (projectId) {
+            const policy = parsePolicy(projectId);
+            const origin2 = getOrigin();
+            if (origin2)
+              assertOriginAllowed(policy, origin2);
+            store.setState({ policy });
+          }
+          const origin = getOrigin();
+          if (enclaveOrigin && origin && enclaveOrigin !== origin && !iframe) {
+            iframe = await mountIframeBridge({ origin: enclaveOrigin });
+          }
+          instance = await createClient(config);
+          if (disposed) {
+            await instance.close();
+            return;
+          }
+          attachWorkerCrashHandler(() => {
+            if (!autoRestart || disposed)
+              return;
+            const attempts = store.getState().restartAttempts;
+            if (attempts >= maxRestartAttempts) {
+              store.setState({
+                status: "error",
+                error: new Error(`Worker restart attempts exhausted (${attempts})`)
+              });
+              return;
+            }
+            store.setState({ restartAttempts: attempts + 1 });
+            bootClient(attempts + 1);
+          });
+          store.setState({ client: instance, status: "ready" });
+        } catch (err) {
+          if (disposed)
+            return;
+          store.setState({
+            status: "error",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        }
+      }
+      if (isBrowser()) {
+        bootClient(0);
+      }
+      app.onUnmount(() => {
+        disposed = true;
+        unsubscribe();
+        instance?.close();
+        iframe?.destroy();
+        iframe = null;
+      });
+    }
+  };
+}
+function attachWorkerCrashHandler(onCrash) {
+  if (!isBrowser())
+    return;
+  const handler = (event) => {
+    const err = event;
+    const msg = err?.message ?? "";
+    if (msg.includes("worker") || msg.includes("Worker") || msg.includes("enclave")) {
+      onCrash();
+    }
+  };
+  window.addEventListener("error", handler, { once: true });
+}
+// src/use-hyperauth.ts
+import { inject } from "vue";
+import { ClientStateError } from "@hyperauth/client";
+function useHyperAuth() {
+  const ctx = inject(HyperAuthKey);
+  if (!ctx) {
+    throw new ClientStateError("useHyperAuth must be called under a component tree that has installed `createHyperAuth()`");
+  }
+  return ctx;
+}
+// src/use-login.ts
+import { computed } from "vue";
+import { HyperAuthError, ClientStateError as ClientStateError2 } from "@hyperauth/client";
+
+// src/use-store.ts
+import { onScopeDispose, readonly, shallowRef } from "vue";
+function useStoreSelector(store, selector = (s) => s) {
+  const valueRef = shallowRef(selector(store.getState()));
+  const unsubscribe = store.subscribe(() => {
+    valueRef.value = selector(store.getState());
+  });
+  onScopeDispose(() => {
+    unsubscribe();
+  });
+  return readonly(valueRef);
+}
+
+// src/use-login.ts
+var selectAuthStatus = (s) => s.authStatus;
+function useLogin() {
+  const ctx = useHyperAuth();
+  const { store } = ctx;
+  const authStatus = useStoreSelector(store, selectAuthStatus);
+  async function login(opts = {}) {
+    const client = ctx.client;
+    if (!client)
+      throw new ClientStateError2("Client not ready");
+    if (!hasWebAuthn())
+      throw new HyperAuthError("WebAuthn unavailable in this environment");
+    store.setState({ authStatus: "authenticating", error: null });
+    try {
+      const sdk = await import("@hyperauth/client");
+      const credentialId = await sdk.authenticatePasskey(opts.rpId);
+      const result = await client.generate(credentialId, opts.alias ? { identifier: opts.alias } : undefined);
+      const publicKeyHex = result.shares.public_key_hex ?? (typeof result.shares.public_key === "string" ? result.shares.public_key : "");
+      const derived = publicKeyHex ? await client.deriveAddress(publicKeyHex, "ethereum") : null;
+      const user = {
+        did: result.did,
+        alias: opts.alias,
+        enclaveId: result.shares.enclave_id,
+        publicKeyHex,
+        pubkeyX: result.shares.pubkey_x ?? "",
+        pubkeyY: result.shares.pubkey_y ?? "",
+        ethAddress: result.address,
+        smartAccountAddress: derived?.address ?? "",
+        credentialId,
+        shares: result.shares
+      };
+      store.setState({ user, authStatus: "authenticated", provider: "webauthn" });
+      return user;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      store.setState({ authStatus: "error", error });
+      throw error;
+    }
+  }
+  async function logout() {
+    const client = ctx.client;
+    if (client) {
+      try {
+        await client.lock();
+      } catch {}
+    }
+    store.setState({
+      user: null,
+      session: null,
+      authStatus: "unauthenticated",
+      provider: "unknown"
+    });
+  }
+  return {
+    login,
+    logout,
+    isAuthenticating: computed(() => authStatus.value === "authenticating")
+  };
+}
+// src/use-session.ts
+import { computed as computed2 } from "vue";
+import { ClientStateError as ClientStateError3, HyperAuthError as HyperAuthError2 } from "@hyperauth/client";
+var DEFAULT_TTL = 60 * 60;
+var DEFAULT_COMMANDS = ["account/sign"];
+var selectSession = (s) => s.session;
+function useSession() {
+  const ctx = useHyperAuth();
+  const { store } = ctx;
+  const sessionRef = useStoreSelector(store, selectSession);
+  const session = computed2(() => sessionRef.value);
+  async function create2(opts = {}) {
+    const client = ctx.client;
+    const user = ctx.user;
+    if (!client)
+      throw new ClientStateError3("Client not ready");
+    if (!user?.shares)
+      throw new HyperAuthError2("User must be authenticated before creating a session");
+    const audience = opts.audience ?? `did:web:${(getOrigin() ?? "").replace(/^https?:\/\//, "")}`;
+    const commands = opts.commands ?? DEFAULT_COMMANDS;
+    const ttl = opts.ttlSeconds ?? DEFAULT_TTL;
+    const expiresAt = Math.floor(Date.now() / 1000) + ttl;
+    const ucanResult = await client.mintUcan(user.shares, {
+      audience,
+      commands,
+      expiration: expiresAt,
+      spend_cap_wei: opts.spendCapWei?.toString(),
+      tx_cap: opts.txCap
+    });
+    const token = encodeUcanToken(ucanResult.signed_dag_cbor);
+    const next = {
+      token,
+      audience,
+      commands,
+      expiresAt,
+      spendCapWei: opts.spendCapWei,
+      txCap: opts.txCap,
+      txCount: 0
+    };
+    store.setState({ session: next, provider: "session-key" });
+    return next;
+  }
+  function revoke() {
+    store.setState((s) => ({
+      session: null,
+      provider: s.user ? "webauthn" : "unknown"
+    }));
+  }
+  function recordTx() {
+    store.setState((s) => {
+      if (!s.session)
+        return {};
+      return { session: { ...s.session, txCount: s.session.txCount + 1 } };
+    });
+  }
+  const now = () => Date.now();
+  return {
+    session,
+    isExpired: computed2(() => session.value ? session.value.expiresAt * 1000 <= now() : false),
+    remainingMs: computed2(() => session.value ? Math.max(0, session.value.expiresAt * 1000 - now()) : 0),
+    create: create2,
+    revoke,
+    recordTx
+  };
+}
+function encodeUcanToken(b64std) {
+  return b64std.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+// src/use-account.ts
+import { computed as computed3, watch } from "vue";
+var selectAccount = (s) => ({
+  address: s.user?.smartAccountAddress ?? null,
+  state: s.accountState,
+  user: s.user
+});
+function useAccount() {
+  const { store } = useHyperAuth();
+  const snap = useStoreSelector(store, selectAccount);
+  async function refresh() {
+    const addr = snap.value.address;
+    if (!addr)
+      return;
+    const sdk = await import("@hyperauth/client");
+    const accountState = await sdk.getAccountState({ account: addr });
+    store.setState({ accountState });
+  }
+  watch(() => snap.value.address, (addr) => {
+    if (addr && !snap.value.state) {
+      refresh();
+    }
+  }, { immediate: true });
+  return {
+    address: computed3(() => snap.value.address ? snap.value.address : null),
+    ethAddress: computed3(() => snap.value.user?.ethAddress ? snap.value.user.ethAddress : null),
+    state: computed3(() => snap.value.state),
+    isDeployed: computed3(() => snap.value.state?.isActive ?? false),
+    refresh
+  };
+}
+// src/use-transaction.ts
+import { computed as computed4 } from "vue";
+import { ClientStateError as ClientStateError4, HyperAuthError as HyperAuthError3 } from "@hyperauth/client";
+
+// src/chains.ts
+var chainIds = {
+  base: 8453,
+  "base-sepolia": 84532,
+  monad: 41454,
+  ethereum: 1
+};
+var explorerUrls = {
+  base: "https://basescan.org",
+  "base-sepolia": "https://sepolia.basescan.org",
+  monad: "https://explorer.monad.xyz",
+  ethereum: "https://etherscan.io"
+};
+function txExplorerUrl(chain, hash) {
+  return `${explorerUrls[chain]}/tx/${hash}`;
+}
+
+// src/use-transaction.ts
+var DEFAULT_CALL_GAS = "0x30d40";
+var DEFAULT_VERIFICATION_GAS = "0xf4240";
+var DEFAULT_PRE_VERIFICATION_GAS = "0x186a0";
+var DEFAULT_MAX_FEE_PER_GAS = "0x59682f00";
+var DEFAULT_MAX_PRIORITY_FEE_PER_GAS = "0x59682f00";
+var selectTx = (s) => s.pendingTransaction;
+function useTransaction() {
+  const ctx = useHyperAuth();
+  const { store } = ctx;
+  const tx = useStoreSelector(store, selectTx);
+  async function buildUserOp(intent) {
+    const client = ctx.client;
+    const user = ctx.user;
+    if (!client)
+      throw new ClientStateError4("Client not ready");
+    if (!user?.smartAccountAddress)
+      throw new HyperAuthError3("User has no smart account address");
+    const sdk = await import("@hyperauth/client");
+    const viem = await import("viem");
+    const callData = intent.rawCallData ?? viem.encodeFunctionData({
+      abi: sdk.hyperAuthAccountAbi,
+      functionName: "execute",
+      args: [intent.to, intent.value ?? 0n, intent.data ?? "0x"]
+    });
+    const accountStateResult = await sdk.getAccountState({ account: user.smartAccountAddress });
+    const isActive = accountStateResult.isActive;
+    let factory = null;
+    let factoryData = null;
+    if (!isActive && user.pubkeyX && user.pubkeyY) {
+      factory = sdk.defaultContracts.hyperAuthFactory;
+      factoryData = viem.encodeFunctionData({
+        abi: sdk.hyperAuthFactoryAbi,
+        functionName: "createAccount",
+        args: [BigInt(`0x${user.pubkeyX}`), BigInt(`0x${user.pubkeyY}`), 0n]
+      });
+    }
+    return {
+      sender: user.smartAccountAddress,
+      nonce: accountStateResult.nonce || "0x0",
+      factory,
+      factoryData,
+      callData,
+      callGasLimit: DEFAULT_CALL_GAS,
+      verificationGasLimit: DEFAULT_VERIFICATION_GAS,
+      preVerificationGas: DEFAULT_PRE_VERIFICATION_GAS,
+      maxFeePerGas: DEFAULT_MAX_FEE_PER_GAS,
+      maxPriorityFeePerGas: DEFAULT_MAX_PRIORITY_FEE_PER_GAS,
+      paymaster: null,
+      paymasterVerificationGasLimit: null,
+      paymasterPostOpGasLimit: null,
+      paymasterData: null,
+      signature: "0x"
+    };
+  }
+  async function signAndSend(intent) {
+    const client = ctx.client;
+    const user = ctx.user;
+    const session = ctx.session;
+    const chain = ctx.chain;
+    const policy = ctx.policy;
+    if (!client)
+      throw new ClientStateError4("Client not ready");
+    if (!user?.shares)
+      throw new HyperAuthError3("User must be authenticated");
+    try {
+      store.setState({
+        pendingTransaction: { phase: "building", error: null, result: null, userOp: null }
+      });
+      const sdk = await import("@hyperauth/client");
+      const userOp = await buildUserOp(intent);
+      store.setState({
+        pendingTransaction: { phase: "sponsoring", error: null, result: null, userOp }
+      });
+      const wantsSponsorship = isSponsoredAction(policy, intent);
+      let opToSign = userOp;
+      let sponsored = false;
+      if (wantsSponsorship) {
+        try {
+          opToSign = await sdk.sponsorUserOp(userOp, sdk.defaultContracts.entryPoint);
+          sponsored = true;
+        } catch {}
+      }
+      store.setState({
+        pendingTransaction: { phase: "signing", error: null, result: null, userOp: opToSign }
+      });
+      const chainId = chainIds[chain];
+      const opHash = await sdk.computeUserOpHash(opToSign, sdk.defaultContracts.entryPoint, chainId);
+      let signature;
+      if (session && session.expiresAt * 1000 > Date.now()) {
+        const signed = await client.signUserOp(opToSign, session.token);
+        signature = signed.signature;
+      } else {
+        const signed = await client.sign(user.shares, Array.from(sdk.hexToBytes(opHash)));
+        signature = sdk.bytesToHex(new Uint8Array(signed.signature));
+      }
+      const signedOp = { ...opToSign, signature };
+      store.setState({
+        pendingTransaction: { phase: "submitting", error: null, result: null, userOp: signedOp }
+      });
+      const userOpHash = await sdk.sendUserOp(signedOp, sdk.defaultContracts.entryPoint);
+      store.setState({
+        pendingTransaction: { phase: "confirming", error: null, result: null, userOp: signedOp }
+      });
+      const receipt = await sdk.waitForReceipt(userOpHash);
+      const txHash = receipt.receipt.transactionHash;
+      const blockNumber = parseBlockNumber(receipt.receipt.blockNumber);
+      const result = { userOpHash, txHash, blockNumber, sponsored };
+      store.setState({
+        pendingTransaction: { phase: "confirmed", error: null, result, userOp: signedOp }
+      });
+      if (session) {
+        store.setState((s) => s.session ? { session: { ...s.session, txCount: s.session.txCount + 1 } } : {});
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      store.setState((s) => ({
+        pendingTransaction: { ...s.pendingTransaction, phase: "error", error: msg }
+      }));
+      throw err;
+    }
+  }
+  function reset() {
+    store.setState({
+      pendingTransaction: { phase: "idle", error: null, result: null, userOp: null }
+    });
+  }
+  return {
+    phase: computed4(() => tx.value.phase),
+    error: computed4(() => tx.value.error),
+    result: computed4(() => tx.value.result),
+    userOp: computed4(() => tx.value.userOp),
+    signAndSend,
+    buildUserOp,
+    reset
+  };
+}
+function isSponsoredAction(policy, intent) {
+  if (!policy)
+    return false;
+  if (policy.capabilities.includes("paymaster/sponsor:*"))
+    return true;
+  return policy.capabilities.includes("paymaster/sponsor");
+}
+function parseBlockNumber(value) {
+  if (typeof value === "string")
+    return parseInt(value, 16);
+  if (typeof value === "number")
+    return value;
+  return null;
+}
+// src/use-settlement.ts
+import { computed as computed5 } from "vue";
+import { ClientStateError as ClientStateError5, HyperAuthError as HyperAuthError4 } from "@hyperauth/client";
+var PHASES = [
+  { phase: "capturing-fiat", label: "Capturing fiat (Apple Pay)" },
+  { phase: "auditing", label: "TigerBeetle audit" },
+  { phase: "minting", label: "CCTP mint" },
+  { phase: "finalizing", label: "On-chain finality" }
+];
+var selectSettlement = (s) => s.settlement;
+function useSettlement() {
+  const ctx = useHyperAuth();
+  const { store } = ctx;
+  const state = useStoreSelector(store, selectSettlement);
+  async function settle(params) {
+    const client = ctx.client;
+    const user = ctx.user;
+    const session = ctx.session;
+    const chain = ctx.chain;
+    if (!client)
+      throw new ClientStateError5("Client not ready");
+    if (!user?.smartAccountAddress)
+      throw new HyperAuthError4("User has no smart account");
+    const initialSteps = PHASES.map(({ phase, label }) => ({
+      phase,
+      label,
+      status: "pending"
+    }));
+    store.setState({
+      settlement: {
+        phase: "capturing-fiat",
+        steps: initialSteps,
+        params,
+        txHash: null,
+        error: null
+      }
+    });
+    try {
+      const sdk = await import("@hyperauth/client");
+      markActive(store, "capturing-fiat");
+      const recipient = params.recipient ?? user.smartAccountAddress;
+      const ucan = params.sessionToken ?? session?.token;
+      if (!ucan)
+        throw new HyperAuthError4("Settlement requires an active session UCAN");
+      markDone(store, "capturing-fiat");
+      markActive(store, "auditing");
+      const result = await client.submitPayment({
+        to: recipient,
+        amount: String(params.amount),
+        token: params.currency,
+        chainId: chainIdFromName(chain),
+        ucan,
+        label: `Settlement: ${params.amount} ${params.currency}`
+      });
+      markDone(store, "auditing");
+      markActive(store, "minting");
+      markDone(store, "minting");
+      markActive(store, "finalizing");
+      const receipt = await sdk.waitForReceipt(result.userOpHash);
+      const txHash = receipt.receipt.transactionHash;
+      markDone(store, "finalizing");
+      store.setState({
+        settlement: {
+          phase: "complete",
+          steps: store.getState().settlement.steps,
+          params,
+          txHash,
+          error: null
+        }
+      });
+      params.onSuccess?.(txHash);
+      return txHash;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      store.setState((s) => ({
+        settlement: {
+          ...s.settlement,
+          phase: "error",
+          error: error.message,
+          steps: s.settlement.steps.map((step) => step.status === "active" ? { ...step, status: "error", detail: error.message } : step)
+        }
+      }));
+      params.onError?.(error);
+      throw error;
+    }
+  }
+  function reset() {
+    store.setState({
+      settlement: { phase: "idle", steps: [], params: null, txHash: null, error: null }
+    });
+  }
+  return {
+    phase: computed5(() => state.value.phase),
+    steps: computed5(() => state.value.steps),
+    params: computed5(() => state.value.params),
+    txHash: computed5(() => state.value.txHash),
+    error: computed5(() => state.value.error),
+    settle,
+    reset
+  };
+}
+function markActive(store, phase) {
+  store.setState((s) => ({
+    settlement: {
+      ...s.settlement,
+      phase,
+      steps: s.settlement.steps.map((step) => step.phase === phase ? { ...step, status: "active" } : step)
+    }
+  }));
+}
+function markDone(store, phase) {
+  store.setState((s) => ({
+    settlement: {
+      ...s.settlement,
+      steps: s.settlement.steps.map((step) => step.phase === phase ? { ...step, status: "done" } : step)
+    }
+  }));
+}
+function chainIdFromName(chain) {
+  switch (chain) {
+    case "base":
+      return 8453;
+    case "base-sepolia":
+      return 84532;
+    case "monad":
+      return 41454;
+    case "ethereum":
+      return 1;
+  }
+}
+// src/use-registration.ts
+import { computed as computed6, ref } from "vue";
+import { HyperAuthError as HyperAuthError5, ClientStateError as ClientStateError6 } from "@hyperauth/client";
+var DEFAULT_CALL_GAS2 = "0x30d40";
+var DEFAULT_VERIFICATION_GAS2 = "0xf4240";
+var DEFAULT_PRE_VERIFICATION_GAS2 = "0x186a0";
+var DEFAULT_MAX_FEE_PER_GAS2 = "0x59682f00";
+var DEFAULT_MAX_PRIORITY_FEE_PER_GAS2 = "0x59682f00";
+var STEP_LABELS = [
+  "Checking availability",
+  "Creating passkey",
+  "Generating identity",
+  "Predicting account",
+  "Checking account state",
+  "Preparing registration",
+  "Covering fees",
+  "Granting permissions",
+  "Signing securely",
+  "Submitting registration",
+  "Waiting for confirmation",
+  "Saving session"
+];
+async function importSdk() {
+  return import("@hyperauth/client");
+}
+async function importViem() {
+  return import("viem");
+}
+function useRegistration() {
+  const ctx = useHyperAuth();
+  const phase = ref("idle");
+  const steps = ref([]);
+  const identity = ref(null);
+  const result = ref(null);
+  const error = ref(null);
+  const isRegistering = ref(false);
+  function updateStep(index, status, detail) {
+    steps.value = steps.value.map((step, i) => i === index ? { ...step, status, detail } : step);
+  }
+  function reset() {
+    phase.value = "idle";
+    steps.value = [];
+    identity.value = null;
+    result.value = null;
+    error.value = null;
+    isRegistering.value = false;
+  }
+  async function register(alias) {
+    const client = ctx.client;
+    if (!client) {
+      throw new ClientStateError6("Client not ready");
+    }
+    if (isRegistering.value) {
+      return;
+    }
+    phase.value = "checking-alias";
+    error.value = null;
+    result.value = null;
+    identity.value = null;
+    isRegistering.value = true;
+    steps.value = STEP_LABELS.map((label) => ({ label, status: "pending" }));
+    async function stepCheckAlias(sdk, rawAlias) {
+      updateStep(0, "active");
+      const normalized = rawAlias.trim().toLowerCase();
+      const aliasHash = await sdk.computeAliasHash(normalized);
+      const aliasResult = await sdk.lookupAlias(aliasHash);
+      if (aliasResult.found) {
+        throw new HyperAuthError5(`"${normalized}" is already taken`);
+      }
+      updateStep(0, "done", "Available");
+      return normalized;
+    }
+    async function stepCreatePasskey(sdk, normalized) {
+      updateStep(1, "active");
+      const created = await sdk.createPasskey(normalized);
+      updateStep(1, "done", "Created");
+      return created;
+    }
+    async function stepGenerateIdentity(credential, normalized) {
+      updateStep(2, "active");
+      const genResult = await client.generate(credential, { identifier: normalized });
+      const { did, address: ethAddress, shares } = genResult;
+      const publicKey = typeof shares.public_key === "string" ? shares.public_key : "";
+      const publicKeyHex = shares.public_key_hex ?? publicKey;
+      const pubkeyX = shares.pubkey_x ?? "";
+      const pubkeyY = shares.pubkey_y ?? "";
+      updateStep(2, "done", "Generated");
+      return {
+        did,
+        enclaveId: shares.enclave_id,
+        publicKey,
+        shares,
+        publicKeyHex,
+        pubkeyX,
+        pubkeyY,
+        ethAddress
+      };
+    }
+    async function stepPredictAccount(publicKeyHex) {
+      updateStep(3, "active");
+      let smartAccountAddress = "";
+      if (publicKeyHex) {
+        const derived = await client.deriveAddress(publicKeyHex, "ethereum");
+        smartAccountAddress = derived.address;
+      }
+      updateStep(3, "done", smartAccountAddress ? "Predicted" : "Skipped");
+      return smartAccountAddress;
+    }
+    async function stepFetchAccountState(sdk, smartAccountAddress) {
+      updateStep(4, "active");
+      let accountNonce = "0x0";
+      let accountIsActive = false;
+      if (smartAccountAddress) {
+        const state = await sdk.getAccountState({ account: smartAccountAddress });
+        accountNonce = state.nonce || "0x0";
+        accountIsActive = state.isActive;
+      }
+      updateStep(4, "done", "Ready");
+      return { accountNonce, accountIsActive };
+    }
+    async function stepPrepareUserOp(sdk, viem, params) {
+      updateStep(5, "active");
+      const {
+        smartAccountAddress,
+        pubkeyX,
+        pubkeyY,
+        did,
+        normalized,
+        accountNonce,
+        accountIsActive
+      } = params;
+      if (!smartAccountAddress) {
+        throw new HyperAuthError5("Unable to derive smart account address");
+      }
+      if (!pubkeyX || !pubkeyY) {
+        throw new HyperAuthError5("Missing public key coordinates for account creation");
+      }
+      const { encodeFunctionData, keccak256, toHex } = viem;
+      const {
+        computeAliasHash,
+        defaultContracts,
+        didRegistryAbi,
+        hyperAuthAccountAbi,
+        hyperAuthFactoryAbi
+      } = sdk;
+      const aliasDigest = await computeAliasHash(normalized);
+      const didHash = keccak256(toHex(did));
+      const metadataCid = "";
+      const registerCall = encodeFunctionData({
+        abi: didRegistryAbi,
+        functionName: "register",
+        args: [didHash, aliasDigest, metadataCid]
+      });
+      const callData = encodeFunctionData({
+        abi: hyperAuthAccountAbi,
+        functionName: "execute",
+        args: [defaultContracts.didRegistry, 0n, registerCall]
+      });
+      const factoryData = encodeFunctionData({
+        abi: hyperAuthFactoryAbi,
+        functionName: "createAccount",
+        args: [BigInt(`0x${pubkeyX}`), BigInt(`0x${pubkeyY}`), 0n]
+      });
+      const userOp = {
+        sender: smartAccountAddress,
+        nonce: accountNonce,
+        factory: accountIsActive ? null : defaultContracts.hyperAuthFactory,
+        factoryData: accountIsActive ? null : factoryData,
+        callData,
+        callGasLimit: DEFAULT_CALL_GAS2,
+        verificationGasLimit: DEFAULT_VERIFICATION_GAS2,
+        preVerificationGas: DEFAULT_PRE_VERIFICATION_GAS2,
+        maxFeePerGas: DEFAULT_MAX_FEE_PER_GAS2,
+        maxPriorityFeePerGas: DEFAULT_MAX_PRIORITY_FEE_PER_GAS2,
+        paymaster: null,
+        paymasterVerificationGasLimit: null,
+        paymasterPostOpGasLimit: null,
+        paymasterData: null,
+        signature: "0x"
+      };
+      updateStep(5, "done", "Prepared");
+      return userOp;
+    }
+    async function stepSponsorUserOp(sdk, userOp, entryPoint) {
+      updateStep(6, "active");
+      const sponsoredOp = await sdk.sponsorUserOp(userOp, entryPoint);
+      updateStep(6, "done", "Fees covered");
+      return sponsoredOp;
+    }
+    function stepAuthorize(did) {
+      updateStep(7, "active");
+      updateStep(7, "done", "Authorized");
+      return did;
+    }
+    async function stepSignUserOp(sdk, params) {
+      updateStep(8, "active");
+      const { shares, sponsoredOp, entryPoint, chainId } = params;
+      if (!shares) {
+        throw new HyperAuthError5("Missing encrypted shares from generate() result");
+      }
+      const hashToSign = await sdk.computeUserOpHash(sponsoredOp, entryPoint, chainId);
+      const signResult = await client.sign(shares, Array.from(sdk.hexToBytes(hashToSign)));
+      const signedOp = {
+        ...sponsoredOp,
+        signature: sdk.bytesToHex(new Uint8Array(signResult.signature))
+      };
+      updateStep(8, "done", "Signed");
+      return signedOp;
+    }
+    async function stepSubmitUserOp(sdk, signedOp, entryPoint) {
+      updateStep(9, "active");
+      const userOpHash = await sdk.sendUserOp(signedOp, entryPoint);
+      updateStep(9, "done", "Submitted");
+      return userOpHash;
+    }
+    async function stepWaitForConfirmation(sdk, userOpHash) {
+      updateStep(10, "active");
+      const receipt = await sdk.waitForReceipt(userOpHash);
+      const txHash = receipt.receipt.transactionHash;
+      const blockNum = typeof receipt.receipt.blockNumber === "string" ? parseInt(receipt.receipt.blockNumber, 16) : typeof receipt.receipt.blockNumber === "number" ? receipt.receipt.blockNumber : null;
+      updateStep(10, "done", "Confirmed");
+      return { txHash, blockNum };
+    }
+    async function stepSaveSession(normalized, did) {
+      updateStep(11, "active");
+      try {
+        await fetch("/api/sessions", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ name: normalized, did })
+        });
+      } catch {}
+      updateStep(11, "done", "Saved");
+    }
+    try {
+      const [sdk, viem] = await Promise.all([importSdk(), importViem()]);
+      const normalized = await stepCheckAlias(sdk, alias);
+      phase.value = "creating-passkey";
+      const { credential, credentialId } = await stepCreatePasskey(sdk, normalized);
+      phase.value = "generating-identity";
+      const {
+        did,
+        enclaveId,
+        publicKey,
+        shares,
+        publicKeyHex,
+        pubkeyX,
+        pubkeyY,
+        ethAddress
+      } = await stepGenerateIdentity(credential, normalized);
+      phase.value = "predicting-account";
+      const smartAccountAddress = await stepPredictAccount(publicKeyHex);
+      phase.value = "fetching-account-state";
+      identity.value = {
+        did,
+        enclaveId,
+        publicKey,
+        pubkeyX,
+        pubkeyY,
+        ethAddress,
+        smartAccountAddress,
+        credentialId,
+        publicKeyHex,
+        encryptedShares: shares
+      };
+      const { accountNonce, accountIsActive } = await stepFetchAccountState(sdk, smartAccountAddress);
+      phase.value = "creating-registration";
+      const userOp = await stepPrepareUserOp(sdk, viem, {
+        smartAccountAddress,
+        pubkeyX,
+        pubkeyY,
+        did,
+        normalized,
+        accountNonce,
+        accountIsActive
+      });
+      phase.value = "sponsoring";
+      const entryPoint = sdk.defaultContracts.entryPoint;
+      const sponsoredOp = await stepSponsorUserOp(sdk, userOp, entryPoint);
+      phase.value = "authorizing";
+      stepAuthorize(did);
+      phase.value = "signing";
+      const signedOp = await stepSignUserOp(sdk, {
+        shares,
+        sponsoredOp,
+        entryPoint,
+        chainId: sdk.defaultContracts.chainId
+      });
+      phase.value = "submitting";
+      const userOpHash = await stepSubmitUserOp(sdk, signedOp, entryPoint);
+      phase.value = "confirming";
+      const { txHash, blockNum } = await stepWaitForConfirmation(sdk, userOpHash);
+      phase.value = "storing-session";
+      await stepSaveSession(normalized, did);
+      result.value = {
+        did,
+        txHash,
+        blockNumber: blockNum,
+        smartAccount: smartAccountAddress
+      };
+      phase.value = "complete";
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      error.value = msg;
+      phase.value = "error";
+      steps.value = steps.value.map((step) => step.status === "active" ? { ...step, status: "error", detail: msg } : step);
+    } finally {
+      isRegistering.value = false;
+    }
+  }
+  return {
+    phase,
+    steps,
+    identity,
+    result,
+    error,
+    isRegistering: computed6(() => isRegistering.value),
+    register,
+    reset
+  };
+}
+// src/use-signer.ts
+import { onScopeDispose as onScopeDispose2, ref as ref2, watch as watch2 } from "vue";
+import {
+  createSignerBridge
+} from "@hyperauth/client";
+function useSigner(options) {
+  const signer = ref2(null);
+  const ready = ref2(false);
+  const error = ref2(null);
+  let dispose = null;
+  let cancelled = false;
+  const wasmUrl = options?.wasmUrl;
+  watch2(() => wasmUrl, () => {
+    dispose?.();
+    dispose = null;
+    cancelled = false;
+    signer.value = null;
+    ready.value = false;
+    error.value = null;
+    createSignerBridge(options).then((handle) => {
+      if (cancelled) {
+        handle.dispose();
+        return;
+      }
+      dispose = handle.dispose;
+      signer.value = handle.signer;
+      ready.value = true;
+    }).catch((err) => {
+      if (cancelled)
+        return;
+      error.value = err instanceof Error ? err : new Error(String(err));
+    });
+  }, { immediate: true });
+  onScopeDispose2(() => {
+    cancelled = true;
+    dispose?.();
+    dispose = null;
+  });
+  return { signer, ready, error };
+}
+// src/use-policy-mint.ts
+import { computed as computed7, ref as ref3 } from "vue";
+var DEFAULT_AUDIENCE = "did:web:hyperauth.org";
+var DEFAULT_EXPIRY_SECONDS = 60 * 60 * 24 * 365;
+function usePolicyMint(options = {}) {
+  const { signer, ready, error: signerError } = useSigner({ wasmUrl: options.wasmUrl });
+  const status = ref3("idle");
+  const token = ref3(null);
+  const payload = ref3(null);
+  const error = ref3(null);
+  let demoIdentity = null;
+  async function mint(params) {
+    if (!signer.value) {
+      throw new Error("signer is not ready yet — wait for `ready` before calling mint()");
+    }
+    status.value = "minting";
+    error.value = null;
+    token.value = null;
+    payload.value = null;
+    try {
+      if (!demoIdentity) {
+        demoIdentity = await generateDemoIdentity(signer.value);
+      }
+      const { did, shares } = demoIdentity;
+      const builtPayload = await buildPolicyPayload(did, params, options);
+      payload.value = builtPayload;
+      const result = await signer.value.mintUcan(shares, builtPayload);
+      token.value = formatJwtStyle(builtPayload, result.signed_dag_cbor);
+      status.value = "minted";
+    } catch (err) {
+      const wrapped = err instanceof Error ? err : new Error(String(err));
+      error.value = wrapped;
+      status.value = "error";
+    }
+  }
+  function reset() {
+    status.value = "idle";
+    token.value = null;
+    payload.value = null;
+    error.value = null;
+  }
+  return {
+    mint,
+    reset,
+    status,
+    token,
+    payload,
+    error: computed7(() => error.value ?? signerError.value),
+    ready
+  };
+}
+var BASE58_ALPHABET2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58btcEncode(bytes) {
+  const digits = [0];
+  for (const byte of bytes) {
+    let carry = byte;
+    for (let i = 0;i < digits.length; i++) {
+      carry += (digits[i] ?? 0) << 8;
+      digits[i] = carry % 58;
+      carry = Math.floor(carry / 58);
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = Math.floor(carry / 58);
+    }
+  }
+  let result = "";
+  for (let i = bytes.length - 1;i >= 0 && bytes[i] === 0; i--)
+    result += "1";
+  for (let i = digits.length - 1;i >= 0; i--)
+    result += BASE58_ALPHABET2[digits[i] ?? 0];
+  return result;
+}
+function base64UrlEncode(bytes) {
+  const str = typeof bytes === "string" ? bytes : String.fromCharCode(...bytes);
+  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function generateDemoIdentity(signer) {
+  const result = await signer.generate();
+  const pubBytes = hexToBytes(result.public_key_hex);
+  const prefix = new Uint8Array([231, 1]);
+  const multikey = new Uint8Array(prefix.length + pubBytes.length);
+  multikey.set(prefix);
+  multikey.set(pubBytes, prefix.length);
+  const did = `did:key:z${base58btcEncode(multikey)}`;
+  const shares = {
+    public_key: result.public_key,
+    public_key_hex: result.public_key_hex,
+    val_share: result.val_share,
+    user_share: result.user_share,
+    nonce: result.nonce,
+    curve: result.curve
+  };
+  return { did, shares };
+}
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const out = new Uint8Array(clean.length / 2);
+  for (let i = 0;i < out.length; i++) {
+    out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+async function buildPolicyPreview(params, options = {}) {
+  return buildPolicyPayload("did:key:<pending>", params, options);
+}
+async function buildPolicyPayload(did, params, options) {
+  const now = Math.floor(Date.now() / 1000);
+  const exp = now + (options.expirySeconds ?? DEFAULT_EXPIRY_SECONDS);
+  const policyId = await hashPolicyId(params);
+  const nnc = generateNonce();
+  return {
+    iss: did,
+    aud: options.audience ?? DEFAULT_AUDIENCE,
+    exp,
+    cap: [{ with: `hyperauth://policy/${policyId}`, can: "policy/issue" }],
+    fct: [
+      {
+        "hyperauth/policy": {
+          origins: params.origins,
+          chain_id: params.chainId,
+          paymaster: params.paymaster,
+          max_fee_per_user_usd: params.maxFeePerUserUsd
+        }
+      }
+    ],
+    prf: [],
+    nnc
+  };
+}
+async function hashPolicyId(params) {
+  const text = JSON.stringify({
+    origins: [...params.origins].sort(),
+    chain_id: params.chainId,
+    paymaster: params.paymaster.toLowerCase(),
+    max_fee_per_user_usd: params.maxFeePerUserUsd
+  });
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return base32EncodeFirstBytes(new Uint8Array(digest), 16);
+}
+function base32EncodeFirstBytes(bytes, byteCount) {
+  const ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+  let result = "";
+  let bits = 0;
+  let value = 0;
+  const slice2 = bytes.slice(0, byteCount);
+  for (const byte of slice2) {
+    value = value << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      result += ALPHA[value >> bits & 31];
+    }
+  }
+  if (bits > 0) {
+    result += ALPHA[value << 5 - bits & 31];
+  }
+  return result;
+}
+function generateNonce() {
+  const bytes = new Uint8Array(12);
+  crypto.getRandomValues(bytes);
+  return base64UrlEncode(bytes);
+}
+function formatJwtStyle(payload, signatureCborB64Std) {
+  const header = base64UrlEncode(JSON.stringify({ alg: "ES256", typ: "UCAN" }));
+  const payloadEnc = base64UrlEncode(JSON.stringify(payload));
+  const sig = base64StdToUrl(signatureCborB64Std);
+  return `${header}.${payloadEnc}.${sig}`;
+}
+function base64StdToUrl(b64std) {
+  return b64std.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+// src/use-policy-verify.ts
+import { computed as computed8, ref as ref4 } from "vue";
+function usePolicyVerify(options = {}) {
+  const { signer, ready, error: signerError } = useSigner({ wasmUrl: options.wasmUrl });
+  const status = ref4("idle");
+  const parsed = ref4(null);
+  const signatureValid = ref4(null);
+  const ownError = ref4(null);
+  async function verify(rawToken) {
+    status.value = "verifying";
+    parsed.value = null;
+    signatureValid.value = null;
+    ownError.value = null;
+    let token;
+    try {
+      token = parsePolicyToken(rawToken);
+    } catch (err) {
+      const wrapped = err instanceof PolicyTokenParseError ? err : err instanceof Error ? err : new Error(String(err));
+      ownError.value = wrapped;
+      status.value = "error";
+      return;
+    }
+    parsed.value = token;
+    if (!signer.value) {
+      ownError.value = new Error("signer is not ready yet — wait for `ready` before calling verify()");
+      status.value = "error";
+      return;
+    }
+    try {
+      const result = await signer.value.verify({
+        public_key_hex: token.publicKeyHex,
+        data: token.signedBytes,
+        signature: token.signature
+      });
+      signatureValid.value = result.valid;
+      status.value = result.valid ? "valid" : "invalid";
+    } catch (err) {
+      const wrapped = err instanceof Error ? err : new Error(String(err));
+      ownError.value = wrapped;
+      status.value = "error";
+    }
+  }
+  function reset() {
+    status.value = "idle";
+    parsed.value = null;
+    signatureValid.value = null;
+    ownError.value = null;
+  }
+  return {
+    verify,
+    reset,
+    status,
+    parsed,
+    signatureValid,
+    error: computed8(() => ownError.value ?? signerError.value),
+    ready
+  };
+}
+// src/ui/button.ts
+import { defineComponent, h } from "vue";
+var Button = defineComponent({
+  name: "HyperAuthButton",
+  props: {
+    loading: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false },
+    type: { type: String, default: "button" }
+  },
+  setup(props, { slots, attrs }) {
+    return () => h("button", {
+      ...attrs,
+      type: props.type,
+      disabled: props.disabled || props.loading,
+      "data-loading": props.loading ? "true" : undefined,
+      "aria-busy": props.loading || undefined
+    }, props.loading && slots.loading ? slots.loading() : slots.default?.());
+  }
+});
+// src/ui/modal.ts
+import {
+  defineComponent as defineComponent2,
+  h as h2,
+  inject as inject2,
+  onMounted,
+  onUnmounted,
+  provide,
+  ref as ref5,
+  useId
+} from "vue";
+var ModalContextKey = Symbol("HyperAuthModal");
+function useModalContext(consumer) {
+  const ctx = inject2(ModalContextKey);
+  if (!ctx) {
+    throw new Error(`${consumer} must be used inside a <Modal>`);
+  }
+  return ctx;
+}
+var Modal = defineComponent2({
+  name: "HyperAuthModal",
+  props: {
+    open: { type: Boolean, required: true },
+    modal: { type: Boolean, default: true }
+  },
+  emits: ["update:open"],
+  setup(props, { slots, emit }) {
+    const titleId = useId();
+    const openRef = ref5(props.open);
+    const ctx = {
+      open: openRef,
+      onOpenChange: (next) => emit("update:open", next),
+      titleId
+    };
+    provide(ModalContextKey, ctx);
+    function onKey(e) {
+      if (e.key === "Escape" && props.modal)
+        ctx.onOpenChange(false);
+    }
+    let prevOverflow = "";
+    onMounted(() => {
+      if (!isBrowser())
+        return;
+      window.addEventListener("keydown", onKey);
+    });
+    onUnmounted(() => {
+      if (!isBrowser())
+        return;
+      window.removeEventListener("keydown", onKey);
+      document.body.style.overflow = prevOverflow;
+    });
+    return () => {
+      openRef.value = props.open;
+      if (isBrowser() && props.modal) {
+        if (props.open) {
+          prevOverflow = document.body.style.overflow;
+          document.body.style.overflow = "hidden";
+        } else {
+          document.body.style.overflow = prevOverflow;
+        }
+      }
+      if (!props.open)
+        return null;
+      return slots.default?.();
+    };
+  }
+});
+var ModalBackdrop = defineComponent2({
+  name: "HyperAuthModalBackdrop",
+  setup(_, { attrs }) {
+    const ctx = useModalContext("ModalBackdrop");
+    return () => h2("div", {
+      "data-hyperauth-modal-backdrop": "",
+      ...attrs,
+      onClick: (e) => {
+        attrs.onClick?.(e);
+        if (!e.defaultPrevented)
+          ctx.onOpenChange(false);
+      }
+    });
+  }
+});
+var ModalContent = defineComponent2({
+  name: "HyperAuthModalContent",
+  setup(_, { slots, attrs }) {
+    const ctx = useModalContext("ModalContent");
+    const rootRef = ref5(null);
+    let prevActive = null;
+    onMounted(() => {
+      if (!isBrowser())
+        return;
+      prevActive = document.activeElement;
+      const focusable = rootRef.value?.querySelector('a[href],button:not([disabled]),textarea,input,select,[tabindex]:not([tabindex="-1"])');
+      focusable?.focus();
+    });
+    onUnmounted(() => {
+      prevActive?.focus?.();
+    });
+    return () => h2("div", {
+      ref: rootRef,
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-labelledby": ctx.titleId,
+      ...attrs
+    }, slots.default?.());
+  }
+});
+var ModalClose = defineComponent2({
+  name: "HyperAuthModalClose",
+  setup(_, { slots, attrs }) {
+    const ctx = useModalContext("ModalClose");
+    return () => h2("button", {
+      type: "button",
+      ...attrs,
+      onClick: (e) => {
+        attrs.onClick?.(e);
+        if (!e.defaultPrevented)
+          ctx.onOpenChange(false);
+      }
+    }, slots.default?.());
+  }
+});
+// src/ui/settlement-progress.ts
+import { defineComponent as defineComponent3, h as h3 } from "vue";
+var SettlementProgress = defineComponent3({
+  name: "HyperAuthSettlementProgress",
+  setup(_, { slots, attrs }) {
+    const settlement = useSettlement();
+    return () => {
+      const snapshot = {
+        steps: settlement.steps.value,
+        phase: settlement.phase.value,
+        error: settlement.error.value,
+        txHash: settlement.txHash.value
+      };
+      if (slots.default) {
+        return slots.default(snapshot);
+      }
+      return h3("ol", {
+        "data-hyperauth-settlement-progress": "",
+        "data-phase": snapshot.phase,
+        ...attrs
+      }, [
+        ...snapshot.steps.map((step) => h3("li", {
+          key: step.phase,
+          "data-hyperauth-settlement-step": step.phase,
+          "data-status": step.status
+        }, [
+          h3("span", step.label),
+          step.detail ? h3("span", { "data-detail": "" }, step.detail) : null
+        ])),
+        snapshot.error ? h3("li", { "data-hyperauth-settlement-error": "" }, snapshot.error) : null
+      ]);
+    };
+  }
+});
+// src/csp.ts
+var cspManifest = {
+  "worker-src": ["'self'", "blob:"],
+  "script-src": ["'self'", "'wasm-unsafe-eval'"],
+  "connect-src": [
+    "'self'",
+    "https://*.hyperauth.io",
+    "https://*.hyperauth.dev",
+    "https://*.pimlico.io",
+    "wss://*.hyperauth.io",
+    "https://api.transak.com",
+    "https://api.sardine.ai"
+  ],
+  "frame-src": ["'self'", "https://*.hyperauth.io"],
+  "img-src": ["'self'", "data:", "blob:"]
+};
+function cspManifestString() {
+  return Object.entries(cspManifest).map(([directive, values]) => `${directive} ${values.join(" ")}`).join("; ");
+}
+export {
+  useTransaction,
+  useSigner,
+  useSettlement,
+  useSession,
+  useRegistration,
+  usePolicyVerify,
+  usePolicyMint,
+  useLogin,
+  useHyperAuth,
+  useAccount,
+  txExplorerUrl,
+  parsePolicyToken,
+  mountIframeBridge,
+  isPolicyExpired,
+  isOriginAllowedByFacts,
+  getPolicyFacts,
+  explorerUrls,
+  cspManifestString,
+  cspManifest,
+  createHyperAuth,
+  chainIds,
+  buildPolicyPreview,
+  SettlementProgress,
+  PolicyTokenParseError,
+  ModalContent,
+  ModalClose,
+  ModalBackdrop,
+  Modal,
+  HyperAuthKey,
+  Button
+};
+
+//# debugId=CE8BD49C130B65B564756E2164756E21