@manifoldxyz/dropkit 0.2.0 → 0.3.0

package/dist/cart.cjs

@@ -0,0 +1,1832 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkOO6QQT3Mcjs = require('./chunk-OO6QQT3M.cjs');
+
+// src/cart/react.ts
+var _react = require('react');
+
+// src/cart/errors.ts
+var CartError = class extends Error {
+  
+  constructor(reason, message, opts) {
+    super(message, _optionalChain([opts, 'optionalAccess', _ => _.cause]) === void 0 ? void 0 : { cause: opts.cause });
+    this.name = "CartError";
+    this.reason = reason;
+  }
+};
+function cartReason(e) {
+  if (e instanceof CartError) return { reason: e.reason, message: e.message };
+  if (_chunkOO6QQT3Mcjs.isMintError.call(void 0, e)) return _chunkOO6QQT3Mcjs.toReason.call(void 0, e);
+  return _chunkOO6QQT3Mcjs.toReason.call(void 0, e);
+}
+
+// src/cart/line.ts
+var _viem = require('viem');
+var isUnsupportedReason = (r) => _chunkOO6QQT3Mcjs.UNSUPPORTED_REASONS.includes(r);
+function deriveLine(args) {
+  const { drop, walletRead, readError, now, pending, walletConnected } = args;
+  const out = (state, reason = null, message = null) => ({ state, reason, message });
+  if (pending) return out("locked");
+  if (drop !== null && drop.paymentToken !== null) {
+    return out("unsupported", "CART_ERC20_UNSUPPORTED", "This item is priced in a token. The cart takes only items priced in the chain's native token.");
+  }
+  if (readError && isUnsupportedReason(readError.reason)) return out("unsupported", readError.reason, readError.message);
+  if (readError) return out("error", readError.reason, readError.message);
+  if (drop === null) return out("loading");
+  if (walletConnected && walletRead === null) return out("loading");
+  if (drop.endTime !== null && drop.endTime <= now) return out("ended");
+  if (drop.maxSupply !== null && drop.maxSupply > 0n && drop.totalMinted >= drop.maxSupply) return out("sold-out");
+  if (drop.startTime !== null && drop.startTime > now) return out("upcoming");
+  if (_optionalChain([walletRead, 'optionalAccess', _2 => _2.ineligible])) return out("ineligible", walletRead.ineligible.reason, walletRead.ineligible.message);
+  return out("live");
+}
+function lineMaxQuantity(drop, walletRead) {
+  if (drop === null) return null;
+  let max = null;
+  if (drop.maxSupply !== null && drop.maxSupply > 0n) {
+    const left = drop.maxSupply - drop.totalMinted;
+    max = left > 0n ? left < BigInt(_chunkOO6QQT3Mcjs.MAX_QUANTITY) ? Number(left) : _chunkOO6QQT3Mcjs.MAX_QUANTITY : 0;
+  }
+  if (walletRead !== null && walletRead.maxQuantity !== null) {
+    const cap = Math.max(0, Math.floor(walletRead.maxQuantity));
+    max = max === null ? cap : Math.min(max, cap);
+  }
+  return max;
+}
+var money = (value, like) => ({ value, decimals: like.decimals, symbol: like.symbol, formatted: _viem.formatUnits.call(void 0, value, like.decimals) });
+function lineTotal(drop, quantity) {
+  if (drop === null || drop.paymentToken !== null) return null;
+  const q = BigInt(quantity);
+  return money((drop.unitPrice.value + drop.unitFee.value) * q, drop.unitPrice);
+}
+function sumMoney(parts, like) {
+  return money(parts.reduce((a, m) => a + m.value, 0n), like);
+}
+
+// src/cart/reads.ts
+function sharedReadClient(raw) {
+  let epoch = 0;
+  const forever = /* @__PURE__ */ new Map();
+  const perEpoch = /* @__PURE__ */ new Map();
+  const memo = (cache, key, load) => {
+    const hit = cache.get(key);
+    if (hit) return hit;
+    const p = load();
+    cache.set(key, p);
+    p.catch(() => {
+      if (cache.get(key) === p) cache.delete(key);
+    });
+    return p;
+  };
+  const chainId = () => _nullishCoalesce(_optionalChain([raw, 'access', _3 => _3.chain, 'optionalAccess', _4 => _4.id]), () => ( 0));
+  const overrides = {
+    getCode: (args) => {
+      const address = args.address.toLowerCase();
+      if (_chunkOO6QQT3Mcjs.findExtension.call(void 0, chainId(), address)) return memo(forever, `code:${address}`, () => raw.getCode(args));
+      return raw.getCode(args);
+    },
+    readContract: (args) => {
+      if (args.functionName === "MINT_FEE" || args.functionName === "MINT_FEE_MERKLE") {
+        return memo(forever, `fee:${args.address.toLowerCase()}:${args.functionName}`, () => raw.readContract(args));
+      }
+      return raw.readContract(args);
+    },
+    getGasPrice: () => memo(perEpoch, `gas:${String(epoch)}`, () => raw.getGasPrice()),
+    getBalance: (args) => memo(perEpoch, `bal:${String(epoch)}:${args.address.toLowerCase()}`, () => raw.getBalance(args))
+  };
+  const client = new Proxy(raw, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string" && prop in overrides) return overrides[prop];
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  return {
+    client,
+    bump: () => {
+      epoch += 1;
+      perEpoch.clear();
+    }
+  };
+}
+var Limiter = (_class = class {
+  constructor(limit) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.limit = limit;
+  }
+  
+  __init() {this.running = 0}
+  __init2() {this.queue = []}
+  async run(task) {
+    if (this.running >= this.limit()) await new Promise((resolve) => this.queue.push(resolve));
+    this.running += 1;
+    try {
+      return await task();
+    } finally {
+      this.running -= 1;
+      _optionalChain([this, 'access', _5 => _5.queue, 'access', _6 => _6.shift, 'call', _7 => _7(), 'optionalCall', _8 => _8()]);
+    }
+  }
+}, _class);
+var sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (_optionalChain([signal, 'optionalAccess', _9 => _9.aborted])) return reject(signal.reason);
+  const t = setTimeout(() => {
+    _optionalChain([signal, 'optionalAccess', _10 => _10.removeEventListener, 'call', _11 => _11("abort", onAbort)]);
+    resolve();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(t);
+    reject(_optionalChain([signal, 'optionalAccess', _12 => _12.reason]));
+  };
+  _optionalChain([signal, 'optionalAccess', _13 => _13.addEventListener, 'call', _14 => _14("abort", onAbort, { once: true })]);
+});
+function rateLimitedFetch(base, perMinute) {
+  const starts = [];
+  const target = _nullishCoalesce(base, () => ( ((input, init) => globalThis.fetch(input, init))));
+  return (async (input, init) => {
+    for (; ; ) {
+      const now = Date.now();
+      while (starts.length && now - starts[0] >= 6e4) starts.shift();
+      if (starts.length < perMinute()) break;
+      await sleep(6e4 - (now - starts[0]) + 5, _nullishCoalesce(_optionalChain([init, 'optionalAccess', _15 => _15.signal]), () => ( void 0)));
+    }
+    starts.push(Date.now());
+    return target(input, init);
+  });
+}
+
+// src/cart/run.ts
+
+
+// src/cart/store.ts
+
+var CART_VALUE_VERSION = 6;
+var defaultStorageKey = (chainId) => `dropkit-cart:${String(chainId)}`;
+function itemKey(config) {
+  return `${String(config.chainId)}:${_viem.getAddress.call(void 0, config.creatorContract)}:${BigInt(config.instanceId).toString()}:${_viem.getAddress.call(void 0, config.extension)}`;
+}
+function canonicalConfig(config, chainId) {
+  const c = _nullishCoalesce(config, () => ( {}));
+  if (c.type !== "manifold-claim") {
+    throw new (0, _chunkOO6QQT3Mcjs.MintError)("INVALID_CONFIG", 'The cart takes only Manifold claims (type: "manifold-claim").', { field: "type" });
+  }
+  if (c.chainId !== chainId) {
+    throw new (0, _chunkOO6QQT3Mcjs.MintError)("INVALID_CONFIG", `This cart is on chain ${String(chainId)}; the config is on chain ${String(c.chainId)}.`, { field: "chainId" });
+  }
+  if (typeof c.creatorContract !== "string" || !_viem.isAddress.call(void 0, c.creatorContract, { strict: false })) {
+    throw new (0, _chunkOO6QQT3Mcjs.MintError)("INVALID_CONFIG", "creatorContract is not a valid address.", { field: "creatorContract" });
+  }
+  if (typeof c.extension !== "string" || !_viem.isAddress.call(void 0, c.extension, { strict: false })) {
+    throw new (0, _chunkOO6QQT3Mcjs.MintError)("INVALID_CONFIG", "Cart configs must set extension (the claim extension address).", { field: "extension" });
+  }
+  if (typeof c.instanceId !== "string" || !/^\d+$/.test(c.instanceId)) {
+    throw new (0, _chunkOO6QQT3Mcjs.MintError)("INVALID_CONFIG", "instanceId must be a non-negative integer string.", { field: "instanceId" });
+  }
+  return {
+    type: "manifold-claim",
+    chainId,
+    creatorContract: _viem.getAddress.call(void 0, c.creatorContract),
+    instanceId: BigInt(c.instanceId).toString(),
+    extension: _viem.getAddress.call(void 0, c.extension)
+  };
+}
+var clampQuantity = (q) => Math.max(1, Math.min(Math.floor(Number.isFinite(q) ? q : 1), _chunkOO6QQT3Mcjs.MAX_QUANTITY));
+var EMPTY_VALUE = (chainId) => ({ v: CART_VALUE_VERSION, chainId, items: [], pending: [], results: [] });
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isHash = (v) => typeof v === "string" && /^0x[0-9a-fA-F]{64}$/.test(v);
+var isAddr = (v) => typeof v === "string" && _viem.isAddress.call(void 0, v, { strict: false });
+var isIntStr = (v) => typeof v === "string" && /^\d+$/.test(v);
+var isQuantity = (v) => typeof v === "number" && Number.isInteger(v) && v >= 1 && v <= _chunkOO6QQT3Mcjs.MAX_QUANTITY;
+function restoreConfig(v, chainId) {
+  try {
+    return canonicalConfig(v, chainId);
+  } catch (e2) {
+    return null;
+  }
+}
+function restoreHoldings(v) {
+  if (!isRecord(v) || !isIntStr(v.before)) return null;
+  if (v.kind === "total-mints" && isAddr(v.extension) && isAddr(v.creatorContract) && isIntStr(v.instanceId)) {
+    return { kind: "total-mints", extension: _viem.getAddress.call(void 0, v.extension), creatorContract: _viem.getAddress.call(void 0, v.creatorContract), instanceId: v.instanceId, before: v.before };
+  }
+  if (v.kind === "balance-1155" && isAddr(v.creatorContract) && isIntStr(v.tokenId)) {
+    return { kind: "balance-1155", creatorContract: _viem.getAddress.call(void 0, v.creatorContract), tokenId: v.tokenId, before: v.before };
+  }
+  if (v.kind === "balance-721" && isAddr(v.creatorContract)) {
+    return { kind: "balance-721", creatorContract: _viem.getAddress.call(void 0, v.creatorContract), before: v.before };
+  }
+  return null;
+}
+function restorePending(v, chainId) {
+  if (!isRecord(v)) return null;
+  const config = restoreConfig(v.config, chainId);
+  const holdings = restoreHoldings(v.holdings);
+  if (!config || !holdings) return null;
+  if (typeof v.id !== "string" || typeof v.lineKey !== "string" || !isAddr(v.payer) || !isAddr(v.recipient) || !isQuantity(v.quantity)) return null;
+  if (v.hash !== null && !isHash(v.hash)) return null;
+  if (v.hashAt !== null && typeof v.hashAt !== "number") return null;
+  if (typeof v.createdAt !== "number") return null;
+  return {
+    id: v.id,
+    lineKey: v.lineKey,
+    config,
+    payer: _viem.getAddress.call(void 0, v.payer),
+    recipient: _viem.getAddress.call(void 0, v.recipient),
+    quantity: v.quantity,
+    holdings,
+    hash: v.hash,
+    hashAt: v.hashAt,
+    createdAt: v.createdAt
+  };
+}
+function restoreResult(v, chainId) {
+  if (!isRecord(v)) return null;
+  const config = restoreConfig(v.config, chainId);
+  const holdings = restoreHoldings(v.holdings);
+  if (!config || !holdings) return null;
+  if (typeof v.id !== "string" || typeof v.lineKey !== "string" || !isAddr(v.payer) || !isAddr(v.recipient) || !isQuantity(v.quantity)) return null;
+  if (v.status !== "collected" && v.status !== "unconfirmed") return null;
+  if (v.txHash !== null && !isHash(v.txHash)) return null;
+  if (typeof v.at !== "number") return null;
+  if (!Array.isArray(v.tokens)) return null;
+  const tokens = [];
+  for (const t of v.tokens) {
+    if (!isRecord(t) || !isAddr(t.contract) || typeof t.tokenId !== "string" || !/^\d+$/.test(t.tokenId)) return null;
+    tokens.push({ contract: _viem.getAddress.call(void 0, t.contract), tokenId: t.tokenId });
+  }
+  return { id: v.id, status: v.status, lineKey: v.lineKey, config, payer: _viem.getAddress.call(void 0, v.payer), recipient: _viem.getAddress.call(void 0, v.recipient), quantity: v.quantity, holdings, txHash: v.txHash, tokens, at: v.at };
+}
+function restoreValue(raw, chainId) {
+  if (raw === null) return { value: EMPTY_VALUE(chainId), lock: null };
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e3) {
+    return { value: EMPTY_VALUE(chainId), lock: null };
+  }
+  if (!isRecord(parsed) || parsed.v !== CART_VALUE_VERSION) return { value: EMPTY_VALUE(chainId), lock: null };
+  if (parsed.chainId !== chainId) return { value: EMPTY_VALUE(chainId), lock: "foreign" };
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const it of Array.isArray(parsed.items) ? parsed.items : []) {
+    if (!isRecord(it)) continue;
+    const config = restoreConfig(it.config, chainId);
+    if (!config || !isQuantity(it.quantity)) continue;
+    const key = itemKey(config);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    items.push({ config, quantity: it.quantity });
+  }
+  let lock = null;
+  const pending = [];
+  for (const p of Array.isArray(parsed.pending) ? parsed.pending : []) {
+    const r = restorePending(p, chainId);
+    if (r) pending.push(r);
+    else lock = "corrupt";
+  }
+  const results = [];
+  for (const p of Array.isArray(parsed.results) ? parsed.results : []) {
+    const r = restoreResult(p, chainId);
+    if (r) results.push(r);
+    else lock = "corrupt";
+  }
+  if (!Array.isArray(parsed.pending) || !Array.isArray(parsed.results)) lock = "corrupt";
+  return { value: { v: CART_VALUE_VERSION, chainId, items, pending, results }, lock };
+}
+var defaultStorage = () => {
+  try {
+    return typeof window === "undefined" ? null : window.sessionStorage;
+  } catch (e4) {
+    return null;
+  }
+};
+var newId = () => {
+  const c = globalThis.crypto;
+  return _optionalChain([c, 'optionalAccess', _16 => _16.randomUUID]) ? c.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+};
+var CartStore = (_class2 = class {
+  
+  
+  
+  __init3() {this.value = null}
+  __init4() {this.lock = null}
+  /** Item writes that could not reach storage (storage threw): the cart then lives in memory only. */
+  __init5() {this.degraded = false}
+  __init6() {this.listeners = /* @__PURE__ */ new Set()}
+  /** The raw value this store last read or wrote. A different raw value in storage was written by another store. */
+  __init7() {this.lastRaw = null}
+  /** Goes up on every item change (R19). One live provider per key (R17); a stale one merges (latest()). */
+  __init8() {this.revision = 0}
+  constructor(opts) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);
+    this.storageKey = opts.storageKey;
+    this.chainId = opts.chainId;
+    this.storage = _nullishCoalesce(opts.storage, () => ( defaultStorage));
+  }
+  /** Loads on first use (client only); never touches storage during server rendering. */
+  __init9() {this.getSnapshot = () => {
+    if (this.value === null) {
+      let raw = null;
+      try {
+        raw = _nullishCoalesce(_optionalChain([this, 'access', _21 => _21.storage, 'call', _22 => _22(), 'optionalAccess', _23 => _23.getItem, 'call', _24 => _24(this.storageKey)]), () => ( null));
+      } catch (e6) {
+        this.degraded = true;
+      }
+      const restored = restoreValue(raw, this.chainId);
+      this.value = restored.value;
+      this.lock = restored.lock;
+      this.lastRaw = raw;
+    }
+    return this.value;
+  }}
+  /**
+   * The value every write starts from: storage as it is now. A store left behind by an unmounted provider (a route
+   * change mid-checkout) may still write once, when its wallet prompt returns; it must merge into what the newer
+   * provider saved, never overwrite it (Codex PR #11 review A-F3). Memory-only stores (locked, no storage) keep
+   * their own value.
+   */
+  latest() {
+    const v = this.getSnapshot();
+    if (this.lock !== null) return v;
+    let raw;
+    try {
+      const st = this.storage();
+      if (!st) return v;
+      raw = st.getItem(this.storageKey);
+    } catch (e7) {
+      return v;
+    }
+    if (raw === null || raw === this.lastRaw) return v;
+    const restored = restoreValue(raw, this.chainId);
+    this.lastRaw = raw;
+    if (restored.lock !== null) {
+      this.lock = restored.lock;
+      return v;
+    }
+    this.value = restored.value;
+    this.revision += 1;
+    this.notify();
+    return restored.value;
+  }
+  __init10() {this.subscribe = (cb) => {
+    this.listeners.add(cb);
+    return () => {
+      this.listeners.delete(cb);
+    };
+  }}
+  /** True when a value this code could not read protects the storage slot (writes are then memory-only). */
+  get locked() {
+    this.getSnapshot();
+    return this.lock;
+  }
+  /** A real test write: storage must accept and return a value, and no unreadable value may be in the way. */
+  persistenceOk() {
+    this.getSnapshot();
+    if (this.lock !== null) return false;
+    try {
+      const s = this.storage();
+      if (!s) return false;
+      const probe = `${this.storageKey}:probe`;
+      s.setItem(probe, "1");
+      const ok = s.getItem(probe) === "1";
+      s.removeItem(probe);
+      return ok;
+    } catch (e8) {
+      return false;
+    }
+  }
+  notify() {
+    for (const cb of [...this.listeners]) cb();
+  }
+  /** One setItem, read back. Returns false when the value did not reach storage. */
+  persist(next) {
+    if (this.lock !== null) return false;
+    try {
+      const s = this.storage();
+      if (!s) return false;
+      const raw = JSON.stringify(next);
+      s.setItem(this.storageKey, raw);
+      const ok = s.getItem(this.storageKey) === raw;
+      if (ok) this.lastRaw = raw;
+      return ok;
+    } catch (e9) {
+      return false;
+    }
+  }
+  /**
+   * strict: the change must reach storage or nothing changes and PERSISTENCE_UNAVAILABLE is thrown (R15).
+   * Item-only changes are not strict: a cart on a storage-less browser still works for the page's life.
+   */
+  commit(next, opts) {
+    const ok = this.persist(next);
+    if (!ok) {
+      if (opts.strict) throw new CartError("PERSISTENCE_UNAVAILABLE", "The cart could not save its state in this tab, so nothing was sent.");
+      this.degraded = true;
+    }
+    this.value = next;
+    if (opts.items) this.revision += 1;
+    this.notify();
+  }
+  get isDegraded() {
+    return this.degraded;
+  }
+  hasItem(key) {
+    return this.getSnapshot().items.some((i) => itemKey(i.config) === key);
+  }
+  pendingFor(key) {
+    return this.getSnapshot().pending.find((p) => p.lineKey === key);
+  }
+  // ---------- items ----------
+  /** Adds an item, or raises the quantity of an existing key. `drop` deletes those results in the same write. */
+  addItem(config, quantity, opts) {
+    const v = this.latest();
+    const key = itemKey(config);
+    const existing = v.items.find((i) => itemKey(i.config) === key);
+    const cap = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _25 => _25.cap]), () => ( null));
+    const bound = (q) => clampQuantity(cap !== null ? Math.min(q, Math.max(1, cap)) : q);
+    const items = existing ? v.items.map((i) => i === existing ? { ...i, quantity: bound(i.quantity + quantity) } : i) : [...v.items, { config, quantity: bound(quantity) }];
+    const drop = new Set(_nullishCoalesce(_optionalChain([opts, 'optionalAccess', _26 => _26.dropResults]), () => ( [])));
+    const results = drop.size ? v.results.filter((r) => !drop.has(r.id)) : v.results;
+    this.commit({ ...v, items, results }, { strict: false, items: true });
+  }
+  setQuantity(key, quantity) {
+    const v = this.latest();
+    const item = v.items.find((i) => itemKey(i.config) === key);
+    if (!item) return;
+    const q = clampQuantity(quantity);
+    if (q === item.quantity) return;
+    this.commit({ ...v, items: v.items.map((i) => i === item ? { ...i, quantity: q } : i) }, { strict: false, items: true });
+  }
+  /** A line with a pending mint is locked and stays. */
+  removeItem(key) {
+    const v = this.latest();
+    if (v.pending.some((p) => p.lineKey === key)) return;
+    const items = v.items.filter((i) => itemKey(i.config) !== key);
+    if (items.length === v.items.length) return;
+    this.commit({ ...v, items }, { strict: false, items: true });
+  }
+  /** Removes items only. Locked lines, pending mints and results stay. */
+  clearItems() {
+    const v = this.latest();
+    const locked = new Set(v.pending.map((p) => p.lineKey));
+    const items = v.items.filter((i) => locked.has(itemKey(i.config)));
+    if (items.length === v.items.length) return;
+    this.commit({ ...v, items }, { strict: false, items: true });
+  }
+  // ---------- pending mints and results ----------
+  /**
+   * Synchronous write plus read-back (R15). Throws CartError('PERSISTENCE_UNAVAILABLE'), changing nothing.
+   * One pending mint per line: returns false, writing nothing, when the line already has one (a second
+   * useCheckout under the same provider confirming the same line). The caller must not send.
+   */
+  writePending(p) {
+    const v = this.latest();
+    if (v.pending.some((x) => x.lineKey === p.lineKey)) return false;
+    this.commit({ ...v, pending: [...v.pending, p] }, { strict: true, items: false });
+    return true;
+  }
+  setHash(id, hash, hashAt) {
+    const v = this.latest();
+    if (!v.pending.some((p) => p.id === id)) return;
+    this.commit({ ...v, pending: v.pending.map((p) => p.id === id ? { ...p, hash, hashAt } : p) }, { strict: true, items: false });
+  }
+  /** A failed or not-sent mint: the pending mint goes, the line stays. */
+  removePending(id) {
+    const v = this.latest();
+    if (!v.pending.some((p) => p.id === id)) return;
+    this.commit({ ...v, pending: v.pending.filter((p) => p.id !== id) }, { strict: true, items: false });
+  }
+  /**
+   * Settling is one write of the whole value (R16, D24): remove the pending mint, remove its line, add the result.
+   */
+  settle(id, result) {
+    const v = this.latest();
+    const p = v.pending.find((x) => x.id === id);
+    if (!p) return;
+    this.commit(
+      {
+        ...v,
+        pending: v.pending.filter((x) => x.id !== id),
+        items: v.items.filter((i) => itemKey(i.config) !== p.lineKey),
+        results: [...v.results, result]
+      },
+      { strict: true, items: true }
+    );
+  }
+  deleteResult(id) {
+    const v = this.latest();
+    if (!v.results.some((r) => r.id === id)) return;
+    this.commit({ ...v, results: v.results.filter((r) => r.id !== id) }, { strict: false, items: false });
+  }
+}, _class2);
+
+// src/cart/run.ts
+var CART_TIMING = {
+  /** A failed read is retried after these delays, then the line shows error (Step 3). */
+  retryDelaysMs: [1e3, 2e3, 4e3],
+  /** A prepared request older than this goes back to preparing (R19). */
+  preparedExpiryMs: 3e4,
+  refreshMs: 3e4,
+  refreshBackoffMs: 6e4,
+  receiptTimeoutMs: 12e4,
+  /** An unknown hash this long after hashAt is a lost hash (Step 5b). */
+  unknownHashSec: 300,
+  holdingsTries: 3,
+  maxReadsInFlight: 4,
+  merklePerMinute: 10
+};
+var nowSec = () => Math.floor(Date.now() / 1e3);
+var adapter = _chunkOO6QQT3Mcjs.manifoldClaimAdapter;
+var LineSkipped = class extends Error {
+  
+  
+  constructor(state, reason, message) {
+    super(message);
+    this.name = "LineSkipped";
+    this.state = state;
+    this.reason = reason;
+  }
+};
+var skipText = {
+  "sold-out": "Sold out.",
+  ended: "The sale has ended.",
+  upcoming: "The sale has not started.",
+  locked: "A mint for this item is still being confirmed."
+};
+var attemptIds = 0;
+async function assessLine(env, line, payer) {
+  const config = structuredClone(line.config);
+  const key = itemKey(config);
+  const ctx = env.ctxFor(key);
+  const recipient = payer;
+  const drop = await adapter.readDrop(ctx, config);
+  if (drop.paymentToken !== null) throw new CartError("CART_ERC20_UNSUPPORTED", "This item is priced in a token, which the cart does not support.");
+  const walletRead = await adapter.readWallet(ctx, config, { payer, recipient, quantity: line.quantity, drop });
+  const read = deriveLine({ drop, walletRead, readError: null, now: nowSec(), pending: false, walletConnected: true });
+  if (read.state !== "live") throw new LineSkipped(read.state, read.reason, _nullishCoalesce(_nullishCoalesce(read.message, () => ( skipText[read.state])), () => ( "This item cannot be minted right now.")));
+  const max = lineMaxQuantity(drop, walletRead);
+  if (max !== null && line.quantity > max) {
+    throw new LineSkipped(max === 0 ? "sold-out" : "ineligible", "WALLET_LIMIT", max === 0 ? "Sold out." : `Only ${String(max)} left for this wallet.`);
+  }
+  const attempt = Object.freeze({
+    attemptId: ++attemptIds,
+    config,
+    payer,
+    recipient,
+    quantity: line.quantity,
+    chainId: config.chainId,
+    tokenContract: config.creatorContract,
+    originChainId: config.chainId
+  });
+  const plan = await adapter.buildPlan(ctx, attempt, walletRead);
+  if (plan.approve) throw new CartError("CART_ERC20_UNSUPPORTED", "This item needs a token approval, which the cart does not support.");
+  return { key, config, quantity: line.quantity, payer, recipient, attempt, drop, walletRead, plan, ctx };
+}
+async function prepareLine(env, line, payer) {
+  const a = await assessLine(env, line, payer);
+  try {
+    await adapter.simulate(a.ctx, a.attempt, a.plan);
+  } catch (e) {
+    if (e instanceof _chunkOO6QQT3Mcjs.MintError && e.reason === "SIMULATION_REVERTED") throw new LineSkipped("ineligible", "SIMULATION_REVERTED", _chunkOO6QQT3Mcjs.friendlyErrorMessage.call(void 0, e));
+    throw e;
+  }
+  const query = _nullishCoalesce(_optionalChain([adapter, 'access', _27 => _27.holdingsQuery, 'optionalCall', _28 => _28(a.drop)]), () => ( null));
+  if (!query || !adapter.readHoldings) throw new (0, _chunkOO6QQT3Mcjs.MintError)("RPC_ERROR", "The cart cannot count holdings for this item.");
+  const before = await adapter.readHoldings(a.ctx, query, a.recipient);
+  const unit = a.drop.unitPrice;
+  return {
+    key: a.key,
+    config: a.config,
+    quantity: a.quantity,
+    payer: a.payer,
+    recipient: a.recipient,
+    plan: a.plan,
+    drop: a.drop,
+    walletRead: a.walletRead,
+    holdings: { ...query, before: before.toString() },
+    preparedAt: Date.now(),
+    amount: { value: a.plan.mint.value, decimals: unit.decimals, symbol: unit.symbol, formatted: _viem.formatUnits.call(void 0, a.plan.mint.value, unit.decimals) },
+    revision: line.revision
+  };
+}
+async function withRetries(fn, delaysMs, isFinal, signal) {
+  for (let i = 0; ; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (isFinal(e) || i >= delaysMs.length || _optionalChain([signal, 'optionalAccess', _29 => _29.aborted])) throw e;
+      await sleep(delaysMs[i], signal);
+    }
+  }
+}
+var sendSwitch = (chainId) => _chunkOO6QQT3Mcjs.requestSwitch.call(void 0, chainId);
+var sendAddChain = (chainId) => _chunkOO6QQT3Mcjs.requestAddChain.call(void 0, chainId);
+var openCalls = /* @__PURE__ */ new Set();
+var notSentCalls = /* @__PURE__ */ new Set();
+var markCallOpen = (id) => void openCalls.add(id);
+var markCallClosed = (id) => void openCalls.delete(id);
+var isCallOpen = (id) => openCalls.has(id);
+var markNotSent = (id) => void notSentCalls.add(id);
+var wasNotSent = (id) => notSentCalls.has(id);
+var SEND_METHODS = /* @__PURE__ */ new Set(["eth_sendTransaction", "wallet_sendTransaction"]);
+async function sendMint(prepared, hooks) {
+  const notSent = (message, cause) => new CartError("REQUEST_NOT_SENT", message, { cause });
+  const live = _chunkOO6QQT3Mcjs.getAccount.call(void 0, );
+  if (!live || live.address.toLowerCase() !== prepared.payer.toLowerCase()) {
+    throw notSent("The connected wallet changed before the transaction was sent.");
+  }
+  let provider;
+  let chain;
+  try {
+    provider = _chunkOO6QQT3Mcjs.getWalletProvider.call(void 0, );
+    chain = _chunkOO6QQT3Mcjs.getChain.call(void 0, prepared.config.chainId);
+  } catch (e) {
+    throw notSent("No wallet is connected.", e);
+  }
+  const state = { forwarded: false };
+  const request = ((args) => {
+    if (SEND_METHODS.has(args.method)) state.forwarded = true;
+    return provider.request(args);
+  });
+  const wallet = _viem.createWalletClient.call(void 0, { chain, transport: _viem.custom.call(void 0, { request }, { retryCount: 0 }) });
+  let hash;
+  try {
+    hash = await wallet.sendTransaction({ account: prepared.payer, to: prepared.plan.mint.to, data: prepared.plan.mint.data, value: prepared.plan.mint.value, chain });
+  } catch (e) {
+    if (!state.forwarded) throw notSent("The transaction request did not reach the wallet.", e);
+    throw e;
+  }
+  hooks.onHash(hash);
+  return hash;
+}
+var receiptOk = (status) => status === "success" || status === 1 || status === 1n || status === "0x1";
+function toMintReceipt(receipt, hash, tokenContract, recipient) {
+  const ok = receiptOk(receipt.status);
+  const parsed = ok ? _chunkOO6QQT3Mcjs.parseMintReceipt.call(void 0, _nullishCoalesce(receipt.logs, () => ( [])), { tokenContract, recipient }) : [];
+  const minted = parsed.reduce((n, t) => n + t.amount, 0n);
+  const tokens = parsed.map((t) => ({ contract: t.contract, tokenId: t.tokenId.toString() }));
+  return { status: ok ? "success" : "reverted", hash: _nullishCoalesce(receipt.transactionHash, () => ( hash)), minted, tokens };
+}
+async function waitMint(client, args) {
+  const receipt = await client.waitForTransactionReceipt({
+    hash: args.hash,
+    confirmations: 1,
+    timeout: CART_TIMING.receiptTimeoutMs,
+    onReplaced: (r) => _optionalChain([args, 'access', _30 => _30.onReplaced, 'optionalCall', _31 => _31({ reason: r.reason, hash: _nullishCoalesce(_optionalChain([r, 'access', _32 => _32.transaction, 'optionalAccess', _33 => _33.hash]), () => ( null)) })])
+  });
+  return toMintReceipt(receipt, args.hash, args.tokenContract, args.recipient);
+}
+var shortAddress = (a) => `${a.slice(0, 6)}\u2026${a.slice(-4)}`;
+var lostHashWarning = (wallet) => `If wallet ${shortAddress(wallet)} still shows a request for this item, reject it.`;
+var unconfirmedMessage = (wallet) => `We couldn't confirm this. Check wallet ${shortAddress(wallet)}. If it didn't go through, add it again.`;
+var isNotFound = (e) => {
+  for (let x = e, depth = 0; x && depth < 6; depth++) {
+    if (x.name === "TransactionReceiptNotFoundError" || x.name === "TransactionNotFoundError") return true;
+    x = x.cause;
+  }
+  return false;
+};
+async function readHoldingsUp(env, p) {
+  const read = adapter.readHoldings;
+  if (!read) return null;
+  for (let i = 0; i < CART_TIMING.holdingsTries; i++) {
+    try {
+      const after = await read(env.ctx, p.holdings, p.recipient);
+      return after - BigInt(p.holdings.before) >= BigInt(p.quantity);
+    } catch (e10) {
+    }
+  }
+  return null;
+}
+var tokensFromQuery = (p) => p.holdings.kind === "balance-1155" ? [{ contract: p.holdings.creatorContract, tokenId: p.holdings.tokenId }] : [];
+function resultFor(p, status, hash, tokens = []) {
+  return { id: newId(), status, lineKey: p.lineKey, config: p.config, payer: p.payer, recipient: p.recipient, quantity: p.quantity, holdings: p.holdings, txHash: hash, tokens, at: nowSec() };
+}
+function commit(env, p, result) {
+  try {
+    env.store.settle(p.id, result);
+    return null;
+  } catch (e) {
+    const { reason, message } = cartReason(e);
+    return { kind: "unavailable", reason, message };
+  }
+}
+async function settle(env, pending) {
+  const p = pending;
+  const hash = _nullishCoalesce(_nullishCoalesce(p.hash, () => ( env.memHash)), () => ( null));
+  if (!hash) {
+    if (isCallOpen(p.id)) return { kind: "waiting", message: "Waiting for the wallet." };
+    if (wasNotSent(p.id)) {
+      try {
+        env.store.removePending(p.id);
+      } catch (e) {
+        const { reason, message } = cartReason(e);
+        return { kind: "unavailable", reason, message };
+      }
+      notSentCalls.delete(p.id);
+      return { kind: "not-sent" };
+    }
+    return lostHash(env, p);
+  }
+  let receipt = _nullishCoalesce(env.receipt, () => ( null));
+  if (!receipt) {
+    try {
+      const r = await env.client.getTransactionReceipt({ hash });
+      receipt = toMintReceipt(r, hash, p.config.creatorContract, p.recipient);
+    } catch (e) {
+      if (!isNotFound(e)) {
+        const { reason, message } = cartReason(e);
+        return { kind: "unavailable", reason, message };
+      }
+    }
+  }
+  if (receipt) {
+    if (receipt.status === "reverted") {
+      try {
+        env.store.removePending(p.id);
+      } catch (e) {
+        const { reason, message } = cartReason(e);
+        return { kind: "unavailable", reason, message };
+      }
+      return { kind: "failed", hash: receipt.hash, message: "The mint transaction reverted." };
+    }
+    if (receipt.minted >= BigInt(p.quantity)) {
+      const result2 = resultFor(p, "collected", receipt.hash, receipt.tokens);
+      return _nullishCoalesce(commit(env, p, result2), () => ( { kind: "collected", result: result2, warning: null }));
+    }
+    const result = resultFor(p, "unconfirmed", receipt.hash);
+    return _nullishCoalesce(commit(env, p, result), () => ( { kind: "unconfirmed", result }));
+  }
+  let known = false;
+  try {
+    await env.client.getTransaction({ hash });
+    known = true;
+  } catch (e) {
+    if (!isNotFound(e)) {
+      const { reason, message } = cartReason(e);
+      return { kind: "unavailable", reason, message };
+    }
+  }
+  const age = p.hashAt === null ? Infinity : nowSec() - p.hashAt;
+  if (known || age < CART_TIMING.unknownHashSec) return { kind: "waiting", message: "Still confirming." };
+  return lostHash(env, p);
+}
+async function lostHash(env, p) {
+  const up = await readHoldingsUp(env, p);
+  if (up) {
+    const result2 = resultFor(p, "collected", _nullishCoalesce(_nullishCoalesce(p.hash, () => ( env.memHash)), () => ( null)), tokensFromQuery(p));
+    return _nullishCoalesce(commit(env, p, result2), () => ( { kind: "collected", result: result2, warning: lostHashWarning(p.payer) }));
+  }
+  const result = resultFor(p, "unconfirmed", _nullishCoalesce(_nullishCoalesce(p.hash, () => ( env.memHash)), () => ( null)));
+  return _nullishCoalesce(commit(env, p, result), () => ( { kind: "unconfirmed", result }));
+}
+
+// src/cart/links.ts
+
+var OPENSEA_CHAINS = {
+  1: "ethereum",
+  8453: "base",
+  10: "optimism",
+  360: "shape",
+  33139: "ape_chain"
+};
+var openseaChain = (chainId) => _nullishCoalesce(OPENSEA_CHAINS[chainId], () => ( null));
+function explorerTx(chainId, hash) {
+  if (!hash) return null;
+  let base;
+  try {
+    base = _optionalChain([_chunkOO6QQT3Mcjs.getChain.call(void 0, chainId), 'access', _34 => _34.blockExplorers, 'optionalAccess', _35 => _35.default, 'access', _36 => _36.url]);
+  } catch (e11) {
+    return null;
+  }
+  return base ? `${base.replace(/\/$/, "")}/tx/${hash}` : null;
+}
+function slugFor(collections, contract) {
+  if (!collections) return null;
+  const want = _viem.getAddress.call(void 0, contract);
+  for (const [k, v] of Object.entries(collections)) {
+    try {
+      if (_viem.getAddress.call(void 0, k) === want && v) return v;
+    } catch (e12) {
+    }
+  }
+  return null;
+}
+function collectedLinks(args) {
+  const tx = explorerTx(args.chainId, args.txHash);
+  const chain = openseaChain(args.chainId);
+  if (!chain) return { tx, profile: null, tokens: [] };
+  const wallet = args.wallet.toLowerCase();
+  const tokens = args.tokens.map((t) => ({ tokenId: t.tokenId, url: `https://opensea.io/item/${chain}/${t.contract.toLowerCase()}/${t.tokenId}` }));
+  const slug = slugFor(args.collections, args.contract);
+  const profile = slug ? `https://opensea.io/${wallet}/holdings?collectionSlugs=${encodeURIComponent(slug)}` : tokens.length === 0 ? `https://opensea.io/${wallet}` : null;
+  return { tx, profile, tokens };
+}
+
+// src/cart/react.ts
+var activeKeys = /* @__PURE__ */ new Set();
+var StateContext = _react.createContext.call(void 0, null);
+var InternalsContext = _react.createContext.call(void 0, null);
+function useCartInternals() {
+  const v = _react.useContext.call(void 0, InternalsContext);
+  if (!v) throw new (0, _chunkOO6QQT3Mcjs.MintError)("INVALID_CONFIG", "useCheckout must be used inside <CartProvider>.");
+  return v;
+}
+function useCart() {
+  const v = _react.useContext.call(void 0, StateContext);
+  if (!v) throw new (0, _chunkOO6QQT3Mcjs.MintError)("INVALID_CONFIG", "useCart must be used inside <CartProvider>.");
+  return v;
+}
+var isFinalRead = (e) => {
+  const r = cartReason(e).reason;
+  return _chunkOO6QQT3Mcjs.UNSUPPORTED_REASONS.includes(r) || r === "INVALID_CONFIG";
+};
+var emptyValue = (chainId) => ({ v: 6, chainId, items: [], pending: [], results: [] });
+var LineBook = (_class3 = class {constructor() { _class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this); }
+  __init11() {this.map = /* @__PURE__ */ new Map()}
+  __init12() {this.version = 0}
+  __init13() {this.listeners = /* @__PURE__ */ new Set()}
+  __init14() {this.subscribe = (cb) => {
+    this.listeners.add(cb);
+    return () => void this.listeners.delete(cb);
+  }}
+  __init15() {this.getVersion = () => this.version}
+  changed() {
+    this.version += 1;
+    for (const cb of [...this.listeners]) cb();
+  }
+}, _class3);
+var Core = (_class4 = class {constructor() { _class4.prototype.__init16.call(this);_class4.prototype.__init17.call(this);_class4.prototype.__init18.call(this);_class4.prototype.__init19.call(this);_class4.prototype.__init20.call(this);_class4.prototype.__init21.call(this);_class4.prototype.__init22.call(this);_class4.prototype.__init23.call(this);_class4.prototype.__init24.call(this);_class4.prototype.__init25.call(this);_class4.prototype.__init26.call(this); }
+  __init16() {this.lifetime = new AbortController()}
+  __init17() {this.scopes = /* @__PURE__ */ new Map()}
+  __init18() {this.settling = /* @__PURE__ */ new Map()}
+  __init19() {this.settledAtMount = /* @__PURE__ */ new Set()}
+  __init20() {this.busy = false}
+  __init21() {this.backoffUntil = 0}
+  __init22() {this.warned = false}
+  __init23() {this.registeredKey = null}
+  __init24() {this.widgetLoad = null}
+  __init25() {this.items = []}
+  __init26() {this.payer = null}
+  sync(items, payer) {
+    this.items = items;
+    this.payer = payer;
+  }
+  setBusy(b) {
+    this.busy = b;
+  }
+  setWidgetLoad(p) {
+    this.widgetLoad = p;
+  }
+  /** True the first time it is called. */
+  warnOnce() {
+    const first = !this.warned;
+    this.warned = true;
+    return first;
+  }
+  setRegistered(key) {
+    this.registeredKey = key;
+  }
+  renewLifetime() {
+    if (this.lifetime.signal.aborted) this.lifetime = new AbortController();
+    return this.lifetime;
+  }
+}, _class4);
+var subscribeAccountChanges = (notify) => _chunkOO6QQT3Mcjs.subscribeAccount.call(void 0, () => notify());
+var accountSnapshot = () => {
+  const a = _chunkOO6QQT3Mcjs.getAccount.call(void 0, );
+  return a ? `${a.address}:${String(a.chainId)}` : "";
+};
+function buildLines(value, book, payer, now, version) {
+  if (version < 0) return [];
+  return value.items.map((item) => {
+    const key = itemKey(item.config);
+    const data = book.map.get(key);
+    const drop = _nullishCoalesce(_optionalChain([data, 'optionalAccess', _37 => _37.drop]), () => ( null));
+    const walletRead = _nullishCoalesce(_optionalChain([data, 'optionalAccess', _38 => _38.walletRead]), () => ( null));
+    const d = deriveLine({ drop, walletRead, readError: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _39 => _39.readError]), () => ( null)), now, pending: value.pending.some((p) => p.lineKey === key), walletConnected: payer !== null });
+    return { key, config: item.config, quantity: item.quantity, state: d.state, reason: d.reason, drop, maxQuantity: lineMaxQuantity(drop, walletRead), total: lineTotal(drop, item.quantity) };
+  });
+}
+var currentSeconds = () => Math.floor(Date.now() / 1e3);
+function CartProvider(props) {
+  const { chainId, rpcUrls, children } = props;
+  const storageKey = _nullishCoalesce(props.storageKey, () => ( defaultStorageKey(chainId)));
+  const projectId = _optionalChain([props, 'access', _40 => _40.connect, 'optionalAccess', _41 => _41.walletConnectProjectId]);
+  const [core] = _react.useState.call(void 0, () => new Core());
+  const [book] = _react.useState.call(void 0, () => new LineBook());
+  const store = _react.useMemo.call(void 0, () => new CartStore({ storageKey, chainId }), [storageKey, chainId]);
+  const serverValue = _react.useMemo.call(void 0, () => emptyValue(chainId), [chainId]);
+  const value = _react.useSyncExternalStore.call(void 0, store.subscribe, store.getSnapshot, () => serverValue);
+  const bookVersion = _react.useSyncExternalStore.call(void 0, book.subscribe, book.getVersion, () => 0);
+  const accountKey = _react.useSyncExternalStore.call(void 0, subscribeAccountChanges, accountSnapshot, () => "");
+  const account = _react.useMemo.call(void 0, () => {
+    const [address, chain] = accountKey.split(":");
+    return address ? { address, chainId: Number(chain) } : null;
+  }, [accountKey]);
+  const payer = _nullishCoalesce(_optionalChain([account, 'optionalAccess', _42 => _42.address]), () => ( null));
+  _react.useEffect.call(void 0, () => core.sync(value.items, payer), [core, value.items, payer]);
+  _react.useEffect.call(void 0, () => {
+    if (activeKeys.has(storageKey)) {
+      throw new (0, _chunkOO6QQT3Mcjs.MintError)("INVALID_CONFIG", "Only one CartProvider per storageKey. Wrap your app once.", { field: "storageKey" });
+    }
+    activeKeys.add(storageKey);
+    core.setRegistered(storageKey);
+    const life = core.renewLifetime();
+    return () => {
+      if (core.registeredKey === storageKey) activeKeys.delete(storageKey);
+      core.setRegistered(null);
+      life.abort();
+    };
+  }, [storageKey, core]);
+  _react.useEffect.call(void 0, () => {
+    if (!core.warnOnce()) return;
+    if (!_optionalChain([rpcUrls, 'optionalAccess', _43 => _43[chainId]])) {
+      console.warn(`dropkit cart: no rpcUrls for chain ${String(chainId)}. Receipts, holdings and balance checks fall back to a public RPC and can be rate-limited during a sale.`);
+    }
+  }, []);
+  const rpcKey = _nullishCoalesce(_optionalChain([rpcUrls, 'optionalAccess', _44 => _44[chainId]]), () => ( ""));
+  const readClient = _react.useMemo.call(void 0, 
+    () => _chunkOO6QQT3Mcjs.createReadClient.call(void 0, { chainId, ...rpcKey ? { rpcUrls: { [chainId]: rpcKey } } : {}, useBridge: true }),
+    [chainId, rpcKey]
+  );
+  const shared = _react.useMemo.call(void 0, () => sharedReadClient(readClient), [readClient]);
+  const limiter = _react.useMemo.call(void 0, () => new Limiter(() => CART_TIMING.maxReadsInFlight), []);
+  const merkleFetch = _react.useMemo.call(void 0, () => rateLimitedFetch(void 0, () => CART_TIMING.merklePerMinute), []);
+  const env = _react.useMemo.call(void 0, 
+    () => ({
+      client: shared.client,
+      chainId,
+      fetch: merkleFetch,
+      ctxFor: (key) => {
+        let scope = core.scopes.get(key);
+        if (!scope) {
+          scope = {};
+          core.scopes.set(key, scope);
+        }
+        return { client: shared.client, fetch: merkleFetch, cacheScope: scope, signal: core.lifetime.signal };
+      }
+    }),
+    [shared, chainId, merkleFetch, core]
+  );
+  _react.useEffect.call(void 0, () => {
+    const loading = _chunkOO6QQT3Mcjs.loadConnectWidget.call(void 0, { chainIds: [chainId], ...projectId ? { walletConnectProjectId: projectId } : {} });
+    core.setWidgetLoad(loading);
+    loading.catch(() => void 0);
+  }, [chainId, projectId, core]);
+  const connect = _react.useCallback.call(void 0, async () => {
+    try {
+      await core.widgetLoad;
+      return await _chunkOO6QQT3Mcjs.openConnectModal.call(void 0, );
+    } catch (e13) {
+      return "dismissed";
+    }
+  }, [core]);
+  const setBusy = _react.useCallback.call(void 0, (b) => core.setBusy(b), [core]);
+  const readLine = _react.useCallback.call(void 0, 
+    (key) => {
+      const item = core.items.find((i) => itemKey(i.config) === key);
+      if (!item || core.lifetime.signal.aborted) return;
+      const data = _nullishCoalesce(book.map.get(key), () => ( { gen: 0, controller: null, drop: null, walletRead: null, readError: null, readFor: null }));
+      book.map.set(key, data);
+      _optionalChain([data, 'access', _45 => _45.controller, 'optionalAccess', _46 => _46.abort, 'call', _47 => _47()]);
+      const controller = new AbortController();
+      data.controller = controller;
+      const gen = ++data.gen;
+      const wantPayer = core.payer;
+      const quantity = item.quantity;
+      const ctx = { ...env.ctxFor(key), signal: controller.signal };
+      void limiter.run(
+        () => withRetries(
+          async () => {
+            const drop = await adapter.readDrop(ctx, item.config);
+            let walletRead = null;
+            if (wantPayer && drop.paymentToken === null) {
+              walletRead = await adapter.readWallet(ctx, item.config, { payer: wantPayer, recipient: wantPayer, quantity, drop });
+            }
+            return { drop, walletRead };
+          },
+          CART_TIMING.retryDelaysMs,
+          (e) => isFinalRead(e) || controller.signal.aborted,
+          controller.signal
+        )
+      ).then(
+        ({ drop, walletRead }) => {
+          if (data.gen !== gen || controller.signal.aborted) return;
+          data.drop = drop;
+          data.walletRead = walletRead;
+          data.readError = null;
+          data.readFor = { quantity, payer: wantPayer };
+          book.changed();
+          const cap = lineMaxQuantity(drop, walletRead);
+          const now = store.getSnapshot().items.find((i) => itemKey(i.config) === key);
+          if (cap !== null && cap > 0 && now && now.quantity > cap && !store.pendingFor(key)) store.setQuantity(key, cap);
+        },
+        (e) => {
+          if (data.gen !== gen || controller.signal.aborted) return;
+          const r = cartReason(e);
+          if (r.reason === "RATE_LIMITED") core.backoffUntil = Date.now() + CART_TIMING.refreshBackoffMs;
+          data.readError = r;
+          data.walletRead = null;
+          data.readFor = { quantity, payer: wantPayer };
+          book.changed();
+        }
+      );
+    },
+    [env, limiter, book, core, store]
+  );
+  const itemsSig = value.items.map((i) => `${itemKey(i.config)}#${String(i.quantity)}`).join("|");
+  const pendingSig = value.pending.map((p) => p.lineKey).join("|");
+  _react.useEffect.call(void 0, () => {
+    const keys = /* @__PURE__ */ new Set();
+    for (const item of core.items) {
+      const key = itemKey(item.config);
+      keys.add(key);
+      if (store.pendingFor(key)) continue;
+      const data = book.map.get(key);
+      if (!data || data.readFor === null || data.readFor.quantity !== item.quantity || data.readFor.payer !== core.payer) {
+        if (!data || data.controller === null || _optionalChain([data, 'access', _48 => _48.readFor, 'optionalAccess', _49 => _49.quantity]) !== item.quantity || _optionalChain([data, 'access', _50 => _50.readFor, 'optionalAccess', _51 => _51.payer]) !== core.payer) readLine(key);
+      }
+    }
+    for (const [key, data] of book.map) {
+      if (!keys.has(key)) {
+        _optionalChain([data, 'access', _52 => _52.controller, 'optionalAccess', _53 => _53.abort, 'call', _54 => _54()]);
+        book.map.delete(key);
+        core.scopes.delete(key);
+      }
+    }
+  }, [itemsSig, payer, pendingSig, readLine, store, book, core]);
+  _react.useEffect.call(void 0, () => {
+    let timer;
+    const tick = () => {
+      const wait = Date.now() < core.backoffUntil ? CART_TIMING.refreshBackoffMs : CART_TIMING.refreshMs;
+      timer = setTimeout(() => {
+        const hidden = typeof document !== "undefined" && document.visibilityState === "hidden";
+        if (!hidden && !core.busy) {
+          shared.bump();
+          for (const item of core.items) if (!store.pendingFor(itemKey(item.config))) readLine(itemKey(item.config));
+        }
+        tick();
+      }, wait);
+    };
+    tick();
+    return () => clearTimeout(timer);
+  }, [shared, store, readLine, core]);
+  const settleOne = _react.useCallback.call(void 0, 
+    (id, extra) => {
+      const hit = core.settling.get(id);
+      if (hit) return hit;
+      const p = store.getSnapshot().pending.find((x) => x.id === id);
+      if (!p) return Promise.resolve(null);
+      const run = settle({ client: readClient, ctx: env.ctxFor(p.lineKey), store, receipt: _nullishCoalesce(_optionalChain([extra, 'optionalAccess', _55 => _55.receipt]), () => ( null)), memHash: _nullishCoalesce(_optionalChain([extra, 'optionalAccess', _56 => _56.memHash]), () => ( null)) }, p).catch((e) => ({ kind: "unavailable", ...cartReason(e) })).finally(() => core.settling.delete(id));
+      core.settling.set(id, run);
+      return run;
+    },
+    [store, env, readClient, core]
+  );
+  _react.useEffect.call(void 0, () => {
+    for (const p of store.getSnapshot().pending) {
+      if (core.settledAtMount.has(p.id)) continue;
+      core.settledAtMount.add(p.id);
+      void settleOne(p.id).then((out) => {
+        if (out && (out.kind === "collected" || out.kind === "unconfirmed")) shared.bump();
+      });
+    }
+  }, [store, settleOne, shared, core]);
+  const cartLines = _react.useMemo.call(void 0, 
+    () => buildLines(value, book, payer, currentSeconds(), bookVersion),
+    [value, book, payer, bookVersion]
+  );
+  const total = _react.useMemo.call(void 0, () => {
+    const counted = cartLines.filter((l) => l.state !== "unsupported" && l.state !== "locked" && l.total !== null);
+    if (counted.length === 0) return null;
+    return sumMoney(counted.map((l) => l.total), counted[0].total);
+  }, [cartLines]);
+  const unconfirmed = _react.useMemo.call(void 0, 
+    () => value.results.filter((r) => r.status === "unconfirmed").map((r) => ({ id: r.id, key: r.lineKey, config: r.config, quantity: r.quantity, at: r.at, wallet: r.payer, message: unconfirmedMessage(r.payer) })),
+    [value.results]
+  );
+  const openseaCollections = props.openseaCollections;
+  const collected = _react.useMemo.call(void 0, 
+    () => value.results.filter((r) => r.status === "collected").map((r) => ({
+      id: r.id,
+      key: r.lineKey,
+      quantity: r.quantity,
+      at: r.at,
+      txHash: r.txHash,
+      wallet: r.payer,
+      tokens: r.tokens,
+      links: collectedLinks({ chainId, wallet: r.recipient, contract: r.config.creatorContract, txHash: r.txHash, tokens: r.tokens, collections: openseaCollections })
+    })),
+    [value.results, chainId, openseaCollections]
+  );
+  const add = _react.useCallback.call(void 0, 
+    async (config, quantity = 1, opts) => {
+      const canon = canonicalConfig(config, chainId);
+      const key = itemKey(canon);
+      const snap = store.getSnapshot();
+      if (snap.pending.some((p) => p.lineKey === key)) return "added";
+      const priors = snap.results.filter((r) => r.status === "unconfirmed" && r.lineKey === key);
+      if (priors.length > 0 && !_optionalChain([opts, 'optionalAccess', _57 => _57.force])) {
+        if (!adapter.readHoldings) return "check-unavailable";
+        for (const r of priors) {
+          try {
+            const now = await adapter.readHoldings(env.ctxFor(key), r.holdings, r.recipient);
+            if (now - BigInt(r.holdings.before) >= BigInt(r.quantity)) return "looks-collected";
+          } catch (e14) {
+            return "check-unavailable";
+          }
+        }
+      }
+      const data = book.map.get(key);
+      const cap = _optionalChain([data, 'optionalAccess', _58 => _58.drop]) ? lineMaxQuantity(data.drop, data.walletRead) : null;
+      store.addItem(canon, quantity, { cap, dropResults: priors.map((r) => r.id) });
+      return "added";
+    },
+    [chainId, store, env, book]
+  );
+  const state = _react.useMemo.call(void 0, 
+    () => ({
+      lines: cartLines,
+      unconfirmed,
+      collected,
+      total,
+      count: cartLines.length,
+      add,
+      setQuantity: (key, quantity) => {
+        const line = cartLines.find((l) => l.key === key);
+        const cap = _optionalChain([line, 'optionalAccess', _59 => _59.maxQuantity]);
+        store.setQuantity(key, cap !== null && cap !== void 0 ? Math.min(quantity, Math.max(1, cap)) : quantity);
+      },
+      remove: (key) => store.removeItem(key),
+      clear: () => store.clearItems(),
+      has: (config) => {
+        try {
+          return store.hasItem(itemKey(canonicalConfig(config, chainId)));
+        } catch (e15) {
+          return false;
+        }
+      },
+      dismissUnconfirmed: (id) => store.deleteResult(id),
+      checkPending: async () => {
+        await Promise.all(store.getSnapshot().pending.map((p) => settleOne(p.id)));
+        shared.bump();
+      }
+    }),
+    [cartLines, unconfirmed, collected, total, add, store, chainId, settleOne, shared]
+  );
+  const internals = _react.useMemo.call(void 0, 
+    () => ({
+      chainId,
+      store,
+      env,
+      shared,
+      limiter,
+      account,
+      getSignal: () => core.lifetime.signal,
+      connect,
+      setBusy,
+      settle: settleOne,
+      refreshLine: readLine,
+      lineData: (key) => _nullishCoalesce(book.map.get(key), () => ( null))
+    }),
+    [chainId, store, env, shared, limiter, account, connect, setBusy, settleOne, readLine, book, core]
+  );
+  return _react.createElement.call(void 0, InternalsContext.Provider, { value: internals }, _react.createElement.call(void 0, StateContext.Provider, { value: state }, children));
+}
+
+// src/cart/useCheckout.ts
+
+
+var nowSec2 = () => Math.floor(Date.now() / 1e3);
+var BUSY = /* @__PURE__ */ new Set(["preparing", "ready", "sending", "checking", "paused"]);
+var fresh = () => ({
+  state: "idle",
+  action: null,
+  reason: null,
+  message: null,
+  steps: [],
+  currentKey: null,
+  run: 0,
+  needsAddChain: false,
+  initialDone: false,
+  assessedQty: {},
+  prepared: null,
+  payer: null,
+  waiting: null,
+  claimed: false,
+  expiry: null
+});
+var step = (key, patch = {}) => ({ key, status: "pending", reason: null, message: null, txHash: null, ...patch });
+function useCheckout() {
+  const cart = useCartInternals();
+  const { store } = cart;
+  const value = _react.useSyncExternalStore.call(void 0, store.subscribe, store.getSnapshot, store.getSnapshot);
+  const [, publish] = _react.useReducer.call(void 0, (n) => n + 1, 0);
+  const cRef = _react.useRef.call(void 0, fresh());
+  const c = cRef.current;
+  const cartRef = _react.useRef.call(void 0, cart);
+  cartRef.current = cart;
+  const alive = _react.useRef.call(void 0, true);
+  _react.useEffect.call(void 0, () => {
+    alive.current = true;
+    const ctl = cRef.current;
+    const k = cartRef;
+    return () => {
+      alive.current = false;
+      ctl.run += 1;
+      if (ctl.expiry) clearTimeout(ctl.expiry);
+      k.current.setBusy(false);
+    };
+  }, []);
+  const set = _react.useCallback.call(void 0, (patch) => {
+    const ctl = cRef.current;
+    Object.assign(ctl, patch);
+    if (ctl.expiry && ctl.state !== "ready") {
+      clearTimeout(ctl.expiry);
+      ctl.expiry = null;
+    }
+    cartRef.current.setBusy(BUSY.has(ctl.state));
+    if (alive.current) publish();
+  }, []);
+  const setStep = _react.useCallback.call(void 0, 
+    (key, patch) => {
+      const ctl = cRef.current;
+      ctl.steps = ctl.steps.map((s) => s.key === key ? { ...s, ...patch } : s);
+    },
+    []
+  );
+  const startPreparing = _react.useCallback.call(void 0, (patch = {}) => {
+    const ctl = cRef.current;
+    const run = ctl.run + 1;
+    set({ state: "preparing", action: null, reason: null, message: null, prepared: null, claimed: false, run, ...patch });
+    void prepare(run);
+  }, []);
+  const prepare = _react.useCallback.call(void 0, async (run) => {
+    const ctl = cRef.current;
+    const live = () => alive.current && ctl.run === run;
+    const k = cartRef.current;
+    const blocked = (reason, message) => {
+      if (live()) set({ state: "blocked", action: null, reason, message, prepared: null, currentKey: null, claimed: false });
+    };
+    const idle = () => {
+      if (live()) set({ ...fresh(), run: ctl.run + 1 });
+    };
+    try {
+      if (!k.store.persistenceOk()) return blocked("PERSISTENCE_UNAVAILABLE", "The cart could not save its state in this tab, so nothing was sent.");
+      let account = _chunkOO6QQT3Mcjs.getAccount.call(void 0, );
+      if (!account) {
+        const outcome = await k.connect();
+        if (!live()) return;
+        account = _chunkOO6QQT3Mcjs.getAccount.call(void 0, );
+        if (outcome === "dismissed" || !account) return idle();
+      }
+      const payer = account.address;
+      if (ctl.payer !== null && ctl.payer.toLowerCase() !== payer.toLowerCase()) {
+        ctl.initialDone = false;
+      }
+      ctl.payer = payer;
+      if (account.chainId !== k.chainId) {
+        const action = ctl.needsAddChain ? { kind: "add-chain", chainId: k.chainId } : { kind: "switch-chain", chainId: k.chainId };
+        return set({ state: "ready", action, reason: null, message: null, claimed: false });
+      }
+      const qtyNow = (key) => _nullishCoalesce(_optionalChain([k, 'access', _60 => _60.store, 'access', _61 => _61.getSnapshot, 'call', _62 => _62(), 'access', _63 => _63.items, 'access', _64 => _64.find, 'call', _65 => _65((i) => itemKey(i.config) === key), 'optionalAccess', _66 => _66.quantity]), () => ( 0));
+      const grew = () => ctl.steps.some((s) => (s.status === "pending" || s.status === "active") && qtyNow(s.key) > (_nullishCoalesce(ctl.assessedQty[s.key], () => ( 0))));
+      while (!ctl.initialDone || grew()) {
+        const ok = await assessAll(run, payer);
+        if (!ok || !live()) return;
+        ctl.initialDone = true;
+      }
+      for (; ; ) {
+        const next = ctl.steps.find((s) => s.status === "pending" || s.status === "active");
+        if (!next) break;
+        const item = k.store.getSnapshot().items.find((i) => itemKey(i.config) === next.key);
+        if (!item) {
+          setStep(next.key, { status: "skipped", reason: null, message: "This item left the cart." });
+          continue;
+        }
+        if (k.store.pendingFor(next.key)) {
+          setStep(next.key, { status: "skipped", reason: null, message: "A mint for this item is still being confirmed." });
+          continue;
+        }
+        try {
+          const prepared = await withRetries(
+            () => k.limiter.run(() => prepareLine(k.env, { config: item.config, quantity: item.quantity, revision: k.store.revision }, payer)),
+            CART_TIMING.retryDelaysMs,
+            (e) => e instanceof LineSkipped || e instanceof CartError,
+            k.getSignal()
+          );
+          if (!live()) return;
+          setStep(next.key, { status: "active", reason: null, message: null });
+          const action = { kind: "mint", key: prepared.key, amount: prepared.amount };
+          ctl.expiry = setTimeout(() => {
+            if (alive.current && ctl.run === run && ctl.state === "ready") startPreparing();
+          }, CART_TIMING.preparedExpiryMs);
+          set({ state: "ready", action, reason: null, message: null, prepared, currentKey: prepared.key, claimed: false });
+          if (!ctl.expiry) {
+            ctl.expiry = setTimeout(() => {
+              if (alive.current && ctl.run === run && ctl.state === "ready") startPreparing();
+            }, CART_TIMING.preparedExpiryMs);
+          }
+          return;
+        } catch (e) {
+          if (!live()) return;
+          if (e instanceof LineSkipped) setStep(next.key, { status: "skipped", reason: e.reason, message: e.message });
+          else {
+            const r = cartReason(e);
+            setStep(next.key, { status: "skipped", reason: r.reason, message: r.message });
+          }
+          publish();
+        }
+      }
+      const settled = ctl.steps.some((s) => s.status === "success" || s.status === "unconfirmed");
+      const first = ctl.steps.find((s) => s.status === "skipped");
+      if (!settled && first) return blocked(_nullishCoalesce(first.reason, () => ( "RPC_ERROR")), _nullishCoalesce(first.message, () => ( "No item in the cart can be collected right now.")));
+      if (live()) set({ state: "done", action: null, reason: null, message: null, prepared: null, currentKey: null, claimed: false });
+    } catch (e) {
+      if (!live()) return;
+      const r = cartReason(e);
+      blocked(r.reason, r.message);
+    }
+  }, []);
+  const assessAll = _react.useCallback.call(void 0, async (run, payer) => {
+    const ctl = cRef.current;
+    const k = cartRef.current;
+    const live = () => alive.current && ctl.run === run;
+    k.shared.bump();
+    const plans = [];
+    const assessedQty = {};
+    for (const s of ctl.steps.filter((x) => x.status === "pending" || x.status === "active")) {
+      const item = k.store.getSnapshot().items.find((i) => itemKey(i.config) === s.key);
+      if (!item) {
+        setStep(s.key, { status: "skipped", message: "This item left the cart." });
+        continue;
+      }
+      if (k.store.pendingFor(s.key)) {
+        setStep(s.key, { status: "skipped", message: "A mint for this item is still being confirmed." });
+        continue;
+      }
+      try {
+        const a = await withRetries(
+          () => k.limiter.run(() => assessLine(k.env, { config: item.config, quantity: item.quantity }, payer)),
+          CART_TIMING.retryDelaysMs,
+          (e) => e instanceof LineSkipped || e instanceof CartError,
+          k.getSignal()
+        );
+        if (!live()) return false;
+        assessedQty[s.key] = item.quantity;
+        plans.push({ value: a.plan.mint.value, gas: a.walletRead.gasReserve, symbol: a.drop.unitPrice.symbol, decimals: a.drop.unitPrice.decimals });
+      } catch (e) {
+        if (!live()) return false;
+        if (e instanceof LineSkipped) setStep(s.key, { status: "skipped", reason: e.reason, message: e.message });
+        else {
+          const r = cartReason(e);
+          setStep(s.key, { status: "skipped", reason: r.reason, message: r.message });
+        }
+      }
+    }
+    if (plans.length > 0) {
+      const balance = await withRetries(() => k.limiter.run(() => k.shared.client.getBalance({ address: payer })), CART_TIMING.retryDelaysMs, () => false, k.getSignal());
+      if (!live()) return false;
+      const need = plans.reduce((n, p) => n + p.value + p.gas, 0n);
+      if (balance < need) {
+        const p = plans[0];
+        const short = need - balance;
+        set({
+          state: "blocked",
+          action: null,
+          reason: "INSUFFICIENT_FUNDS",
+          message: `Your balance is ${_viem.formatUnits.call(void 0, short, p.decimals)} ${p.symbol} short of this cart (price, fees and gas).`,
+          prepared: null,
+          currentKey: null,
+          claimed: false
+        });
+        return false;
+      }
+    }
+    ctl.assessedQty = assessedQty;
+    return true;
+  }, []);
+  const applyOutcome = _react.useCallback.call(void 0, 
+    (key, id, out, memHash) => {
+      const ctl = cRef.current;
+      if (!alive.current) return;
+      if (!out) return startPreparing();
+      switch (out.kind) {
+        case "collected":
+          setStep(key, { status: "success", reason: null, message: out.warning, txHash: out.result.txHash });
+          cartRef.current.shared.bump();
+          return startPreparing();
+        case "unconfirmed":
+          setStep(key, { status: "unconfirmed", reason: null, message: unconfirmedMessage(out.result.payer), txHash: out.result.txHash });
+          cartRef.current.shared.bump();
+          return startPreparing();
+        case "not-sent":
+          setStep(key, { status: "pending", reason: null, message: null });
+          return startPreparing();
+        case "failed":
+          setStep(key, { status: "failed", reason: "SIMULATION_REVERTED", message: out.message, txHash: out.hash });
+          return set({ state: "paused", action: null, reason: "SIMULATION_REVERTED", message: out.message, prepared: null, waiting: null, claimed: false });
+        case "waiting":
+          setStep(key, { status: "unknown", reason: null, message: out.message });
+          return set({ state: "checking", action: null, reason: null, message: out.message, prepared: null, waiting: { id, key, memHash }, claimed: false });
+        case "unavailable":
+          setStep(key, { status: "unknown", reason: out.reason, message: out.message });
+          return set({ state: "checking", action: null, reason: out.reason, message: out.message, prepared: null, waiting: { id, key, memHash }, claimed: false });
+      }
+      void ctl;
+    },
+    [set, setStep, startPreparing]
+  );
+  const checkout = _react.useCallback.call(void 0, () => {
+    const ctl = cRef.current;
+    if (ctl.state !== "idle") return;
+    const k = cartRef.current;
+    const items = k.store.getSnapshot().items;
+    const steps = items.map((i) => step(itemKey(i.config)));
+    k.shared.bump();
+    startPreparing({ steps, currentKey: null, needsAddChain: false, initialDone: false, payer: null, waiting: null });
+    void steps;
+  }, [startPreparing]);
+  const confirm = _react.useCallback.call(void 0, () => {
+    const ctl = cRef.current;
+    if (ctl.claimed || ctl.state !== "ready" || !ctl.action) return;
+    ctl.claimed = true;
+    const action = ctl.action;
+    const k = cartRef.current;
+    const run = ctl.run;
+    if (action.kind === "switch-chain" || action.kind === "add-chain") {
+      set({ state: "sending", claimed: true });
+      const request = action.kind === "switch-chain" ? sendSwitch(action.chainId) : sendAddChain(action.chainId).then(() => ({ needsAdd: false }));
+      request.then(
+        (r) => {
+          if (!alive.current || ctl.run !== run) return;
+          if (r.needsAdd) return set({ state: "ready", action: { kind: "add-chain", chainId: k.chainId }, needsAddChain: true, claimed: false });
+          startPreparing({ needsAddChain: false });
+        },
+        (e) => {
+          if (!alive.current || ctl.run !== run) return;
+          const m = cartReason(e);
+          set({ ...fresh(), run: ctl.run + 1, steps: ctl.steps, state: "idle", reason: "CHAIN_SWITCH_FAILED", message: m.reason === "USER_REJECTED" ? "You rejected the network request." : m.message });
+        }
+      );
+      return;
+    }
+    const prepared = ctl.prepared;
+    const item = k.store.getSnapshot().items.find((i) => itemKey(i.config) === action.key);
+    if (!prepared || prepared.key !== action.key || !item || item.quantity !== prepared.quantity || k.store.revision !== prepared.revision) {
+      startPreparing();
+      return;
+    }
+    const pending = {
+      id: newId(),
+      lineKey: prepared.key,
+      config: prepared.config,
+      payer: prepared.payer,
+      recipient: prepared.recipient,
+      quantity: prepared.quantity,
+      holdings: prepared.holdings,
+      hash: null,
+      hashAt: null,
+      createdAt: nowSec2()
+    };
+    try {
+      if (!k.store.writePending(pending)) {
+        startPreparing();
+        return;
+      }
+    } catch (e) {
+      const m = cartReason(e);
+      set({ state: "blocked", action: null, reason: m.reason, message: m.message, prepared: null, claimed: false });
+      return;
+    }
+    markCallOpen(pending.id);
+    set({ state: "sending", claimed: true, waiting: { id: pending.id, key: pending.lineKey, memHash: null } });
+    let memHash = null;
+    let hashWriteFailed = false;
+    const sent = sendMint(prepared, {
+      onHash: (hash) => {
+        memHash = hash;
+        try {
+          k.store.setHash(pending.id, hash, nowSec2());
+        } catch (e16) {
+          hashWriteFailed = true;
+        }
+      }
+    });
+    void sent.then(
+      async (hash) => {
+        markCallClosed(pending.id);
+        if (!alive.current || ctl.run !== run) return;
+        setStep(pending.lineKey, { txHash: hash });
+        if (hashWriteFailed) {
+          setStep(pending.lineKey, { status: "unknown", message: "Still confirming" });
+          return set({ state: "checking", action: null, message: "Still confirming", prepared: null, waiting: { id: pending.id, key: pending.lineKey, memHash }, claimed: false });
+        }
+        let receipt;
+        try {
+          receipt = await waitMint(k.env.client, { hash, tokenContract: prepared.config.creatorContract, recipient: prepared.recipient });
+        } catch (e17) {
+          receipt = null;
+        }
+        if (!alive.current || ctl.run !== run) return;
+        if (!receipt) {
+          setStep(pending.lineKey, { status: "unknown", message: "Still confirming" });
+          return set({ state: "checking", action: null, message: "Still confirming", prepared: null, waiting: { id: pending.id, key: pending.lineKey, memHash }, claimed: false });
+        }
+        const out = await k.settle(pending.id, { receipt, memHash });
+        applyOutcome(pending.lineKey, pending.id, out, memHash);
+      },
+      async (e) => {
+        markCallClosed(pending.id);
+        if (!alive.current || ctl.run !== run) return;
+        if (e instanceof CartError && e.reason === "REQUEST_NOT_SENT") {
+          markNotSent(pending.id);
+          const out2 = await k.settle(pending.id);
+          return applyOutcome(pending.lineKey, pending.id, out2, null);
+        }
+        if (_chunkOO6QQT3Mcjs.isRejection.call(void 0, e)) {
+          try {
+            k.store.removePending(pending.id);
+          } catch (e18) {
+          }
+          setStep(pending.lineKey, { status: "failed", reason: "USER_REJECTED", message: "You rejected the request." });
+          return set({ state: "paused", action: null, reason: "USER_REJECTED", message: "You rejected the request.", prepared: null, waiting: null, claimed: false });
+        }
+        const out = await k.settle(pending.id, { memHash });
+        applyOutcome(pending.lineKey, pending.id, out, memHash);
+      }
+    );
+  }, [applyOutcome, set, setStep, startPreparing]);
+  const check = _react.useCallback.call(void 0, () => {
+    const ctl = cRef.current;
+    if (ctl.state !== "checking" || !ctl.waiting || ctl.claimed) return;
+    ctl.claimed = true;
+    const w = ctl.waiting;
+    const k = cartRef.current;
+    const run = ctl.run;
+    void (async () => {
+      const p = k.store.getSnapshot().pending.find((x) => x.id === w.id);
+      if (p && p.hash === null && w.memHash) {
+        try {
+          k.store.setHash(w.id, w.memHash, nowSec2());
+        } catch (e19) {
+        }
+      }
+      const out = await k.settle(w.id, { memHash: w.memHash });
+      if (!alive.current || ctl.run !== run) return;
+      ctl.claimed = false;
+      if (out && (out.kind === "waiting" || out.kind === "unavailable")) {
+        setStep(w.key, { status: "unknown", reason: out.kind === "unavailable" ? out.reason : null, message: out.kind === "waiting" ? "Still confirming" : out.message });
+        return set({ state: "checking", reason: out.kind === "unavailable" ? out.reason : null, message: out.kind === "waiting" ? "Still confirming" : out.message });
+      }
+      applyOutcome(w.key, w.id, out, w.memHash);
+    })();
+  }, [applyOutcome, set, setStep]);
+  const retry = _react.useCallback.call(void 0, () => {
+    const ctl = cRef.current;
+    if (ctl.state !== "paused" || !ctl.currentKey) return;
+    setStep(ctl.currentKey, { status: "pending", reason: null, message: null, txHash: null });
+    startPreparing();
+  }, [setStep, startPreparing]);
+  const skip = _react.useCallback.call(void 0, () => {
+    const ctl = cRef.current;
+    if (ctl.state !== "paused" || !ctl.currentKey) return;
+    const s = ctl.steps.find((x) => x.key === ctl.currentKey);
+    setStep(ctl.currentKey, { status: "skipped", reason: _nullishCoalesce(_optionalChain([s, 'optionalAccess', _67 => _67.reason]), () => ( null)), message: _nullishCoalesce(_optionalChain([s, 'optionalAccess', _68 => _68.message]), () => ( null)) });
+    startPreparing();
+  }, [setStep, startPreparing]);
+  const stop = _react.useCallback.call(void 0, () => {
+    const ctl = cRef.current;
+    if (ctl.state !== "ready" && ctl.state !== "checking" && ctl.state !== "paused") return;
+    set({ state: "done", action: null, prepared: null, claimed: false, run: ctl.run + 1 });
+  }, [set]);
+  const reset = _react.useCallback.call(void 0, () => {
+    const ctl = cRef.current;
+    if (ctl.state !== "blocked" && ctl.state !== "done") return;
+    set({ ...fresh(), run: ctl.run + 1 });
+  }, [set]);
+  const accountAddress = _nullishCoalesce(_optionalChain([cart, 'access', _69 => _69.account, 'optionalAccess', _70 => _70.address]), () => ( null));
+  const accountChain = _nullishCoalesce(_optionalChain([cart, 'access', _71 => _71.account, 'optionalAccess', _72 => _72.chainId]), () => ( null));
+  const lastAccount = _react.useRef.call(void 0, { address: accountAddress, chain: accountChain });
+  _react.useEffect.call(void 0, () => {
+    const prev = lastAccount.current;
+    lastAccount.current = { address: accountAddress, chain: accountChain };
+    const ctl = cRef.current;
+    if (prev.address === accountAddress && prev.chain === accountChain) return;
+    if (ctl.state !== "preparing" && ctl.state !== "ready" && ctl.state !== "paused") return;
+    if (accountAddress === null) {
+      set({ ...fresh(), run: ctl.run + 1 });
+      return;
+    }
+    if (prev.address !== accountAddress) {
+      startPreparing({ initialDone: false, payer: null });
+      return;
+    }
+    if (ctl.state === "ready") startPreparing();
+  }, [accountAddress, accountChain, set, startPreparing]);
+  _react.useEffect.call(void 0, () => {
+    const ctl = cRef.current;
+    if (ctl.state !== "ready" || !ctl.prepared) return;
+    const p = ctl.prepared;
+    const item = value.items.find((i) => itemKey(i.config) === p.key);
+    if (!item || item.quantity !== p.quantity || store.revision !== p.revision) startPreparing();
+  }, [value, store, startPreparing]);
+  const published = cRef.current;
+  return _react.useMemo.call(void 0, () => {
+    const live = published.steps.filter((s) => s.status !== "skipped");
+    const idx = published.currentKey === null ? -1 : live.findIndex((s) => s.key === published.currentKey);
+    return {
+      state: published.state,
+      action: published.action,
+      reason: published.reason,
+      message: published.message,
+      steps: published.steps.map((s) => ({ ...s })),
+      current: idx >= 0 ? idx + 1 : null,
+      checkout,
+      confirm,
+      check,
+      retry,
+      skip,
+      stop,
+      reset
+    };
+  }, [c.state, c.action, c.reason, c.message, c.steps, c.currentKey, checkout, confirm, check, retry, skip, stop, reset, renderKey(published)]);
+}
+function renderKey(ctl) {
+  return `${ctl.run}|${ctl.state}|${ctl.steps.map((s) => s.status).join(",")}|${_nullishCoalesce(ctl.message, () => ( ""))}|${_nullishCoalesce(ctl.currentKey, () => ( ""))}`;
+}
+
+// src/cart/useHoldings.ts
+
+
+function useHoldings(configs, opts) {
+  const k = useCartInternals();
+  const { collected } = useCart();
+  const wallet = _react.useMemo.call(void 0, () => {
+    const w = _nullishCoalesce(_nullishCoalesce(_optionalChain([opts, 'optionalAccess', _73 => _73.wallet]), () => ( _optionalChain([k, 'access', _74 => _74.account, 'optionalAccess', _75 => _75.address]))), () => ( null));
+    return w ? _viem.getAddress.call(void 0, w) : null;
+  }, [_optionalChain([opts, 'optionalAccess', _76 => _76.wallet]), _optionalChain([k, 'access', _77 => _77.account, 'optionalAccess', _78 => _78.address])]);
+  const keyed = _react.useMemo.call(void 0, () => {
+    const out = [];
+    for (const c of configs) {
+      try {
+        const config = canonicalConfig(c, k.chainId);
+        out.push({ key: itemKey(config), config });
+      } catch (e20) {
+      }
+    }
+    return out;
+  }, [configs, k.chainId]);
+  const listKey = keyed.map((x) => x.key).join("|");
+  const [read, setRead] = _react.useState.call(void 0, { wallet: null, byKey: {} });
+  const [tick, setTick] = _react.useState.call(void 0, 0);
+  const run = _react.useRef.call(void 0, 0);
+  _react.useEffect.call(void 0, () => {
+    const id = ++run.current;
+    if (!wallet || keyed.length === 0) return;
+    const round = new AbortController();
+    const providerSignal = k.getSignal();
+    const onProviderAbort = () => round.abort();
+    providerSignal.addEventListener("abort", onProviderAbort);
+    const signal = round.signal;
+    const live = () => run.current === id && !signal.aborted;
+    void Promise.all(
+      keyed.map(async ({ key, config }) => {
+        let holding = null;
+        try {
+          holding = await withRetries(
+            () => k.limiter.run(async () => {
+              if (signal.aborted) throw signal.reason;
+              const ctx = { ...k.env.ctxFor(key), signal };
+              const drop = await _asyncNullishCoalesce(await _asyncOptionalChain([k, 'access', async _79 => _79.lineData, 'call', async _80 => _80(key), 'optionalAccess', async _81 => _81.drop]), async () => ( await adapter.readDrop(ctx, config)));
+              if (signal.aborted) throw signal.reason;
+              const query = _nullishCoalesce(_optionalChain([adapter, 'access', _82 => _82.holdingsQuery, 'optionalCall', _83 => _83(drop, "display")]), () => ( null));
+              if (!query || !adapter.readHoldings) return null;
+              const n = await adapter.readHoldings(ctx, query, wallet);
+              const kind = query.kind === "balance-1155" ? "owned" : query.kind === "total-mints" ? "minted" : "owned-in-contract";
+              return { kind, count: Number(n) };
+            }),
+            CART_TIMING.retryDelaysMs,
+            () => signal.aborted,
+            signal
+          );
+        } catch (e21) {
+          holding = null;
+        }
+        if (live()) setRead((prev) => prev.wallet === wallet ? { wallet, byKey: { ...prev.byKey, [key]: holding } } : { wallet, byKey: { [key]: holding } });
+      })
+    );
+    return () => {
+      round.abort();
+      providerSignal.removeEventListener("abort", onProviderAbort);
+    };
+  }, [wallet, listKey, collected.length, tick, k]);
+  const byKey = _react.useMemo.call(void 0, () => wallet && read.wallet === wallet ? read.byKey : {}, [wallet, read]);
+  const loading = wallet !== null && keyed.some((x) => !(x.key in byKey));
+  const get = _react.useCallback.call(void 0, 
+    (config) => {
+      try {
+        return byKey[itemKey(canonicalConfig(config, k.chainId))];
+      } catch (e22) {
+        return void 0;
+      }
+    },
+    [byKey, k.chainId]
+  );
+  const refresh = _react.useCallback.call(void 0, () => setTick((t) => t + 1), []);
+  return _react.useMemo.call(void 0, () => ({ wallet, byKey, get, loading, refresh }), [wallet, byKey, get, loading, refresh]);
+}
+
+// src/cart/AddToCartButton.ts
+
+var LABELS = {
+  add: "Add to cart",
+  adding: "Adding\u2026",
+  "in-cart": "In cart",
+  locked: "Confirming\u2026",
+  unconfirmed: "Check your wallet",
+  "sold-out": "Sold out",
+  upcoming: "Not started",
+  unsupported: "Unavailable"
+};
+function AddToCartButton(props) {
+  const { config, quantity = 1, className, children } = props;
+  const cart = useCart();
+  const [adding, setAdding] = _react.useState.call(void 0, false);
+  const [result, setResult] = _react.useState.call(void 0, null);
+  const inCart = cart.has(config);
+  const same = (c) => {
+    try {
+      return c.creatorContract.toLowerCase() === config.creatorContract.toLowerCase() && BigInt(c.instanceId) === BigInt(config.instanceId) && _optionalChain([c, 'access', _84 => _84.extension, 'optionalAccess', _85 => _85.toLowerCase, 'call', _86 => _86()]) === _optionalChain([config, 'access', _87 => _87.extension, 'optionalAccess', _88 => _88.toLowerCase, 'call', _89 => _89()]);
+    } catch (e23) {
+      return false;
+    }
+  };
+  const line = inCart ? _nullishCoalesce(cart.lines.find((l) => same(l.config)), () => ( null)) : null;
+  const prior = cart.unconfirmed.some((u) => same(u.config));
+  let state = "add";
+  if (adding) state = "adding";
+  else if (_optionalChain([line, 'optionalAccess', _90 => _90.state]) === "locked") state = "locked";
+  else if (_optionalChain([line, 'optionalAccess', _91 => _91.state]) === "unsupported") state = "unsupported";
+  else if (inCart) state = _optionalChain([line, 'optionalAccess', _92 => _92.state]) === "sold-out" ? "sold-out" : _optionalChain([line, 'optionalAccess', _93 => _93.state]) === "upcoming" ? "upcoming" : "in-cart";
+  else if (prior) state = "unconfirmed";
+  const add = _react.useCallback.call(void 0, 
+    (opts) => {
+      if (adding) return;
+      setAdding(true);
+      cart.add(config, quantity, opts).then(
+        (r) => {
+          setResult(r);
+          setAdding(false);
+        },
+        () => {
+          setResult(null);
+          setAdding(false);
+        }
+      );
+    },
+    [adding, cart, config, quantity]
+  );
+  const render = { state, result, line, add };
+  if (typeof children === "function") return children(render);
+  const disabled = state === "adding" || state === "in-cart" || state === "locked" || state === "sold-out" || state === "upcoming" || state === "unsupported";
+  return _react.createElement.call(void 0, 
+    "button",
+    {
+      type: "button",
+      className,
+      "data-state": state,
+      disabled,
+      "aria-busy": state === "adding" ? true : void 0,
+      onClick: () => add()
+    },
+    _nullishCoalesce(children, () => ( LABELS[state]))
+  );
+}
+
+
+
+
+
+
+
+
+exports.AddToCartButton = AddToCartButton; exports.CartError = CartError; exports.CartProvider = CartProvider; exports.openseaChain = openseaChain; exports.useCart = useCart; exports.useCheckout = useCheckout; exports.useHoldings = useHoldings;
+//# sourceMappingURL=cart.cjs.map