@seedprotocol/publish 0.4.17 → 0.4.20

package/dist/index-BfABV7U1.js

@@ -0,0 +1,4840 @@
+import { getGetAdditionalSyncAddresses as An, getAttesterForSeed as vn, getVersionsForSeedUid as Sn, getMetadataAttestationUidsForSeedUid as En, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as In, updateSeedRevokedAt as Pn, setGetPublisherForNewSeeds as Un, setRevokeExecutor as Tn, setAdditionalSyncAddresses as Dn, DEFAULT_ARWEAVE_GRAPHQL_URL as xn, client as ft, getSegmentedItemProperties as st, setSchemaUidForModel as He, setSchemaUidForSchemaDefinition as ie, INTERNAL_DATA_TYPES as Cn, getEasSchemaForItemProperty as Rn, getRelatedItemsForPublish as _n, BaseArweaveClient as Ln, Item as se, getCorrectId as Nt, BaseFileManager as j, getUploadPipelineTransactionStatus as Mn, BaseDb as B, arweaveL1FinalizeJobs as De, resolvePublishPayloadValues as ht, getItemPropertiesFromEas as On, updateVersionUid as Bn, itemHasPublishUploadCandidates as Nn, isItemOwned as Ft, validateItemForPublish as Fn, publishProcesses as P, uploadProcesses as kn } from "@seedprotocol/sdk";
+import { prepareContractCall as C, readContract as _, createThirdwebClient as Hn, getContract as V, sendTransaction as k, waitForReceipt as H, parseEventLogs as rt, prepareEvent as Y } from "thirdweb";
+import { createWallet as Ce, inAppWallet as kt } from "thirdweb/wallets";
+import { useActiveAccount as $n, ThirdwebProvider as Vn, ConnectButton as qn, darkTheme as Wn } from "thirdweb/react";
+import { isContractDeployed as Gn } from "thirdweb/utils";
+import { useState as Ae, useRef as Ht, useEffect as te, createContext as jn, useContext as Yn, useMemo as $t } from "react";
+import { optimismSepolia as E } from "thirdweb/chains";
+import K from "debug";
+import { encodeAbiParameters as Vt, decodeAbiParameters as Jn } from "viem";
+import { jsx as me, jsxs as zn } from "react/jsx-runtime";
+import { SeedProvider as Zn, useLiveQuery as ve } from "@seedprotocol/react";
+import { getInstalledModules as Kn, installModule as Qn } from "thirdweb/modules";
+import { SchemaEncoder as Xn, ZERO_BYTES32 as ea, NO_EXPIRATION as ta, SchemaRegistry as $e, ZERO_ADDRESS as Xe } from "@ethereum-attestation-service/eas-sdk";
+import { fromPromise as he, fromCallback as ye, setup as qt, assign as T, enqueueActions as Le, createActor as et } from "xstate";
+import na from "arweave";
+import { ethers as N } from "ethers";
+import { readFile as aa } from "node:fs/promises";
+import { and as sa, eq as Z, desc as fe, notInArray as ra, inArray as oa } from "drizzle-orm";
+import { useSelector as ia } from "@xstate/react";
+async function ca(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x8878ed33",
+      [
+        {
+          type: "address",
+          name: "_adminSigner"
+        },
+        {
+          type: "bytes",
+          name: "_data"
+        }
+      ],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: [e.adminSigner, e.data]
+  });
+}
+function da(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0xd8fd8f44",
+      [
+        {
+          type: "address",
+          name: "_admin"
+        },
+        {
+          type: "bytes",
+          name: "_data"
+        }
+      ],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: [e.admin, e.data]
+  });
+}
+const Wt = "0x4200000000000000000000000000000000000020", la = "0x44d562ac1d7cd77e232978687fea027ace48f719cf1d58c7888e509663bb87fc", Gt = "0x76f47d88bfaf670f5208911181fcdc0e160cb16d", jt = "0x4200000000000000000000000000000000000021", yt = "0xcd8c945872df8e664e55cf8885c85ea3ea8f2148", L = {
+  SUCCESS: "success",
+  FAILURE: "failure"
+}, ua = [
+  "pollingForConfirmation",
+  "uploadingData",
+  "uploadingViaBundler"
+], pa = 3e4, ma = K("permaPress:helpers:thirdweb");
+let Ve = null;
+function R() {
+  if (!Ve) {
+    const { thirdwebClientId: e } = x();
+    Ve = Hn({ clientId: e });
+  }
+  return Ve;
+}
+const Nr = [
+  // embeddedWallet(),
+  Ce("io.metamask")
+  // createWallet("com.coinbase.wallet"),
+  // createWallet("me.rainbow"),
+], Fr = () => {
+  const [e, t] = Ae(null);
+  return Ce("io.metamask"), Ht(!1), te(() => {
+    (async () => {
+    })();
+  }, []), e;
+}, kr = () => {
+  const e = $n(), [t, n] = Ae(null);
+  return te(() => {
+    !e || !e.address || n(V({
+      client: R(),
+      chain: E,
+      address: e.address
+    }));
+  }, [e]), t;
+}, Yt = () => {
+  const { thirdwebAccountFactoryAddress: e } = x();
+  return V({
+    client: R(),
+    chain: E,
+    address: e
+  });
+};
+async function Jt(e, t = "0x") {
+  const n = Yt();
+  return ca({
+    contract: n,
+    adminSigner: e,
+    data: t
+  });
+}
+async function Re(e) {
+  const t = V({
+    client: R(),
+    chain: E,
+    address: e
+  });
+  return Gn(t);
+}
+async function gt(e) {
+  if (!e)
+    return { needsDeploy: !0 };
+  if (await Re(e.address))
+    return { address: e.address, account: e };
+  const n = await Jt(e.address);
+  return await Re(n) ? { address: n, account: e } : { needsDeploy: !0 };
+}
+const Hr = [
+  Ce("io.metamask"),
+  Ce("me.rainbow")
+], fa = async (e) => {
+  const t = Yt(), n = da({
+    contract: t,
+    admin: e.address,
+    data: "0x"
+  }), a = await k({
+    account: e,
+    transaction: n
+  });
+  ma("createAccountTx result:", a);
+  const s = await H({
+    client: R(),
+    transactionHash: a.transactionHash,
+    chain: E
+  });
+  if (!s)
+    throw new Error("Failed to deploy smart wallet");
+  return s;
+}, $r = {
+  name: "Seed Protocol",
+  description: "Seed Protocol",
+  url: "https://seedprotocol.io"
+};
+async function ot(e = E) {
+  const t = Me();
+  await t.autoConnect({ client: R(), chain: e });
+  const n = t.getAccount();
+  if (!n)
+    throw new Error("Failed to get managed account");
+  return n.address;
+}
+async function ha() {
+  try {
+    const e = it();
+    return await e.autoConnect({ client: R(), chain: E }), e.getAccount() ?? null;
+  } catch {
+    return null;
+  }
+}
+const Me = () => kt({
+  auth: {
+    options: [
+      "farcaster",
+      "email",
+      "passkey",
+      "phone"
+    ]
+  },
+  executionMode: {
+    mode: "EIP4337",
+    smartAccount: {
+      chain: E,
+      factoryAddress: Gt,
+      gasless: !0
+    }
+  }
+  // executionMode: {
+  //   mode: 'EIP4337',
+  //   smartAccount: {
+  //     chain: optimismSepolia,
+  //     factoryAddress: thirdwebAccountFactoryAddress,
+  //     gasless: true,
+  //     overrides: {
+  //       // Custom paymaster that passes through but lets you modify the UserOp
+  //       paymaster: async (userOp) => {
+  //         const hexifyBigInts: any = (obj: any) => {
+  //           if (typeof obj === "bigint") return `0x${obj.toString(16)}`;
+  //           if (Array.isArray(obj)) return obj.map(hexifyBigInts);
+  //           if (obj && typeof obj === "object") {
+  //             return Object.fromEntries(
+  //               Object.entries(obj).map(([k, v]) => [k, hexifyBigInts(v)])
+  //             );
+  //           }
+  //           return obj;
+  //         };
+  //         const chainIdHex = `0x${optimismSepolia.id.toString(16)}`;
+  //         // Increase callGasLimit before sending to paymaster
+  //         const modifiedUserOp = hexifyBigInts({
+  //           ...userOp,
+  //           callGasLimit: BigInt(8000000), // Double it, or set a fixed value
+  //         });
+  //         console.log("[SmartWallet Paymaster]", getPublishConfig().thirdwebClientId);
+  //         // Call thirdweb's default paymaster endpoint
+  //         const response = await fetch(
+  //           `https://${optimismSepolia.id}.bundler.thirdweb.com/v2`,
+  //           {
+  //             method: "POST",
+  //             headers: { 
+  //               "Content-Type": "application/json",
+  //               "X-Client-Id": getPublishConfig().thirdwebClientId,
+  //             },
+  //             body: JSON.stringify({
+  //               id: 1,
+  //               jsonrpc: "2.0",
+  //               method: "pm_sponsorUserOperation",
+  //               params: [modifiedUserOp, '0x5ff137d4b0fdcd49dca30c7cf57e578a026d2789', chainIdHex],
+  //             }),
+  //           }
+  //         );
+  //         const data = await response.json();
+  //         console.log("[SmartWallet Paymaster Response]", data);
+  //         return {
+  //           paymasterAndData: data.result.paymasterAndData,
+  //           preVerificationGas: data.result.preVerificationGas,
+  //           verificationGasLimit: data.result.verificationGasLimit,
+  //           callGasLimit: data.result.callGasLimit,
+  //         };
+  //       },
+  //       execute: (accountContract, transaction) => {
+  //         // Log the gas that was set on the transaction
+  //         console.log("[SmartWallet Execute]", {
+  //           gas: transaction.gas,
+  //           to: transaction.to,
+  //           dataLength: transaction.data?.length,
+  //         });
+  //         // Return the default execute call — don't change behavior,
+  //         // just observe what's being passed through
+  //         return prepareContractCall({
+  //           contract: accountContract,
+  //           method: "function execute(address, uint256, bytes)",
+  //           params: [
+  //             transaction.to ?? "",
+  //             transaction.value ?? 0n,
+  //             transaction.data ?? "0x",
+  //           ],
+  //           gas: transaction.gas, // Pass through whatever was set
+  //         });
+  //       },
+  //     },
+  //   }
+  // }
+}), it = () => kt({
+  auth: {
+    options: [
+      "farcaster",
+      "email",
+      "passkey",
+      "phone"
+    ]
+  },
+  executionMode: {
+    mode: "EIP7702",
+    sponsorGas: !0
+  }
+}), ya = () => [
+  it()
+], ga = [
+  { type: "error", name: "AccessDenied", inputs: [] },
+  { type: "error", name: "AlreadyRevoked", inputs: [] },
+  { type: "error", name: "InvalidRevocation", inputs: [] },
+  { type: "error", name: "InvalidRevocations", inputs: [] },
+  { type: "error", name: "InvalidSchema", inputs: [] },
+  { type: "error", name: "Irrevocable", inputs: [] },
+  { type: "error", name: "NotFound", inputs: [] },
+  { type: "error", name: "NotPayable", inputs: [] },
+  { type: "error", name: "InsufficientValue", inputs: [] },
+  { type: "error", name: "InvalidLength", inputs: [] }
+], wa = () => Y({
+  signature: "event Attested(address indexed recipient, address indexed attester, bytes32 uid, bytes32 indexed schemaUID)"
+}), ba = "0x0000000000000000000000000000000000000000", W = "0x" + "0".repeat(64);
+function wt(e, t, n) {
+  const { easContractAddress: a } = x(), s = V({
+    client: e,
+    chain: t,
+    address: a
+  });
+  return C({
+    contract: s,
+    method: "function attest((bytes32 schema,(address recipient,uint64 expirationTime,bool revocable,bytes32 refUID,bytes data,uint256 value) data) request) payable returns (bytes32)",
+    params: [
+      {
+        schema: n.schema,
+        data: {
+          recipient: n.data.recipient ?? ba,
+          expirationTime: n.data.expirationTime ?? 0n,
+          revocable: n.data.revocable ?? !0,
+          refUID: n.data.refUID,
+          data: n.data.data,
+          value: n.data.value ?? 0n
+        }
+      }
+    ]
+  });
+}
+function Aa(e, t, n) {
+  const { easContractAddress: a } = x(), s = V({
+    client: e,
+    chain: t,
+    address: a
+  });
+  return C({
+    contract: s,
+    method: "function multiAttest((bytes32 schema,(address recipient,uint64 expirationTime,bool revocable,bytes32 refUID,bytes data,uint256 value)[] data)[] requests) payable returns (bytes32[])",
+    params: [n]
+  });
+}
+function qe(e) {
+  return Vt([{ type: "bytes32" }], [e]);
+}
+function bt(e, t) {
+  if (!e.logs?.length) return;
+  const n = t.toLowerCase(), a = e.logs.filter((s) => s.address && s.address.toLowerCase() === n);
+  if (a.length)
+    try {
+      const o = rt({
+        logs: a,
+        events: [wa()],
+        strict: !1
+      })[0]?.args?.uid;
+      if (o && o !== W) return o;
+    } catch {
+    }
+}
+function va(e, t, n) {
+  const { easContractAddress: a } = x(), s = V({
+    client: e,
+    chain: t,
+    address: a,
+    abi: [...ga]
+  });
+  return C({
+    contract: s,
+    method: "function multiRevoke((bytes32 schema,(bytes32 uid,uint256 value)[] data)[] multiRequests) payable",
+    params: [
+      n.map((r) => ({
+        schema: r.schema,
+        data: r.data.map((o) => ({
+          uid: o.uid,
+          value: o.value ?? 0n
+        }))
+      }))
+    ]
+  });
+}
+async function Sa(e) {
+  const { account: t, attester: n } = e;
+  if (!n || t.address.toLowerCase() === n.toLowerCase())
+    return t;
+  const a = An();
+  if (a) {
+    const s = await a(), r = n.toLowerCase();
+    if (s?.some((o) => o?.toLowerCase() === r))
+      throw new Error(
+        "Revocation not supported for items published via the modular executor."
+      );
+  }
+  try {
+    const s = await Jt(t.address), r = n.toLowerCase(), o = s.toLowerCase();
+    if (r === o && await Re(s)) {
+      const i = Me();
+      await i.autoConnect({
+        client: R(),
+        chain: E
+      });
+      const l = i.getAccount();
+      if (l)
+        return l;
+    }
+  } catch {
+  }
+  return t;
+}
+async function Ea(e) {
+  const { seedLocalId: t, seedUid: n, seedSchemaUid: a } = e, s = await ha();
+  if (!s)
+    throw new Error("No wallet connected. Connect a wallet to revoke attestations.");
+  const r = await vn({ seedLocalId: t, seedUid: n }), o = await Sa({ account: s, attester: r }), c = R(), [i, l] = await Promise.all([
+    Sn(n),
+    En(n)
+  ]), d = i.map((u) => u.uid), m = /* @__PURE__ */ new Map();
+  for (const { uid: u, schemaUid: y } of l) {
+    const f = m.get(y) ?? [];
+    f.push(u), m.set(y, f);
+  }
+  const p = [];
+  for (const [u, y] of m)
+    y.length > 0 && p.push({
+      schema: u,
+      data: y.map((f) => ({ uid: f }))
+    });
+  d.length > 0 && p.push({
+    schema: In,
+    data: d.map((u) => ({ uid: u }))
+  }), p.push({
+    schema: a,
+    data: [{ uid: n }]
+  });
+  for (const u of p) {
+    if (u.data.length === 0) continue;
+    const y = va(c, E, [u]);
+    try {
+      const f = await k({ account: o, transaction: y });
+      await H({
+        client: c,
+        chain: E,
+        transactionHash: f.transactionHash
+      });
+    } catch (f) {
+      const b = f instanceof Error ? f.message : String(f);
+      if (b.includes("AccessDenied") || b.includes("0x4ca88867"))
+        throw new Error(
+          "Only the original attester can revoke attestations. Connect the wallet that published this item."
+        );
+      if (b.includes("AlreadyRevoked"))
+        continue;
+      throw f;
+    }
+  }
+  const h = Math.floor(Date.now() / 1e3);
+  await Pn({ seedLocalId: t, revokedAt: h });
+}
+let ct = null;
+function Ia(e) {
+  ct = e;
+}
+function Pa() {
+  return ct;
+}
+function zt(e) {
+  Ia(e), Un(async () => {
+    try {
+      return await ot(E);
+    } catch {
+      return;
+    }
+  }), Tn(Ea), import("./worker-F-UKvyIU.js").then((t) => {
+    t.startArweaveL1FinalizeWorker();
+  }), Dn(async () => e.useModularExecutor && e.modularAccountModuleContract ? [e.modularAccountModuleContract] : []);
+}
+const Vr = zt;
+function x() {
+  const e = ct;
+  if (!e)
+    throw new Error(
+      "@seedprotocol/publish: Call initPublish() or ensure PublishProvider is mounted with config before using the publish package"
+    );
+  const t = e.useArweaveBundler ?? !1, n = e.arweaveUploadVerificationBaseUrl ?? e.uploadApiBaseUrl, a = e.arweaveGraphqlUrl ?? xn;
+  return {
+    ...e,
+    thirdwebAccountFactoryAddress: Gt,
+    easContractAddress: jt,
+    useIntegerLocalIds: e.useIntegerLocalIds ?? !1,
+    useDirectEas: e.useDirectEas ?? !1,
+    modularAccountModuleData: e.modularAccountModuleData ?? "0x",
+    useModularExecutor: e.useModularExecutor ?? !1,
+    useArweaveBundler: t,
+    arweaveUploadVerificationBaseUrl: n,
+    arweaveGraphqlUrl: a,
+    autoDeployManagedAccount: e.autoDeployManagedAccount ?? !1
+  };
+}
+class Zt extends Error {
+  constructor(t, n, a, s, r = "METADATA_PROPERTIES_MISSING") {
+    super(t), this.seedLocalId = n, this.expectedSchemas = a, this.foundSchemas = s, this.code = r, this.name = "AttestationVerificationError";
+  }
+}
+class Q extends Error {
+  constructor(t, n, a, s) {
+    super(t), this.code = n, this.managedAddress = a, this.name = "ManagedAccountPublishError", this.underlyingCause = s;
+  }
+  /** Original error when connection or deployment failed (avoids shadowing `Error.cause`). */
+  underlyingCause;
+}
+function At(e) {
+  if (e instanceof Q) return !0;
+  if (typeof e != "object" || e === null) return !1;
+  const t = e;
+  return t.name === "ManagedAccountPublishError" && typeof t.code == "string";
+}
+function Ua(e, t = 700) {
+  if (e == null) return "";
+  if (e instanceof Error) {
+    const n = e.cause instanceof Error ? ` | cause: ${e.cause.message}` : "";
+    return (e.message + n).slice(0, t);
+  }
+  if (typeof e == "object") {
+    const n = e, a = [];
+    if (typeof n.message == "string" && a.push(n.message), typeof n.shortMessage == "string" && a.push(n.shortMessage), typeof n.details == "string" && a.push(n.details), typeof n.reason == "string" && a.push(n.reason), a.length) return a.join(" | ").slice(0, t);
+    try {
+      return JSON.stringify(e).slice(0, t);
+    } catch {
+      return String(e).slice(0, t);
+    }
+  }
+  return String(e).slice(0, t);
+}
+function Ta(e) {
+  return /Router:\s*function does not exist/i.test(Ua(e));
+}
+const Kt = jn(null);
+function Da() {
+  const e = Yn(Kt);
+  if (!e)
+    throw new Error("usePublishConfig must be used within PublishProvider");
+  return e;
+}
+const qr = ({
+  children: e,
+  config: t,
+  queryClient: n,
+  queryClientRef: a
+}) => (te(() => {
+  t && zt(t);
+}, [t]), /* @__PURE__ */ me(Kt.Provider, { value: t ?? Pa(), children: /* @__PURE__ */ me(Vn, { children: /* @__PURE__ */ me(Zn, { queryClient: n, queryClientRef: a, children: e }) }) })), xa = "The executor module could not be installed on your publishing account on Optimism Sepolia. Reconnect and try again, or contact support if this persists.";
+async function tt(e, t, n) {
+  const { modularAccountModuleContract: a } = n;
+  if (!a) return;
+  const s = V({
+    client: R(),
+    chain: E,
+    address: e
+  });
+  try {
+    const r = await Kn({ contract: s }), o = a.toLowerCase();
+    if (r.some(
+      (d) => d.implementation?.toLowerCase() === o
+    )) return;
+    const i = Qn({
+      contract: s,
+      moduleContract: a,
+      data: Vt([{ type: "address" }], [jt])
+    }), l = await k({ transaction: i, account: t });
+    await H({
+      client: R(),
+      transactionHash: l.transactionHash,
+      chain: E
+    });
+  } catch (r) {
+    if (Ta(r))
+      return;
+    throw new Q(
+      xa,
+      "EXECUTOR_MODULE_NOT_INSTALLED",
+      e,
+      r
+    );
+  }
+}
+function Se(e) {
+  console.error("[ConnectButton] Wallet setup / module install failed:", e), x().onWalletSetupWarning?.(e);
+}
+async function Ca(e, t, n) {
+  if (n.modularAccountModuleContract) {
+    if (n.useModularExecutor) {
+      if (!t) {
+        Se(
+          new Error(
+            "Executor module: managed account address not available yet (managed wallet may still be syncing)."
+          )
+        );
+        return;
+      }
+      try {
+        const a = Me();
+        await a.autoConnect({ client: R(), chain: E });
+        const s = a.getAccount();
+        if (!s) {
+          Se(new Error("Executor module: managed wallet has no account"));
+          return;
+        }
+        await tt(t, s, n);
+      } catch (a) {
+        Se(a);
+      }
+      return;
+    }
+    try {
+      await tt(e.address, e, n);
+    } catch (a) {
+      Se(a);
+    }
+  }
+}
+const Wr = () => {
+  const e = Da(), t = async () => {
+    console.log("[ConnectButton] Disconnected");
+    try {
+      await ft.setAddresses([]);
+    } catch (a) {
+      console.warn("[ConnectButton] Failed to clear seed client addresses:", a);
+    }
+  }, n = async (a, s) => {
+    const r = a.getAccount();
+    if (!r) return;
+    console.log("[ConnectButton] Connected", r.address);
+    const o = /* @__PURE__ */ new Set([r.address.toLowerCase()]);
+    let c;
+    if (e.useModularExecutor)
+      try {
+        c = await ot(E), o.add(c.toLowerCase());
+      } catch {
+      }
+    try {
+      await ft.setAddresses({ owned: [...o] });
+    } catch (i) {
+      console.warn("[ConnectButton] Failed to set seed client addresses:", i);
+    }
+    await Ca(r, c, e);
+  };
+  return /* @__PURE__ */ me(
+    qn,
+    {
+      client: R(),
+      wallets: ya(),
+      autoConnect: !0,
+      chain: E,
+      chains: [E],
+      onConnect: n,
+      onDisconnect: t,
+      theme: Wn({
+        colors: {
+          primaryButtonBg: "#1D2939",
+          primaryButtonText: "#FFFFFF",
+          secondaryButtonHoverBg: "#1D2939",
+          connectedButtonBg: "#101828",
+          connectedButtonBgHover: "#1D2939",
+          borderColor: "#344054"
+        }
+      })
+    }
+  );
+}, Gr = ({
+  value: e,
+  onChange: t,
+  disabled: n = !1,
+  "aria-label": a = "Publish mode"
+}) => {
+  const s = {
+    display: "inline-flex",
+    gap: 8,
+    flexWrap: "wrap"
+  }, r = (o) => ({
+    padding: "8px 14px",
+    fontSize: 13,
+    borderRadius: 8,
+    border: `1px solid ${o ? "#344054" : "#D0D5DD"}`,
+    background: o ? "#101828" : "#fff",
+    color: o ? "#fff" : "#344054",
+    cursor: n ? "not-allowed" : "pointer",
+    opacity: n ? 0.6 : 1
+  });
+  return /* @__PURE__ */ zn("div", { role: "group", "aria-label": a, style: s, children: [
+    /* @__PURE__ */ me(
+      "button",
+      {
+        type: "button",
+        disabled: n,
+        style: r(e === "patch"),
+        onClick: () => t("patch"),
+        children: "Publish updates"
+      }
+    ),
+    /* @__PURE__ */ me(
+      "button",
+      {
+        type: "button",
+        disabled: n,
+        style: r(e === "new_version"),
+        onClick: () => t("new_version"),
+        children: "New version"
+      }
+    )
+  ] });
+}, Ra = [
+  {
+    inputs: [{ internalType: "bytes32", name: "uid", type: "bytes32" }],
+    name: "getSchema",
+    outputs: [
+      {
+        components: [
+          { internalType: "bytes32", name: "uid", type: "bytes32" },
+          { internalType: "contract ISchemaResolver", name: "resolver", type: "address" },
+          { internalType: "bool", name: "revocable", type: "bool" },
+          { internalType: "string", name: "schema", type: "string" }
+        ],
+        internalType: "struct SchemaRecord",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "string", name: "schema", type: "string" },
+      { internalType: "contract ISchemaResolver", name: "resolver", type: "address" },
+      { internalType: "bool", name: "revocable", type: "bool" }
+    ],
+    name: "register",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+], _a = "0x" + "0".repeat(64);
+function La(e, t) {
+  return V({
+    client: e,
+    chain: t,
+    address: Wt,
+    abi: Ra
+  });
+}
+const Ma = "function getSchema(bytes32 uid) view returns ((bytes32 uid, address resolver, bool revocable, string schema))";
+async function Ee(e, t, n) {
+  const a = V({
+    client: e,
+    chain: t,
+    address: Wt
+    // No ABI - use string method so thirdweb parses the exact signature and produces correct selector
+  }), s = await _({
+    contract: a,
+    method: Ma,
+    params: [n]
+  });
+  return !s || s.uid === _a ? null : s;
+}
+function We(e, t, n) {
+  const a = La(e, t);
+  return C({
+    contract: a,
+    method: "register",
+    params: [n.schema, n.resolverAddress, n.revocable]
+  });
+}
+const Oa = "0x0000000000000000000000000000000000000000";
+function Ge(e, t, n) {
+  const s = new Xn("bytes32 schemaId,string name").encodeData([
+    { name: "schemaId", value: n.schemaUid, type: "bytes32" },
+    { name: "name", value: n.schemaName, type: "string" }
+  ]), { easContractAddress: r } = x(), o = V({
+    client: e,
+    chain: t,
+    address: r
+    // No ABI - use string method so thirdweb parses the exact signature
+  });
+  return C({
+    contract: o,
+    method: "function attest((bytes32 schema,(address recipient,uint64 expirationTime,bool revocable,bytes32 refUID,bytes data,uint256 value) data) request) payable returns (bytes32)",
+    params: [
+      {
+        schema: la,
+        data: {
+          recipient: Oa,
+          expirationTime: BigInt(ta),
+          revocable: !0,
+          refUID: ea,
+          data: s,
+          value: 0n
+        }
+      }
+    ]
+  });
+}
+const ce = "0x0000000000000000000000000000000000000000", de = !0;
+function je(e) {
+  return e.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+async function Ba(e) {
+  const { itemRelationProperties: t, itemImageProperties: n, itemListProperties: a } = await st(e), s = /* @__PURE__ */ new Set();
+  e.modelName && s.add(e.modelName);
+  for (const r of t) {
+    const o = r.propertyDef?.ref;
+    o && s.add(o);
+  }
+  for (const r of n) {
+    const o = r.propertyDef?.dataType;
+    o === "File" ? s.add("File") : o === "Html" ? s.add("Html") : s.add("Image");
+  }
+  for (const r of a) {
+    const o = r.propertyDef?.ref;
+    o && s.add(o);
+  }
+  return s;
+}
+async function Oe(e, t, n, a) {
+  const { itemBasicProperties: s, itemRelationProperties: r, itemImageProperties: o, itemListProperties: c } = await st(e), i = [
+    ...s,
+    ...r,
+    ...o,
+    ...c
+  ], l = /* @__PURE__ */ new Set(), d = await Ba(e), m = /* @__PURE__ */ new Set();
+  for (const f of d) {
+    const b = `bytes32 ${je(f)}`, g = $e.getSchemaUID(
+      b,
+      ce,
+      de
+    );
+    if (await Ee(n, a, g)) {
+      He({ modelName: f, schemaUid: g });
+      continue;
+    }
+    if (m.has(g)) {
+      He({ modelName: f, schemaUid: g });
+      continue;
+    }
+    try {
+      const v = We(n, a, {
+        schema: b,
+        resolverAddress: ce,
+        revocable: de
+      }), I = await k({
+        account: t,
+        transaction: v
+      });
+      await H({
+        client: n,
+        chain: a,
+        transactionHash: I.transactionHash
+      });
+    } catch (v) {
+      throw new Error(
+        `Failed to register EAS schema for model ${f}: ${v instanceof Error ? v.message : String(v)}`
+      );
+    }
+    try {
+      const v = Ge(n, a, {
+        schemaUid: g,
+        schemaName: je(f)
+      }), I = await k({
+        account: t,
+        transaction: v
+      });
+      await H({
+        client: n,
+        chain: a,
+        transactionHash: I.transactionHash
+      });
+    } catch (v) {
+      throw new Error(
+        `Failed to name EAS schema for model ${f}: ${v instanceof Error ? v.message : String(v)}`
+      );
+    }
+    m.add(g), He({ modelName: f, schemaUid: g });
+  }
+  const p = "string storage_transaction_id", h = $e.getSchemaUID(
+    p,
+    ce,
+    de
+  );
+  if (await Ee(n, a, h))
+    ie({ text: p, schemaUid: h });
+  else if (!l.has(h) && (d.has("Image") || d.has("File") || d.has("Html"))) {
+    try {
+      const f = We(n, a, {
+        schema: p,
+        resolverAddress: ce,
+        revocable: de
+      }), b = await k({ account: t, transaction: f });
+      await H({ client: n, chain: a, transactionHash: b.transactionHash });
+      const g = Ge(n, a, {
+        schemaUid: h,
+        schemaName: "storage_transaction_id"
+      }), S = await k({ account: t, transaction: g });
+      await H({ client: n, chain: a, transactionHash: S.transactionHash });
+    } catch (f) {
+      throw new Error(
+        `Failed to register EAS schema for storageTransactionId: ${f instanceof Error ? f.message : String(f)}`
+      );
+    }
+    l.add(h), ie({ text: p, schemaUid: h });
+  }
+  for (const f of i) {
+    if (!f.propertyDef) continue;
+    const b = Cn[f.propertyDef.dataType]?.eas ?? "string", g = f, S = g.storagePropertyName && g.storagePropertyName.length > 0 ? g.storagePropertyName : f.propertyName, v = je(S), I = `${b} ${v}`, D = [
+      "string",
+      "address",
+      "bool",
+      "bytes",
+      "bytes32",
+      "uint8",
+      "uint16",
+      "uint32",
+      "uint64",
+      "uint128",
+      "uint256"
+    ].includes(b) ? b : void 0;
+    let w = await Rn({
+      schemaUid: f.schemaUid,
+      propertyName: S,
+      easDataType: D
+    });
+    if (w) {
+      const A = await Ee(n, a, w.id);
+      if (A && A.schema === I) {
+        ie({ text: I, schemaUid: w.id });
+        continue;
+      }
+    }
+    const U = $e.getSchemaUID(I, ce, de);
+    if (await Ee(n, a, U)) {
+      ie({ text: I, schemaUid: U });
+      continue;
+    }
+    if (l.has(U)) {
+      ie({ text: I, schemaUid: U });
+      continue;
+    }
+    try {
+      const A = We(n, a, {
+        schema: I,
+        resolverAddress: ce,
+        revocable: de
+      }), M = await k({
+        account: t,
+        transaction: A
+      });
+      await H({
+        client: n,
+        chain: a,
+        transactionHash: M.transactionHash
+      });
+    } catch (A) {
+      throw new Error(
+        `Failed to register EAS schema for property ${f.propertyName}: ${A instanceof Error ? A.message : String(A)}`
+      );
+    }
+    try {
+      const A = Ge(n, a, {
+        schemaUid: U,
+        schemaName: v
+      }), M = await k({
+        account: t,
+        transaction: A
+      });
+      await H({
+        client: n,
+        chain: a,
+        transactionHash: M.transactionHash
+      });
+    } catch (A) {
+      throw new Error(
+        `Failed to name EAS schema for property ${f.propertyName}: ${A instanceof Error ? A.message : String(A)}`
+      );
+    }
+    l.add(U), ie({ text: I, schemaUid: U });
+  }
+  const y = await _n(e);
+  for (const f of y)
+    await Oe(f, t, n, a);
+}
+function jr(e = {}) {
+  return Y({
+    signature: "event AdminUpdated(address indexed signer, bool isAdmin)",
+    filters: e
+  });
+}
+function Yr() {
+  return Y({
+    signature: "event Initialized(uint8 version)"
+  });
+}
+function Jr(e = {}) {
+  return Y({
+    signature: "event SignerPermissionsUpdated(address indexed authorizingSigner, address indexed targetSigner, (address signer, uint8 isAdmin, address[] approvedTargets, uint256 nativeTokenLimitPerTransaction, uint128 permissionStartTimestamp, uint128 permissionEndTimestamp, uint128 reqValidityStartTimestamp, uint128 reqValidityEndTimestamp, bytes32 uid) permissions)",
+    filters: e
+  });
+}
+function zr() {
+  return Y({
+    signature: "event ContractURIUpdated(string prevURI, string newURI)"
+  });
+}
+function Na() {
+  return Y({
+    signature: "event CreatedAttestation((bytes32 schemaUid, bytes32 attestationUid) result)"
+  });
+}
+function Zr() {
+  return Y({
+    signature: "event EIP712DomainChanged()"
+  });
+}
+function Kr() {
+  return Y({
+    signature: "event Log(string message)"
+  });
+}
+function Qr(e = {}) {
+  return Y({
+    signature: "event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)",
+    filters: e
+  });
+}
+function Fa() {
+  return Y({
+    signature: "event SeedPublished(bytes returnedDataFromEAS)"
+  });
+}
+async function Xr(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xb0d691fe",
+      [],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function eo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xc45a0155",
+      [],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function to(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x8b52d723",
+      [],
+      [
+        {
+          type: "tuple[]",
+          name: "signers",
+          components: [
+            {
+              type: "address",
+              name: "signer"
+            },
+            {
+              type: "address[]",
+              name: "approvedTargets"
+            },
+            {
+              type: "uint256",
+              name: "nativeTokenLimitPerTransaction"
+            },
+            {
+              type: "uint128",
+              name: "startTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "endTimestamp"
+            }
+          ]
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function no(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xe9523c97",
+      [],
+      [
+        {
+          type: "address[]"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function ao(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x4a00cc48",
+      [],
+      [
+        {
+          type: "tuple[]",
+          components: [
+            {
+              type: "tuple",
+              name: "metadata",
+              components: [
+                {
+                  type: "string",
+                  name: "name"
+                },
+                {
+                  type: "string",
+                  name: "metadataURI"
+                },
+                {
+                  type: "address",
+                  name: "implementation"
+                }
+              ]
+            },
+            {
+              type: "tuple[]",
+              name: "functions",
+              components: [
+                {
+                  type: "bytes4",
+                  name: "functionSelector"
+                },
+                {
+                  type: "string",
+                  name: "functionSignature"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function so(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xd42f2f35",
+      [],
+      [
+        {
+          type: "tuple[]",
+          name: "signers",
+          components: [
+            {
+              type: "address",
+              name: "signer"
+            },
+            {
+              type: "address[]",
+              name: "approvedTargets"
+            },
+            {
+              type: "uint256",
+              name: "nativeTokenLimitPerTransaction"
+            },
+            {
+              type: "uint128",
+              name: "startTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "endTimestamp"
+            }
+          ]
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function ro(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xce0b6013",
+      [
+        {
+          type: "bytes4",
+          name: "_functionSelector"
+        }
+      ],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: [e.functionSelector]
+  });
+}
+async function oo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xd087d288",
+      [],
+      [
+        {
+          type: "uint256"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function io(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xf15d424e",
+      [
+        {
+          type: "address",
+          name: "signer"
+        }
+      ],
+      [
+        {
+          type: "tuple",
+          components: [
+            {
+              type: "address",
+              name: "signer"
+            },
+            {
+              type: "address[]",
+              name: "approvedTargets"
+            },
+            {
+              type: "uint256",
+              name: "nativeTokenLimitPerTransaction"
+            },
+            {
+              type: "uint128",
+              name: "startTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "endTimestamp"
+            }
+          ]
+        }
+      ]
+    ],
+    params: [e.signer]
+  });
+}
+async function co(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x7dff5a79",
+      [
+        {
+          type: "address",
+          name: "signer"
+        }
+      ],
+      [
+        {
+          type: "bool"
+        }
+      ]
+    ],
+    params: [e.signer]
+  });
+}
+async function lo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x24d7806c",
+      [
+        {
+          type: "address",
+          name: "_account"
+        }
+      ],
+      [
+        {
+          type: "bool"
+        }
+      ]
+    ],
+    params: [e.account]
+  });
+}
+async function uo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x1dd756c5",
+      [
+        {
+          type: "address",
+          name: "_signer"
+        },
+        {
+          type: "tuple",
+          name: "_userOp",
+          components: [
+            {
+              type: "address",
+              name: "sender"
+            },
+            {
+              type: "uint256",
+              name: "nonce"
+            },
+            {
+              type: "bytes",
+              name: "initCode"
+            },
+            {
+              type: "bytes",
+              name: "callData"
+            },
+            {
+              type: "uint256",
+              name: "callGasLimit"
+            },
+            {
+              type: "uint256",
+              name: "verificationGasLimit"
+            },
+            {
+              type: "uint256",
+              name: "preVerificationGas"
+            },
+            {
+              type: "uint256",
+              name: "maxFeePerGas"
+            },
+            {
+              type: "uint256",
+              name: "maxPriorityFeePerGas"
+            },
+            {
+              type: "bytes",
+              name: "paymasterAndData"
+            },
+            {
+              type: "bytes",
+              name: "signature"
+            }
+          ]
+        }
+      ],
+      [
+        {
+          type: "bool"
+        }
+      ]
+    ],
+    params: [e.signer, e.userOp]
+  });
+}
+async function po(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xa9082d84",
+      [
+        {
+          type: "tuple",
+          name: "req",
+          components: [
+            {
+              type: "address",
+              name: "signer"
+            },
+            {
+              type: "uint8",
+              name: "isAdmin"
+            },
+            {
+              type: "address[]",
+              name: "approvedTargets"
+            },
+            {
+              type: "uint256",
+              name: "nativeTokenLimitPerTransaction"
+            },
+            {
+              type: "uint128",
+              name: "permissionStartTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "permissionEndTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "reqValidityStartTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "reqValidityEndTimestamp"
+            },
+            {
+              type: "bytes32",
+              name: "uid"
+            }
+          ]
+        },
+        {
+          type: "bytes",
+          name: "signature"
+        }
+      ],
+      [
+        {
+          type: "bool",
+          name: "success"
+        },
+        {
+          type: "address",
+          name: "signer"
+        }
+      ]
+    ],
+    params: [e.req, e.signature]
+  });
+}
+async function mo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xe8a3d485",
+      [],
+      [
+        {
+          type: "string"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function fo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x399b77da",
+      [
+        {
+          type: "bytes32",
+          name: "_hash"
+        }
+      ],
+      [
+        {
+          type: "bytes32"
+        }
+      ]
+    ],
+    params: [e.hash]
+  });
+}
+async function ho(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x1626ba7e",
+      [
+        {
+          type: "bytes32",
+          name: "_hash"
+        },
+        {
+          type: "bytes",
+          name: "_signature"
+        }
+      ],
+      [
+        {
+          type: "bytes4",
+          name: "magicValue"
+        }
+      ]
+    ],
+    params: [e.hash, e.signature]
+  });
+}
+async function yo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x01ffc9a7",
+      [
+        {
+          type: "bytes4",
+          name: "interfaceId"
+        }
+      ],
+      [
+        {
+          type: "bool"
+        }
+      ]
+    ],
+    params: [e.interfaceId]
+  });
+}
+async function go(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x84b0196e",
+      [],
+      [
+        {
+          type: "bytes1",
+          name: "fields"
+        },
+        {
+          type: "string",
+          name: "name"
+        },
+        {
+          type: "string",
+          name: "version"
+        },
+        {
+          type: "uint256",
+          name: "chainId"
+        },
+        {
+          type: "address",
+          name: "verifyingContract"
+        },
+        {
+          type: "bytes32",
+          name: "salt"
+        },
+        {
+          type: "uint256[]",
+          name: "extensions"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function wo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xd5f5127d",
+      [],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function bo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x8da5cb5b",
+      [],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+function Ao(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0xd1f57894",
+      [
+        {
+          type: "address",
+          name: "_defaultAdmin"
+        },
+        {
+          type: "bytes",
+          name: "_data"
+        }
+      ],
+      []
+    ],
+    params: [e.defaultAdmin, e.data]
+  });
+}
+function vo(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0xac9650d8",
+      [
+        {
+          type: "bytes[]",
+          name: "data"
+        }
+      ],
+      [
+        {
+          type: "bytes[]",
+          name: "results"
+        }
+      ]
+    ],
+    params: [e.data]
+  });
+}
+function So(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0xb76464d5",
+      [
+        {
+          type: "address",
+          name: "_entrypointOverride"
+        }
+      ],
+      []
+    ],
+    params: [e.entrypointOverride]
+  });
+}
+function Eo(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0x5892e236",
+      [
+        {
+          type: "tuple",
+          name: "_req",
+          components: [
+            {
+              type: "address",
+              name: "signer"
+            },
+            {
+              type: "uint8",
+              name: "isAdmin"
+            },
+            {
+              type: "address[]",
+              name: "approvedTargets"
+            },
+            {
+              type: "uint256",
+              name: "nativeTokenLimitPerTransaction"
+            },
+            {
+              type: "uint128",
+              name: "permissionStartTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "permissionEndTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "reqValidityStartTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "reqValidityEndTimestamp"
+            },
+            {
+              type: "bytes32",
+              name: "uid"
+            }
+          ]
+        },
+        {
+          type: "bytes",
+          name: "_signature"
+        }
+      ],
+      []
+    ],
+    params: [e.req, e.signature]
+  });
+}
+function Io(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0x3a871cdd",
+      [
+        {
+          type: "tuple",
+          name: "userOp",
+          components: [
+            {
+              type: "address",
+              name: "sender"
+            },
+            {
+              type: "uint256",
+              name: "nonce"
+            },
+            {
+              type: "bytes",
+              name: "initCode"
+            },
+            {
+              type: "bytes",
+              name: "callData"
+            },
+            {
+              type: "uint256",
+              name: "callGasLimit"
+            },
+            {
+              type: "uint256",
+              name: "verificationGasLimit"
+            },
+            {
+              type: "uint256",
+              name: "preVerificationGas"
+            },
+            {
+              type: "uint256",
+              name: "maxFeePerGas"
+            },
+            {
+              type: "uint256",
+              name: "maxPriorityFeePerGas"
+            },
+            {
+              type: "bytes",
+              name: "paymasterAndData"
+            },
+            {
+              type: "bytes",
+              name: "signature"
+            }
+          ]
+        },
+        {
+          type: "bytes32",
+          name: "userOpHash"
+        },
+        {
+          type: "uint256",
+          name: "missingAccountFunds"
+        }
+      ],
+      [
+        {
+          type: "uint256",
+          name: "validationData"
+        }
+      ]
+    ],
+    params: [e.userOp, e.userOpHash, e.missingAccountFunds]
+  });
+}
+function Po(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0x4a58db19",
+      [],
+      []
+    ],
+    params: []
+  });
+}
+function Uo(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0xb61d27f6",
+      [
+        {
+          type: "address",
+          name: "_target"
+        },
+        {
+          type: "uint256",
+          name: "_value"
+        },
+        {
+          type: "bytes",
+          name: "_calldata"
+        }
+      ],
+      []
+    ],
+    params: [e.target, e.value, e.calldata]
+  });
+}
+function To(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0x47e1da2a",
+      [
+        {
+          type: "address[]",
+          name: "_target"
+        },
+        {
+          type: "uint256[]",
+          name: "_value"
+        },
+        {
+          type: "bytes[]",
+          name: "_calldata"
+        }
+      ],
+      []
+    ],
+    params: [e.target, e.value, e.calldata]
+  });
+}
+function Do(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0xbc197c81",
+      [
+        {
+          type: "address"
+        },
+        {
+          type: "address"
+        },
+        {
+          type: "uint256[]"
+        },
+        {
+          type: "uint256[]"
+        },
+        {
+          type: "bytes"
+        }
+      ],
+      [
+        {
+          type: "bytes4"
+        }
+      ]
+    ],
+    params: [e.arg_0, e.arg_1, e.arg_2, e.arg_3, e.arg_4]
+  });
+}
+function xo(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0xf23a6e61",
+      [
+        {
+          type: "address"
+        },
+        {
+          type: "address"
+        },
+        {
+          type: "uint256"
+        },
+        {
+          type: "uint256"
+        },
+        {
+          type: "bytes"
+        }
+      ],
+      [
+        {
+          type: "bytes4"
+        }
+      ]
+    ],
+    params: [e.arg_0, e.arg_1, e.arg_2, e.arg_3, e.arg_4]
+  });
+}
+function Co(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0x150b7a02",
+      [
+        {
+          type: "address"
+        },
+        {
+          type: "address"
+        },
+        {
+          type: "uint256"
+        },
+        {
+          type: "bytes"
+        }
+      ],
+      [
+        {
+          type: "bytes4"
+        }
+      ]
+    ],
+    params: [e.arg_0, e.arg_1, e.arg_2, e.arg_3]
+  });
+}
+function Ro(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0x938e3d7b",
+      [
+        {
+          type: "string",
+          name: "_uri"
+        }
+      ],
+      []
+    ],
+    params: [e.uri]
+  });
+}
+function _o(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0x4d44560d",
+      [
+        {
+          type: "address",
+          name: "withdrawAddress"
+        },
+        {
+          type: "uint256",
+          name: "amount"
+        }
+      ],
+      []
+    ],
+    params: [e.withdrawAddress, e.amount]
+  });
+}
+function Lo(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0x6240d6d9",
+      [
+        {
+          type: "bytes32",
+          name: "schemaUid"
+        },
+        {
+          type: "bool",
+          name: "revocable"
+        }
+      ],
+      [
+        {
+          type: "bytes32"
+        }
+      ]
+    ],
+    params: [e.schemaUid, e.revocable]
+  });
+}
+function Mo(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0x13e0c263",
+      [
+        {
+          type: "bytes32",
+          name: "seedUid"
+        },
+        {
+          type: "bytes32",
+          name: "versionSchemaUid"
+        }
+      ],
+      [
+        {
+          type: "bytes32"
+        }
+      ]
+    ],
+    params: [e.seedUid, e.versionSchemaUid]
+  });
+}
+function vt(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0x31e19cb8",
+      [
+        {
+          type: "tuple[]",
+          name: "requests",
+          components: [
+            {
+              type: "string",
+              name: "localId"
+            },
+            {
+              type: "bytes32",
+              name: "seedUid"
+            },
+            {
+              type: "bytes32",
+              name: "seedSchemaUid"
+            },
+            {
+              type: "bytes32",
+              name: "versionUid"
+            },
+            {
+              type: "bytes32",
+              name: "versionSchemaUid"
+            },
+            {
+              type: "bool",
+              name: "seedIsRevocable"
+            },
+            {
+              type: "tuple[]",
+              name: "listOfAttestations",
+              components: [
+                {
+                  type: "bytes32",
+                  name: "schema"
+                },
+                {
+                  type: "tuple[]",
+                  name: "data",
+                  components: [
+                    {
+                      type: "address",
+                      name: "recipient"
+                    },
+                    {
+                      type: "uint64",
+                      name: "expirationTime"
+                    },
+                    {
+                      type: "bool",
+                      name: "revocable"
+                    },
+                    {
+                      type: "bytes32",
+                      name: "refUID"
+                    },
+                    {
+                      type: "bytes",
+                      name: "data"
+                    },
+                    {
+                      type: "uint256",
+                      name: "value"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              type: "tuple[]",
+              name: "propertiesToUpdate",
+              components: [
+                {
+                  type: "string",
+                  name: "publishLocalId"
+                },
+                {
+                  type: "bytes32",
+                  name: "propertySchemaUid"
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      [
+        {
+          type: "bytes32[]"
+        }
+      ]
+    ],
+    params: [e.requests]
+  });
+}
+function Oo(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0xd688e801",
+      [
+        {
+          type: "tuple[]",
+          name: "requests",
+          components: [
+            { type: "uint256", name: "localIdIndex" },
+            { type: "bytes32", name: "seedUid" },
+            { type: "bytes32", name: "seedSchemaUid" },
+            { type: "bytes32", name: "versionUid" },
+            { type: "bytes32", name: "versionSchemaUid" },
+            { type: "bool", name: "seedIsRevocable" },
+            {
+              type: "tuple[]",
+              name: "listOfAttestations",
+              components: [
+                { type: "bytes32", name: "schema" },
+                {
+                  type: "tuple[]",
+                  name: "data",
+                  components: [
+                    { type: "address", name: "recipient" },
+                    { type: "uint64", name: "expirationTime" },
+                    { type: "bool", name: "revocable" },
+                    { type: "bytes32", name: "refUID" },
+                    { type: "bytes", name: "data" },
+                    { type: "uint256", name: "value" }
+                  ]
+                }
+              ]
+            },
+            {
+              type: "tuple[]",
+              name: "propertiesToUpdate",
+              components: [
+                { type: "uint256", name: "publishLocalIdIndex" },
+                { type: "bytes32", name: "propertySchemaUid" }
+              ]
+            }
+          ]
+        }
+      ],
+      [{ type: "bytes32[]" }]
+    ],
+    params: [e.requests]
+  });
+}
+function Bo(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0xb71308c5",
+      [
+        {
+          type: "tuple",
+          name: "request",
+          components: [
+            {
+              type: "string",
+              name: "localId"
+            },
+            {
+              type: "bytes32",
+              name: "seedUid"
+            },
+            {
+              type: "bytes32",
+              name: "seedSchemaUid"
+            },
+            {
+              type: "bytes32",
+              name: "versionUid"
+            },
+            {
+              type: "bytes32",
+              name: "versionSchemaUid"
+            },
+            {
+              type: "bool",
+              name: "seedIsRevocable"
+            },
+            {
+              type: "tuple[]",
+              name: "listOfAttestations",
+              components: [
+                {
+                  type: "bytes32",
+                  name: "schema"
+                },
+                {
+                  type: "tuple[]",
+                  name: "data",
+                  components: [
+                    {
+                      type: "address",
+                      name: "recipient"
+                    },
+                    {
+                      type: "uint64",
+                      name: "expirationTime"
+                    },
+                    {
+                      type: "bool",
+                      name: "revocable"
+                    },
+                    {
+                      type: "bytes32",
+                      name: "refUID"
+                    },
+                    {
+                      type: "bytes",
+                      name: "data"
+                    },
+                    {
+                      type: "uint256",
+                      name: "value"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              type: "tuple[]",
+              name: "propertiesToUpdate",
+              components: [
+                {
+                  type: "string",
+                  name: "publishLocalId"
+                },
+                {
+                  type: "bytes32",
+                  name: "propertySchemaUid"
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      [
+        {
+          type: "bytes32"
+        },
+        {
+          type: "bytes32"
+        }
+      ]
+    ],
+    params: [e.request]
+  });
+}
+function No(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0x715018a6",
+      [],
+      []
+    ],
+    params: []
+  });
+}
+function Fo(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0xb90b6e0d",
+      [
+        {
+          type: "address",
+          name: "_eas"
+        }
+      ],
+      [
+        {
+          type: "string"
+        }
+      ]
+    ],
+    params: [e.eas]
+  });
+}
+function ko(e) {
+  return C({
+    contract: e.contract,
+    method: [
+      "0xf2fde38b",
+      [
+        {
+          type: "address",
+          name: "newOwner"
+        }
+      ],
+      []
+    ],
+    params: [e.newOwner]
+  });
+}
+const _e = () => {
+  const e = Ln.getHost(), t = na;
+  return Object.keys(t).includes("default") && t.default ? t.default.init({
+    host: e,
+    protocol: "https"
+  }) : t.init({
+    host: e,
+    protocol: "https"
+  });
+}, $ = "0x" + "0".repeat(64), dt = async (e) => {
+  let t;
+  try {
+    t = await se.find({ seedLocalId: e });
+  } catch {
+  }
+  return t || new Promise((n) => {
+    const a = setInterval(() => {
+      try {
+        se.find({ seedLocalId: e }).then((s) => {
+          s && (clearInterval(a), n(s));
+        });
+      } catch {
+      }
+    }, 200);
+  });
+};
+function ka(e) {
+  if (!e || typeof e != "object") return;
+  const t = e;
+  if (Array.isArray(t.data_root))
+    return {
+      data_root: new Uint8Array(t.data_root),
+      chunks: (t.chunks ?? []).map((n) => ({ ...n, dataHash: new Uint8Array(n.dataHash ?? []) })),
+      proofs: (t.proofs ?? []).map((n) => ({ ...n, proof: new Uint8Array(n.proof ?? []) }))
+    };
+}
+function Ha(e) {
+  return {
+    data_root: Array.from(e.data_root),
+    chunks: e.chunks.map((t) => ({ ...t, dataHash: Array.from(t.dataHash) })),
+    proofs: e.proofs.map((t) => ({ ...t, proof: Array.from(t.proof) }))
+  };
+}
+const $a = he(
+  async ({ input: { context: e } }) => {
+    let { item: t } = e;
+    t.getPublishUploads || (t = await dt(t.seedLocalId));
+    let n;
+    e.arweaveUploadTags?.length && (n = { arweaveUploadTags: e.arweaveUploadTags });
+    const a = await t.getPublishUploads(n), s = x(), r = e.signArweaveTransactions ?? s.signArweaveTransactions, o = e.arweaveJwk ?? s.arweaveJwk, c = a.map((m) => ({
+      versionLocalId: m.versionLocalId,
+      itemPropertyName: m.itemPropertyName,
+      transactionJson: m.transactionToSign.toJSON()
+    }));
+    let i;
+    if (r)
+      i = await r(c);
+    else if (o) {
+      const m = _e(), p = o;
+      i = [];
+      for (const h of c) {
+        const u = m.transactions.fromRaw(h.transactionJson);
+        u.data && u.data.byteLength > 0 && !u.chunks && await u.prepareChunks(u.data), await m.transactions.sign(u, p);
+        const y = u.toJSON();
+        i.push({
+          transaction: {
+            ...y,
+            chunks: u.chunks ? Ha(u.chunks) : void 0
+          },
+          versionId: h.versionLocalId,
+          modelName: h.itemPropertyName
+        });
+      }
+    } else
+      throw new Error(
+        "Arweave signing not configured. Provide signArweaveTransactions or arweaveJwk at createPublish or in PublishProvider config."
+      );
+    const l = _e();
+    return {
+      arweaveTransactions: i.map((m) => {
+        const { chunks: p, ...h } = m.transaction, u = { ...h }, y = ka(p);
+        return y && (u.chunks = y), {
+          transaction: l.transactions.fromRaw(u),
+          versionId: m.versionId,
+          modelName: m.modelName
+        };
+      }),
+      publishUploads: a
+    };
+  }
+), Qt = (e, t, n) => {
+  const a = [];
+  return e && a.push({ name: "Content-SHA-256", value: e }), t && a.push({ name: "Content-Type", value: t }), n?.length && a.push(...n), a;
+}, Xt = async (e) => {
+  const t = e instanceof Uint8Array ? new Uint8Array(e) : new Uint8Array(e), n = await crypto.subtle.digest("SHA-256", t);
+  return Array.from(new Uint8Array(n)).map((a) => a.toString(16).padStart(2, "0")).join("");
+}, Va = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  html: "text/html",
+  htm: "text/html",
+  json: "application/json",
+  txt: "text/plain"
+}, en = (e) => {
+  const t = e.split(".").pop()?.toLowerCase();
+  return t ? Va[t] : void 0;
+}, nt = async (e) => typeof Blob < "u" && e instanceof Blob ? new Uint8Array(await e.arrayBuffer()) : new Uint8Array(e), qa = (e) => {
+  switch (e) {
+    case "Image":
+      return j.getFilesPath("images");
+    case "File":
+      return j.getFilesPath("files");
+    case "Html":
+      return j.getFilesPath("html");
+    case "Json":
+      return j.getFilesPath("json");
+    default:
+      return j.getFilesPath("images");
+  }
+}, Wa = async (e, t, n, a) => {
+  const s = a?.arweaveUploadTags, r = e.itemProperty, o = [];
+  for (const h of e.childProperties) {
+    const u = h.localStoragePath;
+    !u || u.endsWith("undefined") || !await j.pathExists(u) || o.push({
+      propertyName: h.propertyName,
+      localStoragePath: u
+    });
+  }
+  let c;
+  if ((!o || o.length === 0) && n?.localStoragePath) {
+    const h = n.localStoragePath;
+    if (h && !h.endsWith("undefined") && await j.pathExists(h))
+      try {
+        const y = await j.readFileAsBuffer(h);
+        c = await nt(y);
+      } catch {
+        const y = await j.getFs();
+        c = await nt(y.readFileSync(h));
+      }
+  }
+  if (o.length > 0) {
+    const h = "===FILE_SEPARATOR===";
+    let u = "";
+    const y = await j.getFs();
+    for (const f of o) {
+      let b;
+      try {
+        b = await y.promises.readFile(f.localStoragePath);
+      } catch {
+        b = y.readFileSync(f.localStoragePath);
+      }
+      u += `${h}${f.propertyName}${h}${b}`;
+    }
+    c = typeof document < "u" ? new TextEncoder().encode(u) : new Uint8Array(Buffer.from(u));
+  }
+  if (!c) return t;
+  const i = new Uint8Array(c), l = await Xt(i);
+  let d;
+  o.length === 0 && n?.localStoragePath ? d = en(n.localStoragePath) : o.length > 0 && (d = "application/octet-stream");
+  const m = n ? n.localId : r.localId, p = n ? n.propertyName : r.propertyName;
+  return t.push({
+    data: i,
+    contentHash: l,
+    contentType: d,
+    tags: Qt(l, d, s),
+    itemPropertyName: p,
+    itemPropertyLocalId: m,
+    seedLocalId: r.seedLocalId,
+    versionLocalId: r.versionLocalId
+  }), t;
+}, Ga = async (e, t) => {
+  const n = [], a = t?.arweaveUploadTags;
+  for (const s of e) {
+    const r = s.getService().getSnapshot(), o = "context" in r ? r.context : null;
+    if (!o) continue;
+    const c = o.propertyValue, i = o.refResolvedValue;
+    if (!i) continue;
+    const { localId: l } = Nt(c ?? "");
+    if (!l) continue;
+    const d = s.propertyDef?.refValueType ?? s.propertyDef?.dataType ?? "Image", p = `${qa(d)}/${i}`;
+    if (!await j.pathExists(p)) continue;
+    const u = await j.readFileAsBuffer(p), y = await nt(u), f = await Xt(y), b = en(i);
+    n.push({
+      data: y,
+      contentHash: f,
+      contentType: b,
+      tags: Qt(f, b, a),
+      itemPropertyName: s.propertyName,
+      itemPropertyLocalId: s.localId,
+      seedLocalId: l,
+      versionLocalId: s.versionLocalId
+    });
+  }
+  return n;
+}, tn = async (e, t = [], n, a) => {
+  const { itemUploadProperties: s, itemRelationProperties: r, itemImageProperties: o } = await st(e);
+  for (const i of s)
+    t = await Wa(
+      i,
+      t,
+      n,
+      a
+    );
+  const c = await Ga(o, a);
+  t.push(...c);
+  for (const i of r) {
+    const l = i.getService().getSnapshot(), d = "context" in l ? l.context : null;
+    if (!d) continue;
+    const m = d.propertyValue;
+    if (!m || i.uid) continue;
+    const { localId: p, uid: h } = Nt(m), u = await se.find({ seedLocalId: p, seedUid: h });
+    if (!u)
+      throw new Error(`No relatedItem found for ${i.propertyName}`);
+    t = await tn(u, t, i, a);
+  }
+  return t;
+}, lt = 3, ae = 65, St = new TextEncoder().encode("seed-recovery"), Ye = 32, ja = 0xffffffffffffffffn;
+function Ya(e, t, n) {
+  const a = N.solidityPackedKeccak256(
+    ["uint256", "address", "uint64"],
+    [BigInt(t), e, n & ja]
+  );
+  return N.getBytes(a);
+}
+function Et(e) {
+  if (e.length === 0) return new Uint8Array([0]);
+  if (e.length !== Ye)
+    throw new Error(`ANS-104 target/anchor must be empty or ${Ye} bytes, got ${e.length}`);
+  const t = new Uint8Array(1 + Ye);
+  return t[0] = 1, t.set(e, 1), t;
+}
+function Ja(e) {
+  return e != null && typeof e == "object" && "privateKey" in e && typeof e.privateKey == "string";
+}
+function za(e, t, n) {
+  let s = e >= 0 ? e << 1 : ~e << 1 | 1, r = n;
+  do {
+    const o = s & 127;
+    s >>>= 7, t[r++] = s ? o | 128 : o;
+  } while (s);
+  return r - n;
+}
+const ut = (e) => {
+  if (!e?.length) return new Uint8Array(0);
+  const t = new TextEncoder(), n = new Uint8Array(16), a = [], s = (i) => {
+    const l = za(i, n, 0);
+    a.push(n.slice(0, l));
+  };
+  s(e.length);
+  for (const i of e) {
+    const l = t.encode(i.name), d = t.encode(i.value);
+    s(l.length), a.push(l), s(d.length), a.push(d);
+  }
+  s(0);
+  const r = a.reduce((i, l) => i + l.length, 0), o = new Uint8Array(r);
+  let c = 0;
+  for (const i of a)
+    o.set(i, c), c += i.length;
+  return o;
+}, It = (e) => {
+  const t = new Uint8Array(8), n = new DataView(t.buffer);
+  return n.setUint32(0, e & 4294967295, !0), n.setUint32(4, Math.floor(e / 4294967296), !0), t;
+};
+async function we(e) {
+  return new Uint8Array(
+    await crypto.subtle.digest("SHA-384", e)
+  );
+}
+function Ie(e, t) {
+  const n = new Uint8Array(e.length + t.length);
+  return n.set(e, 0), n.set(t, e.length), n;
+}
+async function nn(e) {
+  const t = new TextEncoder();
+  if (Array.isArray(e)) {
+    const r = Ie(t.encode("list"), t.encode(e.length.toString()));
+    let o = await we(r);
+    for (const c of e) {
+      const i = await nn(c);
+      o = await we(Ie(o, i));
+    }
+    return o;
+  }
+  const n = Ie(t.encode("blob"), t.encode(e.byteLength.toString())), a = await we(n), s = await we(e);
+  return we(Ie(a, s));
+}
+async function pt(e, t, n, a, s) {
+  const r = new TextEncoder();
+  return nn([
+    r.encode("dataitem"),
+    r.encode("1"),
+    r.encode(lt.toString()),
+    e,
+    t,
+    n,
+    a,
+    s
+  ]);
+}
+function an(e, t, n, a, s) {
+  const r = ut(t), o = It(t.length), c = It(r.length), i = Et(a), l = Et(s), d = [
+    e,
+    i,
+    l,
+    o,
+    c,
+    r,
+    n
+  ], m = d.reduce((u, y) => u + y.length, 0), p = new Uint8Array(m);
+  let h = 0;
+  for (const u of d)
+    p.set(u, h), h += u.length;
+  return p;
+}
+async function sn(e, t) {
+  const n = new Uint8Array(2);
+  new DataView(n.buffer).setUint16(0, lt, !0);
+  const a = 2 + ae + t.length, s = new Uint8Array(a);
+  s.set(n, 0), s.set(e, 2), s.set(t, 2 + ae);
+  const r = await crypto.subtle.digest("SHA-256", new Uint8Array(e));
+  return { id: ts(new Uint8Array(r)), raw: s };
+}
+const Za = async (e, t, n, a = new Uint8Array(0)) => {
+  const s = N.SigningKey.computePublicKey(t.privateKey, !1), r = N.getBytes(s), o = ut(n), c = new Uint8Array(0), i = await pt(
+    r,
+    c,
+    a,
+    o,
+    e
+  ), l = N.getBytes(await t.signMessage(i)), d = an(r, n, e, c, a);
+  return sn(l, d);
+}, Ka = async (e, t, n, a = new Uint8Array(0)) => {
+  const s = N.hexlify(St), r = await t.signMessage({
+    message: { raw: s }
+  }), o = N.hashMessage(St), c = N.SigningKey.recoverPublicKey(o, r), i = N.getBytes(c), l = ut(n), d = new Uint8Array(0), m = await pt(
+    i,
+    d,
+    a,
+    l,
+    e
+  ), p = N.hexlify(m), h = await t.signMessage({
+    message: { raw: p }
+  }), u = N.getBytes(h), y = an(i, n, e, d, a);
+  return sn(u, y);
+}, mt = 65;
+function Qa(e) {
+  const t = 2 + ae + mt;
+  if (e.length < t + 1) return null;
+  const n = e[t];
+  if (n !== 0 && n !== 1) return null;
+  const a = n === 1;
+  if (a && e.length < t + 33) return null;
+  let s = t + (a ? 33 : 1);
+  if (e.length < s + 1) return null;
+  const r = e[s];
+  if (r !== 0 && r !== 1) return null;
+  const o = r === 1;
+  return o && e.length < s + 33 ? null : s + (o ? 33 : 1);
+}
+function Xa(e) {
+  const t = Qa(e);
+  if (t == null) return null;
+  const n = 2 + ae + mt, a = e[n] === 1, s = a ? e.slice(n + 1, n + 33) : new Uint8Array(0), r = n + (a ? 33 : 1), c = e[r] === 1 ? e.slice(r + 1, r + 33) : new Uint8Array(0);
+  return { rawTarget: s, rawAnchor: c, tagsStart: t };
+}
+async function es(e) {
+  const t = Xa(e);
+  if (t == null) return !1;
+  const { rawTarget: n, rawAnchor: a, tagsStart: s } = t, r = s + 16;
+  if (e.length < r) return !1;
+  const o = new DataView(e.buffer, e.byteOffset, e.byteLength);
+  if (o.getUint16(0, !0) !== lt) return !1;
+  const i = e.slice(2, 2 + ae), l = e.slice(2 + ae, 2 + ae + mt), d = Number(
+    o.getUint32(s + 8, !0) + o.getUint32(s + 12, !0) * 4294967296
+  ), m = s + 16 + d;
+  if (e.length < m) return !1;
+  const p = e.slice(s + 16, m), h = e.slice(m);
+  try {
+    const u = await pt(
+      l,
+      n,
+      a,
+      p,
+      h
+    ), y = N.hashMessage(u), f = N.hexlify(i), b = N.SigningKey.recoverPublicKey(y, f), g = N.getBytes(b);
+    return g.length === l.length && g.every((S, v) => S === l[v]);
+  } catch {
+    return !1;
+  }
+}
+const ts = (e) => {
+  let t = "";
+  for (const n of e)
+    t += String.fromCharCode(n);
+  return btoa(t).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}, ns = K("seedProtocol:createArweaveDataItems"), as = he(
+  async ({ input: { context: e } }) => {
+    let { item: t } = e;
+    t.getPublishUploads || (t = await dt(t.seedLocalId));
+    let n;
+    e.arweaveUploadTags?.length && (n = { arweaveUploadTags: e.arweaveUploadTags });
+    const a = await tn(t, [], void 0, n), s = x(), r = e.signDataItems ?? s.signDataItems, o = e.dataItemSigner ?? s.dataItemSigner;
+    let c, i;
+    if (r)
+      c = (await r(a)).map((m) => ({
+        transaction: { id: m.transaction.id },
+        versionId: m.versionId,
+        modelName: m.modelName
+      }));
+    else if (o) {
+      const d = o, m = [], p = Date.now(), h = d.address;
+      for (let u = 0; u < a.length; u++) {
+        const y = a[u], f = y.tags, b = new Uint8Array(8);
+        crypto.getRandomValues(b);
+        const g = (new DataView(b.buffer).getBigUint64(0, !1) ^ BigInt(u)) & 0xffffffffffffffffn, S = Ya(h, p, g), v = Ja(d) ? await Za(y.data, d, f, S) : await Ka(y.data, d, f, S);
+        if (!await es(v.raw))
+          throw ns("DataItem verification failed: id=%s modelName=%s", v.id, y.itemPropertyName), new Error(
+            `DataItem signature verification failed for ${y.itemPropertyName}. The signing key may not match the owner, or the payload may have been modified.`
+          );
+        m.push(v);
+      }
+      i = m, c = m.map((u, y) => ({
+        transaction: { id: u.id },
+        versionId: a[y]?.versionLocalId,
+        modelName: a[y]?.itemPropertyName
+      }));
+    } else
+      throw new Error(
+        "@seedprotocol/publish: useArweaveBundler requires signDataItems or dataItemSigner (pass at createPublish or in PublishProvider config)"
+      );
+    const l = a.map((d) => ({
+      itemPropertyName: d.itemPropertyName,
+      itemPropertyLocalId: d.itemPropertyLocalId,
+      seedLocalId: d.seedLocalId,
+      versionLocalId: d.versionLocalId,
+      transactionToSign: null
+    }));
+    return {
+      arweaveTransactions: c,
+      publishUploads: l,
+      arweaveUploadData: a,
+      signedDataItems: i
+    };
+  }
+), Pt = 8192;
+function ss(e) {
+  const t = new Uint8Array(e);
+  let n = "";
+  for (let a = 0; a < t.length; a += Pt) {
+    const s = t.subarray(a, Math.min(a + Pt, t.length));
+    n += String.fromCharCode.apply(null, s);
+  }
+  return btoa(n);
+}
+async function rs(e) {
+  const t = [];
+  for (const [n, a] of e.entries()) {
+    const s = a;
+    if (typeof s == "object" && s !== null && "arrayBuffer" in s) {
+      const r = await s.arrayBuffer(), o = ss(r), c = s;
+      t.push({
+        name: n,
+        value: o,
+        encoding: "base64",
+        filename: c.name || void 0
+      });
+    } else
+      t.push({ name: n, value: String(a) });
+  }
+  return t;
+}
+function os(e, t, n) {
+  const a = ["Upload server returned ", String(e)], s = t && typeof t == "object" && "message" in t ? String(t.message) : t && typeof t == "object" && "error" in t ? String(t.error) : null;
+  return s ? a.push(`: ${s}`) : n && a.push(` (${n})`), a.join("");
+}
+function is(e) {
+  if (!e)
+    return "Upload server unavailable. Please try again or check your connection.";
+  const t = e.toLowerCase();
+  return /other side closed|econnreset|socket hang up|connection closed/i.test(t) ? "Upload server closed the connection. It may be busy or the request may be too large—try again." : /etimedout|timeout/i.test(t) ? "Upload request timed out. Please try again." : /enotfound|getaddrinfo|dns/i.test(t) ? "Upload server could not be reached. Check the upload URL and your network." : "Upload failed. Please try again or check the upload server.";
+}
+async function cs(e, t, n) {
+  const a = typeof window < "u" ? window.Main : void 0;
+  if (a?.uploadArweaveStart) {
+    const o = await rs(t);
+    return a.uploadArweaveStart(e, o);
+  }
+  const s = await fetch(e, {
+    method: "POST",
+    body: t
+  }), r = await s.json().catch(() => ({}));
+  return { status: s.status, body: r };
+}
+const ds = he(
+  async ({ input: { context: e, event: t } }) => {
+    const { arweaveTransactions: n = [], transactionKeys: a, reimbursementTransactionId: s } = e;
+    if (s)
+      return {
+        transactionId: s
+      };
+    const r = n.map(({ transaction: p }) => p), o = new FormData();
+    for (const p of r) {
+      let { data: h, chunks: u, ...y } = p;
+      const f = h instanceof Blob ? h : new Blob([h]);
+      o.append(`${p.id}-data`, f, `${p.id}-data`);
+      const b = new Blob([JSON.stringify(u)], { type: "application/json" });
+      o.append(`${p.id}-chunks`, b, `${p.id}-chunks`);
+      const g = new Blob([JSON.stringify(y)], { type: "application/json" });
+      o.append(`${p.id}-json`, g, `${p.id}-json`);
+    }
+    const { uploadApiBaseUrl: c } = x(), i = `${c}/api/upload/arweave/start`, { status: l, body: d, message: m } = await cs(
+      i,
+      o
+    );
+    if (l >= 300 || l < 200) {
+      const p = l === 0 ? m : null;
+      p && console.error("[upload]", p);
+      const h = l === 0 ? is(p) : os(l, d, a);
+      throw new Error(h);
+    }
+    return d;
+  }
+), ls = he(async ({ input: { context: e, event: t } }) => {
+  const { requestResponse: n, reimbursementTransactionId: a } = e;
+  if (!n)
+    throw new Error("No request response");
+  if (!a)
+    throw new Error("No reimbursement transaction id");
+  const s = _e();
+  await new Promise((o, c) => {
+    const i = setInterval(async () => {
+      let l;
+      try {
+        l = await s.transactions.getStatus(a);
+      } catch {
+        return;
+      }
+      l && l.confirmed && (clearInterval(i), o());
+    }, 5e3);
+  });
+}), ne = K("seedProtocol:services:publish:actors");
+function us(e) {
+  if (e instanceof Uint8Array) return e;
+  if (e instanceof ArrayBuffer) return new Uint8Array(e);
+  throw new Error("Transaction data must be Uint8Array or ArrayBuffer for upload resume");
+}
+const ps = ye(
+  ({ sendBack: e, input: t }) => {
+    const n = t.context, s = (n.arweaveTransactions ?? []).map(({ transaction: l }) => l), r = _e(), o = n.uploaderState && typeof n.currentTransactionIndex == "number", c = o ? n.currentTransactionIndex : 0;
+    (async () => {
+      const l = s.length;
+      for (let d = c; d < l; d++) {
+        const m = s[d];
+        if (!m) continue;
+        const p = r.transactions.fromRaw(m);
+        if (!await r.transactions.verify(p))
+          throw new Error("Transaction verification failed");
+        let u;
+        const y = n.uploaderState;
+        if (o && d === c && y) {
+          const f = p.data, b = f instanceof Uint8Array ? f : us(f);
+          u = await r.transactions.getUploader(y, b);
+        } else
+          u = await r.transactions.getUploader(p, p.data);
+        for (; !u.isComplete; ) {
+          ne("uploading chunk"), ne(`uploader.pctComplete: ${u.pctComplete}`), ne(`uploader.uploadedChunks: ${u.uploadedChunks}`), ne(`uploader.totalChunks: ${u.totalChunks}`), ne(u.lastResponseError), ne(u.lastResponseStatus);
+          try {
+            await u.uploadChunk();
+            const f = Math.trunc((d + u.pctComplete / 100) / l * 100);
+            e({
+              type: "updatePercentage",
+              completionPercentage: f,
+              uploaderState: u.toJSON(),
+              currentTransactionIndex: d
+            }), ne(`${u.pctComplete}% complete, ${u.uploadedChunks}/${u.totalChunks}`);
+          } catch (f) {
+            ne(f);
+          }
+        }
+      }
+      return "done";
+    })().then((l) => {
+      e({ type: "uploadComplete", result: l });
+    }).catch((l) => {
+      e({ type: "uploadError", error: l });
+    });
+  }
+), ms = ye(
+  ({ sendBack: e, input: { context: t } }) => {
+    const { signedDataItems: n } = t, { uploadApiBaseUrl: a, useArweaveBundler: s } = x();
+    if (!s || !a) {
+      e({
+        type: "uploadError",
+        error: new Error(
+          "Arweave bundler not configured. Set useArweaveBundler and uploadApiBaseUrl."
+        )
+      });
+      return;
+    }
+    const r = `${a.replace(/\/$/, "")}/api/upload/arweave/batch`;
+    if (!n || n.length === 0) {
+      e({ type: "uploadComplete", result: "done" });
+      return;
+    }
+    (async () => {
+      const c = async (f) => {
+        const b = f;
+        if (b.raw != null && (b.raw instanceof Uint8Array || Buffer.isBuffer(b.raw)))
+          return Buffer.from(b.raw);
+        if (typeof b.getRaw == "function") {
+          const g = b.getRaw();
+          return g instanceof Promise ? g : Buffer.from(g);
+        }
+        if (b.filename != null)
+          return aa(b.filename);
+        throw new Error("Cannot get raw bytes from DataItem");
+      }, i = await Promise.all(
+        n.map((f) => c(f))
+      ), l = i.length;
+      let d = 4;
+      for (const f of i)
+        d += 4 + f.length;
+      const m = Buffer.alloc(d);
+      let p = 0;
+      m.writeUInt32BE(l, p), p += 4;
+      for (const f of i)
+        m.writeUInt32BE(f.length, p), p += 4, f.copy(m, p), p += f.length;
+      const h = await fetch(r, {
+        method: "POST",
+        headers: { "Content-Type": "application/octet-stream" },
+        body: m
+      });
+      if (!h.ok)
+        throw new Error(`Batch upload failed: ${h.status}`);
+      const u = await h.json().catch(() => ({})), y = typeof u.failed == "number" ? u.failed : 0;
+      if (y > 0) {
+        const f = u.total ?? "?", b = u.succeeded ?? 0;
+        throw new Error(
+          `Arweave batch upload failed: ${y} of ${f} item(s) failed (${b} succeeded)`
+        );
+      }
+    })().then(() => e({ type: "uploadComplete", result: "done" })).catch((c) => e({ type: "uploadError", error: c }));
+  }
+), rn = "Could not connect the managed publishing account on Optimism Sepolia. Reconnect with the same sign-in method and try again.", fs = "Your publishing smart account is not deployed on Optimism Sepolia yet. Complete wallet setup, enable autoDeployManagedAccount in config if appropriate, then try again.", hs = "The managed account could not be confirmed on Optimism Sepolia after deployment. Wait a moment and retry, or check your network connection.", on = "Automatic deployment of the managed publishing account failed on Optimism Sepolia. Retry or deploy the account through your wallet provider.";
+async function Ut() {
+  const { useModularExecutor: e } = x();
+  if (!e)
+    return { kind: "skip" };
+  let t;
+  try {
+    t = await ot(E);
+  } catch (a) {
+    return { kind: "unavailable", cause: a };
+  }
+  return await Re(t) ? { kind: "ready", managedAddress: t } : { kind: "not_deployed", managedAddress: t };
+}
+async function cn() {
+  const e = Me();
+  await e.autoConnect({ client: R(), chain: E });
+  const t = e.getAccount();
+  if (!t)
+    throw new Q(rn, "MANAGED_ACCOUNT_UNAVAILABLE");
+  return t;
+}
+async function ys() {
+  const e = await cn();
+  try {
+    await fa(e);
+  } catch (t) {
+    throw new Q(on, "MANAGED_ACCOUNT_NOT_DEPLOYED", e.address, t);
+  }
+}
+async function dn() {
+  const e = x();
+  if (!e.useModularExecutor)
+    throw new Error("runModularExecutorPublishPrep: useModularExecutor is false");
+  let t = await Ut();
+  if (t.kind === "unavailable")
+    return {
+      ok: !1,
+      error: new Q(rn, "MANAGED_ACCOUNT_UNAVAILABLE", void 0, t.cause)
+    };
+  if (t.kind === "not_deployed")
+    if (e.autoDeployManagedAccount) {
+      try {
+        await ys();
+      } catch (n) {
+        return { ok: !1, error: At(n) ? n : new Q(on, "MANAGED_ACCOUNT_NOT_DEPLOYED", t.managedAddress, n) };
+      }
+      if (t = await Ut(), t.kind !== "ready")
+        return {
+          ok: !1,
+          error: new Q(
+            hs,
+            "MANAGED_ACCOUNT_NOT_DEPLOYED",
+            t.kind === "not_deployed" ? t.managedAddress : void 0
+          )
+        };
+    } else
+      return {
+        ok: !1,
+        error: new Q(fs, "MANAGED_ACCOUNT_NOT_DEPLOYED", t.managedAddress)
+      };
+  if (t.kind === "ready") {
+    if (e.modularAccountModuleContract)
+      try {
+        const n = await cn();
+        await tt(t.managedAddress, n, e);
+      } catch (n) {
+        return At(n) ? { ok: !1, error: n } : {
+          ok: !1,
+          error: new Q(
+            "Executor module setup failed on Optimism Sepolia.",
+            "EXECUTOR_MODULE_NOT_INSTALLED",
+            t.managedAddress,
+            n
+          )
+        };
+      }
+    return { ok: !0, managedAddress: t.managedAddress };
+  }
+  throw new Error("runModularExecutorPublishPrep: unexpected readiness state");
+}
+const gs = K("seedProtocol:services:publish:actors:persistSeedUid"), Tt = "0x" + "0".repeat(64), ws = 15e3;
+function ln(e, t) {
+  const n = e.seedLocalId, a = n ? t.find((r) => r?.localId === n) : void 0, s = a?.seedUid && a.seedUid !== Tt ? a.seedUid : t[0]?.seedUid;
+  s && s !== Tt && (e.seedUid = s);
+}
+async function un(e, t) {
+  const n = e.persistSeedUid;
+  if (typeof n != "function") return;
+  const a = new Promise(
+    (s, r) => setTimeout(() => r(new Error("persistSeedUid timed out")), ws)
+  );
+  try {
+    await Promise.race([n.call(e, t), a]);
+  } catch (s) {
+    gs("persistSeedUid failed (attestations already on-chain):", s);
+  }
+}
+async function pn(e) {
+  if (e.length === 0) return;
+  const { arweaveUploadVerificationBaseUrl: t } = x(), n = await Promise.all(
+    e.map(
+      (a) => Mn(t, a)
+    )
+  );
+  for (let a = 0; a < e.length; a++) {
+    const s = e[a], r = n[a];
+    if (r) {
+      if (r.status === 404)
+        throw new Error(
+          `Arweave transaction ${s} not found. Upload may have failed. Delete this publish record and try again.`
+        );
+      if (r.status !== 200)
+        throw new Error(
+          `Arweave transaction ${s} is not yet available from the upload service (status: ${r.status}). Wait and retry.`
+        );
+    }
+  }
+}
+function bs() {
+  return Y({
+    signature: "event CreatedAttestation((bytes32 schemaUid, bytes32 attestationUid) result)"
+  });
+}
+function As() {
+  return Y({
+    signature: "event SeedPublished(bytes32 seedUid, bytes32 versionUid)"
+  });
+}
+function xe(e) {
+  return e == null || e === "" ? $ : ("0x" + (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0").padStart(64, "0").slice(-64)).toLowerCase();
+}
+function Dt(e, t, n) {
+  if (!t || !e.logs?.length) return;
+  const a = xe(t);
+  if (a === $) return;
+  const s = n ? bs : Na;
+  try {
+    const r = rt({
+      logs: e.logs,
+      events: [s()],
+      strict: !1
+    });
+    for (const o of r) {
+      const c = o?.args?.result;
+      if (c?.attestationUid && xe(c.schemaUid) === a) {
+        const i = c.attestationUid;
+        return i && xe(i) !== $ ? i : void 0;
+      }
+    }
+  } catch {
+  }
+}
+function xt(e, t, n, a) {
+  const s = t.toLowerCase(), r = e.logs?.filter((o) => o.address && o.address.toLowerCase() === s);
+  if (r?.length)
+    try {
+      const i = rt({
+        logs: r,
+        events: [(a ? As : Fa)()],
+        strict: !1
+      })[0];
+      if (!i) return;
+      if (a) {
+        const f = i.args?.seedUid;
+        return f && xe(f) !== $ ? f : void 0;
+      }
+      const d = i.args?.returnedDataFromEAS;
+      if (!d || d === "0x") return;
+      const p = Jn([{ type: "bytes32[]" }], d)[0];
+      if (!p?.length) return;
+      const u = p[n];
+      return u && u !== $ ? u : p.length === 1 && p[0] && p[0] !== $ ? p[0] : void 0;
+    } catch {
+      return;
+    }
+}
+const le = 64, G = (e) => {
+  if (e == null) return "0x" + "0".repeat(le);
+  if (typeof e == "string")
+    return "0x" + (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0").padStart(le, "0").slice(-le);
+  if (e instanceof Uint8Array || typeof ArrayBuffer < "u" && e instanceof ArrayBuffer) {
+    const t = e instanceof Uint8Array ? e : new Uint8Array(e);
+    return "0x" + Array.from(t).map((a) => a.toString(16).padStart(2, "0")).join("").padStart(le, "0").slice(-le);
+  }
+  return "0x" + "0".repeat(le);
+}, vs = (e) => {
+  if (e == null || typeof e == "string" && (e === "" || e === "0x")) return "0x";
+  if (typeof e == "string") {
+    const n = (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0");
+    return "0x" + (n.length % 2 === 1 ? "0" + n : n);
+  }
+  if (e instanceof Uint8Array || typeof ArrayBuffer < "u" && e instanceof ArrayBuffer) {
+    const t = e instanceof Uint8Array ? e : new Uint8Array(e);
+    return "0x" + Array.from(t).map((n) => n.toString(16).padStart(2, "0")).join("");
+  }
+  return "0x";
+};
+function Ss(e) {
+  const t = new Set(
+    e.map((n) => n?.localId).filter((n) => !!n)
+  );
+  return e.some(
+    (n) => (n?.listOfAttestations ?? []).some((a) => {
+      const s = a;
+      return s._unresolvedValue && t.has(s._unresolvedValue) ? !0 : Array.isArray(s._rawListIdsForResolve) ? s._rawListIdsForResolve.some((r) => r && t.has(String(r).trim())) : !1;
+    })
+  );
+}
+function Es(e, t) {
+  return (e ?? []).filter(
+    (n) => n.publishLocalId && t.has(n.publishLocalId)
+  );
+}
+const Is = {
+  recipient: Xe,
+  expirationTime: BigInt(0),
+  revocable: !0,
+  refUID: $,
+  data: $,
+  value: BigInt(0)
+};
+function Je(e) {
+  const t = (e?.listOfAttestations ?? []).map((a) => {
+    const s = Array.isArray(a?.data) ? a.data : [];
+    return {
+      schema: G(a?.schema),
+      data: s.map((r) => ({
+        ...r,
+        refUID: G(r?.refUID),
+        data: vs(r?.data),
+        expirationTime: r?.expirationTime != null ? BigInt(r.expirationTime) : BigInt(0),
+        value: r?.value != null ? BigInt(r.value) : BigInt(0)
+      }))
+    };
+  }), n = (e?.propertiesToUpdate ?? []).map((a) => ({
+    ...a,
+    propertySchemaUid: G(a?.propertySchemaUid)
+  }));
+  return {
+    ...e,
+    seedUid: G(e?.seedUid),
+    seedSchemaUid: G(e?.seedSchemaUid),
+    versionUid: G(e?.versionUid),
+    versionSchemaUid: G(e?.versionSchemaUid),
+    listOfAttestations: t,
+    propertiesToUpdate: n
+  };
+}
+function Ct(e, t) {
+  for (const n of e)
+    for (const a of n?.propertiesToUpdate ?? []) {
+      const s = a?.publishLocalId, r = G(a?.propertySchemaUid);
+      if (!s || !r) continue;
+      const o = t.get(s);
+      if (!o?.listOfAttestations) continue;
+      const c = o.listOfAttestations.find(
+        (i) => G(i?.schema)?.toLowerCase() === r?.toLowerCase()
+      );
+      c && (!Array.isArray(c.data) || c.data.length === 0) && (c.data = [{ ...Is, refUID: $ }]);
+    }
+}
+const Ps = "pending_l1";
+async function mn(e) {
+  const { useArweaveBundler: t } = x();
+  if (!t) return;
+  const n = e.arweaveTransactions ?? [], a = e.publishUploads ?? [];
+  if (n.length === 0 || n.length !== a.length) return;
+  const s = B.getAppDb();
+  if (!s) return;
+  const r = Date.now();
+  for (let o = 0; o < n.length; o++) {
+    const c = n[o], i = a[o];
+    if (!i) continue;
+    const l = c.transaction?.id;
+    if (!(!l || typeof l != "string"))
+      try {
+        await s.insert(De).values({
+          seedLocalId: i.seedLocalId,
+          dataItemId: l,
+          versionLocalId: i.versionLocalId ?? null,
+          itemPropertyName: i.itemPropertyName ?? null,
+          phase: Ps,
+          createdAt: r,
+          updatedAt: r
+        }).onConflictDoNothing();
+      } catch {
+      }
+  }
+}
+const Us = K("seedProtocol:services:publish:actors"), Ts = he(
+  async ({ input: { context: e, event: t } }) => {
+    const { address: n, account: a } = e, s = e.arweaveTransactions ?? [], r = e.publishUploads ?? [];
+    let { item: o } = e;
+    const { modularAccountModuleContract: c, useModularExecutor: i } = x();
+    if (!n || typeof n != "string" || !n.trim())
+      throw new Error("No wallet address for publish. Connect a wallet and try again.");
+    if (!a)
+      throw new Error("Wallet session is missing. Reconnect your wallet and retry the publish.");
+    if (!o?.seedLocalId)
+      throw new Error(
+        "Attestation recovery failed: Item data is missing. Delete this publish record and try a full publish from the beginning."
+      );
+    typeof o.getPublishUploads != "function" && (o = await dt(o.seedLocalId));
+    const d = s.length, m = r.length;
+    if (d !== m)
+      throw new Error(
+        "Attestation recovery failed: Arweave transaction data is missing or incomplete. Delete this publish record and try a full publish from the beginning."
+      );
+    const p = V({
+      client: R(),
+      chain: E,
+      address: n
+    });
+    let h = i && c ? V({
+      client: R(),
+      chain: E,
+      address: c
+    }) : p;
+    await Oe(o, a, R(), E);
+    const u = s.map(
+      (w, U) => {
+        const A = w.transaction?.id;
+        if (!A || typeof A != "string")
+          throw new Error(
+            "Attestation recovery failed: Arweave transaction data did not survive restore. Delete this publish record and try a full publish from the beginning."
+          );
+        const M = r[U];
+        if (!M) throw new Error("Publish upload index mismatch");
+        return { ...M, txId: A };
+      }
+    );
+    await pn(u.map((w) => w.txId));
+    let y;
+    try {
+      y = await o.getPublishPayload(u, { publishMode: e.publishMode ?? "patch" });
+    } catch (w) {
+      throw w;
+    }
+    const f = Array.isArray(y) ? y : [y];
+    let b = a;
+    if (i) {
+      const w = await dn();
+      if (!w.ok)
+        throw w.error;
+      h = V({
+        client: R(),
+        chain: E,
+        address: yt
+      });
+      const U = it();
+      await U.autoConnect({ client: R(), chain: E });
+      const F = U.getAccount();
+      if (!F)
+        throw new Error("Failed to get modular account");
+      b = F;
+    }
+    const g = i ? yt : n, S = f.length > 1 && Ss(f);
+    let v;
+    if (S) {
+      let w = structuredClone(f);
+      const U = {};
+      for (let A = 0; A < w.length; A++) {
+        w = await ht(w, U);
+        const M = w[A], X = /* @__PURE__ */ new Set([M.localId]), ge = {
+          ...M,
+          propertiesToUpdate: Es(M.propertiesToUpdate, X)
+        }, J = Je(ge), Be = /* @__PURE__ */ new Map([[J.localId, J]]);
+        Ct([J], Be);
+        const Ne = {
+          ...vt({
+            contract: h,
+            requests: [J]
+          }),
+          gas: 5000000n
+        }, Fe = await k({
+          account: b,
+          transaction: await Promise.resolve(Ne)
+        }), re = await H({
+          client: R(),
+          chain: E,
+          transactionHash: Fe.transactionHash
+        });
+        if (!re)
+          throw new Error("Failed to send transaction");
+        const oe = !J.seedUid || G(J.seedUid) === $, wn = J?.listOfAttestations?.length ?? 0, bn = J?.seedSchemaUid;
+        if (oe) {
+          const ke = Dt(re, bn, i) ?? xt(
+            re,
+            g,
+            wn,
+            i
+          );
+          ke && (U[M.localId] = ke, w[A] = { ...w[A], seedUid: ke });
+        }
+      }
+      for (const A of w) {
+        const M = A?.localId, X = A?.seedUid;
+        M && X && G(X) !== $ && (U[M] = G(X));
+      }
+      v = (await ht(structuredClone(f), U)).map(
+        (A) => Je({
+          ...A,
+          seedUid: U[A.localId] ?? A.seedUid
+        })
+      );
+    } else {
+      const w = f.map((oe) => Je(oe)), U = new Map(w.map((oe) => [oe?.localId, oe]));
+      Ct(w, U);
+      const F = Array.isArray(y) ? w : [w[0]], A = {
+        ...vt({
+          contract: h,
+          requests: F
+        }),
+        gas: 5000000n
+      }, M = await k({
+        account: b,
+        transaction: await Promise.resolve(A)
+      }), X = await H({
+        client: R(),
+        chain: E,
+        transactionHash: M.transactionHash
+      });
+      if (!X)
+        throw new Error("Failed to send transaction");
+      const ge = w[0], J = ge?.seedUid, Be = J === $ || !J, Ne = ge?.listOfAttestations?.length ?? 0, Fe = ge?.seedSchemaUid, re = Be ? Dt(X, Fe, i) ?? xt(
+        X,
+        g,
+        Ne,
+        i
+      ) : void 0;
+      v = re && w.length > 0 ? [{ ...w[0], seedUid: re }, ...w.slice(1)] : w;
+    }
+    ln(o, v);
+    const I = o, D = v.find((w) => w?.localId === o.seedLocalId)?.seedUid;
+    return D && D !== $ && await un(I, n), Us("requestData", y), mn(e), { easPayload: y };
+  }
+), Rt = K("seedProtocol:services:publish:verifyAttestations"), Ds = "0x" + "0".repeat(64), Pe = 64, _t = (e) => e == null ? "0x" + "0".repeat(Pe) : typeof e == "string" ? "0x" + (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0").padStart(Pe, "0").slice(-Pe) : "0x" + "0".repeat(Pe), xs = 5e3, ze = 6;
+async function Cs({
+  normalizedRequests: e,
+  item: t
+}) {
+  const n = t.seedLocalId;
+  for (const a of e) {
+    if (a.listOfAttestations.length === 0 || a.versionUid === Ds) continue;
+    const s = a.listOfAttestations.map(
+      (d) => _t(d.schema).toLowerCase()
+    );
+    let r = [], o;
+    for (let d = 1; d <= ze; d++)
+      try {
+        d > 1 && await new Promise((m) => setTimeout(m, xs)), r = await On({
+          versionUids: [a.versionUid]
+        });
+        break;
+      } catch (m) {
+        if (o = m, Rt("verifyAttestations attempt %d failed:", d, m), d === ze)
+          throw Rt("verifyAttestations: giving up after %d attempts", ze), o;
+      }
+    const c = r.map((d) => d.schemaId ? _t(d.schemaId).toLowerCase() : "").filter(Boolean), i = new Set(c);
+    if (s.filter((d) => !i.has(d)).length > 0)
+      throw new Zt(
+        `Publish verification failed: Seed and Version attestations were created, but property/metadata attestations are missing or incomplete. Expected ${s.length} property attestations for schema(s) ${s.join(", ")}; found ${c.length}. Use PublishManager.retryAttestations('${n}') to retry.`,
+        n,
+        s,
+        c,
+        "METADATA_PROPERTIES_MISSING"
+      );
+  }
+}
+const be = K("seedProtocol:services:publish:createAttestationsDirectToEas"), ue = 64, z = (e) => {
+  if (e == null) return "0x" + "0".repeat(ue);
+  if (typeof e == "string")
+    return "0x" + (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0").padStart(ue, "0").slice(-ue);
+  if (e instanceof Uint8Array || typeof ArrayBuffer < "u" && e instanceof ArrayBuffer) {
+    const t = e instanceof Uint8Array ? e : new Uint8Array(e);
+    return "0x" + Array.from(t).map((a) => a.toString(16).padStart(2, "0")).join("").padStart(ue, "0").slice(-ue);
+  }
+  return "0x" + "0".repeat(ue);
+}, Rs = (e) => {
+  if (e == null || typeof e == "string" && (e === "" || e === "0x")) return "0x";
+  if (typeof e == "string") {
+    const n = (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0");
+    return "0x" + (n.length % 2 === 1 ? "0" + n : n);
+  }
+  if (e instanceof Uint8Array || typeof ArrayBuffer < "u" && e instanceof ArrayBuffer) {
+    const t = e instanceof Uint8Array ? e : new Uint8Array(e);
+    return "0x" + Array.from(t).map((n) => n.toString(16).padStart(2, "0")).join("");
+  }
+  return "0x";
+}, _s = async (e) => {
+  let t;
+  try {
+    t = await se.find({ seedLocalId: e });
+  } catch {
+  }
+  return t || new Promise((n) => {
+    const a = setInterval(() => {
+      try {
+        se.find({ seedLocalId: e }).then((s) => {
+          s && (clearInterval(a), n(s));
+        });
+      } catch {
+      }
+    }, 200);
+  });
+}, Ls = he(
+  async ({ input: { context: e, event: t } }) => {
+    const { address: n, account: a } = e, s = e.arweaveTransactions ?? [], r = e.publishUploads ?? [];
+    let { item: o } = e;
+    if (!n || typeof n != "string" || !n.trim())
+      throw new Error("No wallet address for publish. Connect a wallet and try again.");
+    if (!a)
+      throw new Error("Wallet session is missing. Reconnect your wallet and retry the publish.");
+    if (!o?.seedLocalId)
+      throw new Error(
+        "Attestation recovery failed: Item data is missing. Delete this publish record and try a full publish from the beginning."
+      );
+    typeof o.getPublishUploads != "function" && (o = await _s(o.seedLocalId));
+    const i = s.length, l = r.length;
+    if (i !== l)
+      throw new Error(
+        "Attestation recovery failed: Arweave transaction data is missing or incomplete. Delete this publish record and try a full publish from the beginning."
+      );
+    await Oe(o, a, R(), E);
+    const d = s.map(
+      (g, S) => {
+        const I = g.transaction?.id;
+        if (!I || typeof I != "string")
+          throw new Error(
+            "Attestation recovery failed: Arweave transaction data did not survive restore. Delete this publish record and try a full publish from the beginning."
+          );
+        const q = r[S];
+        if (!q) throw new Error("Publish upload index mismatch");
+        return { ...q, txId: I };
+      }
+    );
+    await pn(d.map((g) => g.txId));
+    const m = await o.getPublishPayload(d, { publishMode: e.publishMode ?? "patch" }), h = (Array.isArray(m) ? m : [m]).map((g) => {
+      const S = (g?.listOfAttestations ?? []).map((I) => {
+        const q = Array.isArray(I?.data) ? I.data : [];
+        return {
+          schema: z(I?.schema),
+          data: q.map((D) => ({
+            ...D,
+            refUID: z(D?.refUID),
+            data: Rs(D?.data)
+          }))
+        };
+      }), v = (g?.propertiesToUpdate ?? []).map((I) => ({
+        ...I,
+        propertySchemaUid: z(I?.propertySchemaUid)
+      }));
+      return {
+        ...g,
+        seedUid: z(g?.seedUid),
+        seedSchemaUid: z(g?.seedSchemaUid),
+        versionUid: z(g?.versionUid),
+        versionSchemaUid: z(g?.versionSchemaUid),
+        listOfAttestations: S,
+        propertiesToUpdate: v
+      };
+    }), u = new Map(h.map((g) => [g.localId, g])), y = {
+      recipient: Xe,
+      expirationTime: BigInt(0),
+      revocable: !0,
+      refUID: W,
+      data: W,
+      value: BigInt(0)
+    };
+    for (const g of h)
+      for (const S of g.propertiesToUpdate ?? []) {
+        const v = S.publishLocalId, I = z(S.propertySchemaUid);
+        if (!v || !I) continue;
+        const q = u.get(v);
+        if (!q?.listOfAttestations) continue;
+        const D = q.listOfAttestations.find(
+          (w) => z(w?.schema)?.toLowerCase() === I?.toLowerCase()
+        );
+        D && (!Array.isArray(D.data) || D.data.length === 0) && (D.data = [{ ...y, refUID: W }]);
+      }
+    const f = R();
+    for (let g = 0; g < h.length; g++) {
+      const S = h[g];
+      let v = S.seedUid, I = S.versionUid;
+      if (v === W) {
+        const D = wt(f, E, {
+          schema: S.seedSchemaUid,
+          data: {
+            refUID: W,
+            data: qe(S.seedSchemaUid),
+            revocable: S.seedIsRevocable
+          }
+        }), w = await k({ account: a, transaction: D }), U = await H({
+          client: f,
+          chain: E,
+          transactionHash: w.transactionHash
+        });
+        if (!U) throw new Error("Failed to create Seed attestation");
+        const { easContractAddress: F } = x(), A = bt(U, F);
+        if (!A || A === W)
+          throw new Error("Failed to get Seed UID from attestation receipt");
+        v = A, S.seedUid = A, be("created Seed attestation", v);
+      }
+      if (v !== W && I === W) {
+        const D = wt(f, E, {
+          schema: S.versionSchemaUid,
+          data: {
+            refUID: v,
+            data: qe(S.versionSchemaUid),
+            revocable: !0
+          }
+        }), w = await k({ account: a, transaction: D }), U = await H({
+          client: f,
+          chain: E,
+          transactionHash: w.transactionHash
+        });
+        if (!U) throw new Error("Failed to create Version attestation");
+        const { easContractAddress: F } = x(), A = bt(U, F);
+        if (!A || A === W)
+          throw new Error("Failed to get Version UID from attestation receipt");
+        I = A, S.versionUid = A, await Bn({
+          seedLocalId: S.localId,
+          versionUid: A,
+          publisher: n
+        }), be("created Version attestation", I);
+      }
+      for (const D of S.listOfAttestations)
+        for (const w of D.data)
+          w.refUID = I;
+      for (const D of S.propertiesToUpdate ?? []) {
+        const w = u.get(D.publishLocalId);
+        if (!w?.listOfAttestations) continue;
+        const U = z(D.propertySchemaUid), F = w.listOfAttestations.find(
+          (A) => z(A?.schema)?.toLowerCase() === U?.toLowerCase()
+        );
+        F?.data?.[0] && (F.data[0].data = qe(v));
+      }
+      const q = S.listOfAttestations.map((D) => ({
+        schema: D.schema,
+        data: D.data.map((w) => ({
+          recipient: w.recipient ?? Xe,
+          expirationTime: w.expirationTime ?? 0n,
+          revocable: w.revocable ?? !0,
+          refUID: w.refUID ?? W,
+          data: w.data ?? "0x",
+          value: w.value ?? 0n
+        }))
+      }));
+      if (q.length > 0) {
+        const D = Aa(f, E, q), w = await k({ account: a, transaction: D });
+        if (!await H({
+          client: f,
+          chain: E,
+          transactionHash: w.transactionHash
+        })) throw new Error("Failed to create property attestations");
+        be("created property attestations for request", g);
+      }
+    }
+    ln(o, h);
+    const b = o;
+    h[0]?.seedUid && h[0].seedUid !== W && await un(b, n);
+    try {
+      await Cs({ normalizedRequests: h, item: o });
+    } catch (g) {
+      throw g instanceof Zt || be("verifyAttestations failed (non-verification error):", g), g;
+    }
+    return be("direct EAS publish complete"), mn(e), { easPayload: m };
+  }
+), Ms = async (e) => {
+  let t;
+  try {
+    t = await se.find({ seedLocalId: e });
+  } catch {
+  }
+  return t || new Promise((n) => {
+    const a = setInterval(() => {
+      se.find({ seedLocalId: e }).then((s) => {
+        s && (clearInterval(a), n(s));
+      }).catch(() => {
+      });
+    }, 200);
+  });
+};
+async function Os(e) {
+  const n = typeof e.getPublishUploads == "function" ? e : await Ms(e.seedLocalId);
+  return await Nn(n);
+}
+const pe = /* @__PURE__ */ new Set(), Bs = ye(({ sendBack: e, input: { context: t } }) => {
+  const { item: n, account: a, publishMode: s } = t;
+  return (async () => {
+    if (!await Ft(n)) {
+      e({ type: "notOwner" });
+      return;
+    }
+    if (pe.has(n.seedLocalId)) {
+      e({
+        type: "redundantPublishProcess"
+      });
+      return;
+    }
+    pe.add(n.seedLocalId);
+    try {
+      a && await Oe(n, a, R(), E);
+      const c = await Fn(n, [], {
+        publishMode: s ?? "patch"
+      });
+      if (!c.isValid) {
+        pe.delete(n.seedLocalId), e({ type: "validationFailed", errors: c.errors });
+        return;
+      }
+      if (await Os(n)) {
+        const l = x().useArweaveBundler;
+        e({ type: l ? "validPublishProcessBundler" : "validPublishProcess" });
+      } else
+        e({ type: "skipArweave" });
+    } catch (c) {
+      pe.delete(n.seedLocalId), console.error("[checking] itemNeedsArweaveUpload failed", c), e({ type: "skipArweave" });
+    }
+  })().catch(() => {
+    pe.delete(n.seedLocalId), e({ type: "validPublishProcess" });
+  }), () => {
+    pe.delete(n.seedLocalId);
+  };
+}), {
+  SUCCESS: Ze,
+  FAILURE: Ke
+} = L;
+function ee(e) {
+  const t = e;
+  return t.error ?? t.data;
+}
+const fn = qt({
+  types: {
+    context: {},
+    input: {}
+  },
+  actors: {
+    createArweaveTransactions: $a,
+    createArweaveDataItems: as,
+    sendReimbursementRequest: ds,
+    pollForConfirmation: ls,
+    uploadData: ps,
+    uploadViaBundler: ms,
+    createAttestations: Ts,
+    createAttestationsDirectToEas: Ls,
+    checking: Bs
+  },
+  actions: {
+    /** Log error; error/errorStep are assigned per transition. Supports both event.error (custom events) and event.data (XState fromPromise invoke errors). */
+    handleError: ({ event: e }) => {
+      const t = ee(e);
+      t != null ? console.error(t) : console.error("Unknown error (full event):", e);
+    },
+    assignErrorCreatingArweaveTransactions: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "creatingArweaveTransactions"
+    }),
+    assignErrorCreatingArweaveDataItems: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "creatingArweaveDataItems"
+    }),
+    assignErrorSendingReimbursementRequest: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "sendingReimbursementRequest"
+    }),
+    assignErrorPollingForConfirmation: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "pollingForConfirmation"
+    }),
+    assignErrorUploadingData: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "uploadingData"
+    }),
+    assignErrorUploadingViaBundler: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "uploadingViaBundler"
+    }),
+    assignErrorCreatingAttestations: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "creatingAttestations"
+    }),
+    assignErrorCreatingAttestationsDirectToEas: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "creatingAttestationsDirectToEas"
+    }),
+    assignAccountFromRetry: T({
+      account: ({ event: e }) => e.account
+    }),
+    assignErrorNotOwner: T({
+      error: () => new Error("Item is read-only: you do not own this item. Only the publisher can publish."),
+      errorStep: () => "checking"
+    }),
+    assignErrorValidationFailed: T({
+      error: ({ event: e }) => {
+        const n = e.errors ?? [], a = n.length > 0 ? `Validation failed (${n.length} error${n.length === 1 ? "" : "s"}):
+${n.map((r) => r.message).join(`
+`)}` : "Validation failed", s = new Error(a);
+        return s.validationErrors = n, s;
+      },
+      errorStep: () => "checking"
+    })
+  }
+}).createMachine({
+  id: "publish",
+  initial: "checking",
+  context: ({ input: e }) => e,
+  states: {
+    checking: {
+      on: {
+        notOwner: {
+          target: Ke,
+          actions: ["assignErrorNotOwner", "handleError"]
+        },
+        validationFailed: {
+          target: Ke,
+          actions: ["assignErrorValidationFailed", "handleError"]
+        },
+        redundantPublishProcess: {
+          target: "stopping"
+        },
+        validPublishProcess: {
+          target: "creatingArweaveTransactions"
+        },
+        validPublishProcessBundler: {
+          target: "creatingArweaveDataItems"
+        },
+        skipArweave: [
+          {
+            guard: () => x().useDirectEas,
+            target: "creatingAttestationsDirectToEas",
+            actions: T({
+              arweaveTransactions: () => [],
+              publishUploads: () => []
+            })
+          },
+          {
+            guard: () => !x().useDirectEas,
+            target: "creatingAttestations",
+            actions: T({
+              arweaveTransactions: () => [],
+              publishUploads: () => []
+            })
+          }
+        ]
+      },
+      invoke: {
+        src: "checking",
+        input: ({ context: e }) => ({ context: e })
+      }
+    },
+    creatingArweaveTransactions: {
+      invoke: {
+        src: "createArweaveTransactions",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: "sendingReimbursementRequest",
+          actions: T({
+            arweaveTransactions: ({ event: e }) => e.output.arweaveTransactions,
+            publishUploads: ({ event: e }) => e.output.publishUploads
+          })
+        },
+        onError: {
+          target: "failure",
+          actions: ["assignErrorCreatingArweaveTransactions", "handleError"]
+        }
+      }
+    },
+    creatingArweaveDataItems: {
+      invoke: {
+        src: "createArweaveDataItems",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: "uploadingViaBundler",
+          actions: T({
+            arweaveTransactions: ({ event: e }) => e.output.arweaveTransactions,
+            publishUploads: ({ event: e }) => e.output.publishUploads,
+            arweaveUploadData: ({ event: e }) => e.output.arweaveUploadData,
+            signedDataItems: ({ event: e }) => e.output.signedDataItems
+          })
+        },
+        onError: {
+          target: "failure",
+          actions: ["assignErrorCreatingArweaveDataItems", "handleError"]
+        }
+      }
+    },
+    sendingReimbursementRequest: {
+      invoke: {
+        src: "sendReimbursementRequest",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: "pollingForConfirmation",
+          actions: T({
+            requestResponse: ({ event: e }) => e.output,
+            reimbursementTransactionId: ({ event: e }) => e.output.transactionId
+          })
+        },
+        onError: {
+          target: "failure",
+          actions: ["assignErrorSendingReimbursementRequest", "handleError"]
+        }
+      }
+    },
+    pollingForConfirmation: {
+      invoke: {
+        src: "pollForConfirmation",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: "uploadingData",
+          actions: T({
+            reimbursementConfirmed: !0
+          })
+        },
+        onError: {
+          target: "failure",
+          actions: ["assignErrorPollingForConfirmation", "handleError"]
+        }
+      }
+    },
+    uploadingViaBundler: {
+      on: {
+        uploadComplete: [
+          {
+            guard: () => x().useDirectEas,
+            target: "creatingAttestationsDirectToEas",
+            actions: T({
+              completionPercentage: 100
+            })
+          },
+          {
+            guard: () => !x().useDirectEas,
+            target: "creatingAttestations",
+            actions: T({
+              completionPercentage: 100
+            })
+          }
+        ],
+        uploadError: {
+          target: "failure",
+          actions: ["assignErrorUploadingViaBundler", "handleError"]
+        }
+      },
+      invoke: {
+        src: "uploadViaBundler",
+        input: ({ context: e }) => ({ context: e })
+      }
+    },
+    uploadingData: {
+      on: {
+        updatePercentage: {
+          actions: T({
+            completionPercentage: ({ event: e }) => e.completionPercentage,
+            uploaderState: ({ event: e }) => e.uploaderState,
+            currentTransactionIndex: ({ event: e }) => e.currentTransactionIndex
+          })
+        },
+        uploadComplete: [
+          {
+            guard: () => x().useDirectEas,
+            target: "creatingAttestationsDirectToEas",
+            actions: T({
+              completionPercentage: 100
+            })
+          },
+          {
+            guard: () => !x().useDirectEas,
+            target: "creatingAttestations",
+            actions: T({
+              completionPercentage: 100
+            })
+          }
+        ],
+        uploadError: {
+          target: "failure",
+          actions: ["assignErrorUploadingData", "handleError"]
+        }
+      },
+      invoke: {
+        src: "uploadData",
+        input: ({ context: e }) => ({ context: e })
+      }
+    },
+    creatingAttestations: {
+      invoke: {
+        src: "createAttestations",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: Ze,
+          actions: T({
+            easPayload: ({ event: e }) => e.output?.easPayload
+          })
+        },
+        onError: {
+          target: "attestationFailureRecoverable",
+          actions: ["assignErrorCreatingAttestations", "handleError"]
+        }
+      }
+    },
+    attestationFailureRecoverable: {
+      on: {
+        retry: {
+          target: "creatingAttestations",
+          actions: ["assignAccountFromRetry"]
+        }
+      }
+    },
+    creatingAttestationsDirectToEas: {
+      invoke: {
+        src: "createAttestationsDirectToEas",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: Ze,
+          actions: T({
+            easPayload: ({ event: e }) => e.output?.easPayload
+          })
+        },
+        onError: {
+          target: "attestationFailureRecoverableDirectToEas",
+          actions: ["assignErrorCreatingAttestationsDirectToEas", "handleError"]
+        }
+      }
+    },
+    attestationFailureRecoverableDirectToEas: {
+      on: {
+        retry: {
+          target: "creatingAttestationsDirectToEas",
+          actions: ["assignAccountFromRetry"]
+        }
+      }
+    },
+    stopping: {
+      entry: ({ context: e }) => {
+        console.log(`Actor for ${e.item?.seedLocalId} stopped`);
+      },
+      type: "final"
+    },
+    [Ze]: {
+      type: "final"
+    },
+    [Ke]: {
+      type: "final"
+    }
+  }
+}), Ns = T(({ context: e, event: t }) => {
+  const n = t, a = n.publishProcesses ?? /* @__PURE__ */ new Map(), s = n.subscriptions ?? /* @__PURE__ */ new Map();
+  return {
+    publishProcesses: new Map(a),
+    subscriptions: new Map(
+      s
+    )
+  };
+});
+let hn = null;
+function Fs(e) {
+  hn = e;
+}
+function ks() {
+  return hn;
+}
+const Lt = K("seedProtocol:services:PublishManager:actors:subscribe");
+function Mt(e) {
+  const t = e.value;
+  return typeof t == "string" ? t : t && typeof t == "object" ? Object.keys(t)[0] ?? "" : "";
+}
+function Qe(e) {
+  return ua.includes(e);
+}
+const yn = ye(
+  ({ receive: e, input: { publishProcess: t, seedLocalId: n } }) => {
+    const a = ks();
+    let s = null;
+    const r = () => {
+      s != null && (clearInterval(s), s = null);
+    }, o = (i) => {
+      const l = Mt(i);
+      Qe(l) && s == null && a ? s = setInterval(() => {
+        try {
+          const d = t.getSnapshot();
+          if (d.status === "done") {
+            r();
+            return;
+          }
+          const m = Mt(d);
+          if (!Qe(m)) {
+            r();
+            return;
+          }
+        } catch {
+          return;
+        }
+        a?.savePublish(n, t);
+      }, pa) : Qe(l) || r();
+    }, c = t.subscribe(async (i) => {
+      Lt("Publish state:", i.value), a && (i.status === "done" ? (r(), a.savePublish(n, t, { triggerPublishDone: !0 })) : (a.savePublish(n, t), o(i)));
+    });
+    e(({ type: i }) => {
+      i === "UNSUBSCRIBE" && (Lt("Received UNSUBSCRIBE event"), r(), c.unsubscribe(), a?.removeSubscription(n));
+    });
+  }
+), Hs = Le(({ event: e, enqueue: t }) => {
+  const n = e, { item: a, address: s, account: r, options: o } = n;
+  if (!(s != null && typeof s == "string" && s.trim().length > 0)) {
+    console.warn("[createPublish] No valid wallet address; skipping spawn.");
+    return;
+  }
+  t.assign(({ context: i, spawn: l }) => {
+    const { publishProcesses: d } = i;
+    if (d && d.has(a.seedLocalId))
+      return console.warn(`Publish process with seedLocalId "${a.seedLocalId}" already exists.`), i;
+    const m = typeof crypto < "u" && typeof crypto.randomUUID == "function" ? crypto.randomUUID() : `run_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`, h = [
+      ...x().arweaveUploadTags ?? [],
+      ...o?.arweaveUploadTags ?? []
+    ], u = l(fn, {
+      input: {
+        item: a,
+        address: s,
+        account: r,
+        modelName: a.modelName,
+        schemaId: a.schemaUid,
+        signDataItems: o?.signDataItems,
+        dataItemSigner: o?.dataItemSigner,
+        signArweaveTransactions: o?.signArweaveTransactions,
+        arweaveJwk: o?.arweaveJwk,
+        publishMode: o?.publishMode ?? "patch",
+        publishRunId: m,
+        arweaveUploadTags: h.length ? h : void 0
+      }
+    });
+    return d.set(a.seedLocalId, u), {
+      publishProcesses: new Map(d)
+    };
+  }), t.assign(({ context: i, spawn: l }) => {
+    const { subscriptions: d, publishProcesses: m } = i, p = m.get(a.seedLocalId);
+    if (!p)
+      return console.warn(`Publish process with seedLocalId "${a.seedLocalId}" does not exist.`), i;
+    if (d && d.has(a.seedLocalId))
+      return console.warn(`Subscription with seedLocalId "${a.seedLocalId}" already exists.`), i;
+    const h = l(yn, {
+      input: { publishProcess: p, seedLocalId: a.seedLocalId }
+    });
+    return d.set(a.seedLocalId, h), {
+      subscriptions: new Map(d)
+    };
+  });
+}), $s = ({
+  context: e,
+  event: t
+}) => {
+  const n = t, { seedLocalId: a, account: s } = n, r = e.publishProcesses.get(a);
+  if (!r) {
+    console.warn(`Publish process with seedLocalId "${a}" does not exist.`);
+    return;
+  }
+  r.send({ type: "retry", account: s });
+}, Vs = Le(({ context: e, event: t, enqueue: n }) => {
+  const { publishProcesses: a, subscriptions: s } = e, { seedLocalId: r } = t, o = a.get(r);
+  if (!o) {
+    console.warn(`Publish process with seedLocalId "${r}" does not exist.`);
+    return;
+  }
+  n.stopChild(o);
+  const c = s.get(r);
+  c && n.stopChild(c);
+  const i = new Map(a);
+  i.delete(r);
+  const l = new Map(s);
+  l.delete(r), n.assign({
+    publishProcesses: i,
+    subscriptions: l
+  });
+}), qs = K("seedProtocol:PublishManager:index"), Ws = Le(({ context: e, enqueue: t }) => {
+  qs("Stopping all actors..."), e.publishProcesses.forEach((n) => {
+    t.stopChild(n);
+  }), e.subscriptions.forEach((n) => {
+    t.stopChild(n);
+  }), t.assign({
+    publishProcesses: /* @__PURE__ */ new Map(),
+    subscriptions: /* @__PURE__ */ new Map()
+  });
+}), Gs = Le(({ context: e, event: t, enqueue: n }) => {
+  const { seedLocalId: a } = t, s = e.publishProcesses.get(a);
+  if (!s) {
+    console.warn(`Publish process with seedLocalId "${a}" does not exist.`);
+    return;
+  }
+  n.stopChild(s);
+  const r = e.subscriptions.get(a);
+  r && n.stopChild(r);
+  const o = new Map(e.publishProcesses);
+  o.delete(a);
+  const c = new Map(e.subscriptions);
+  c.delete(a), n.assign({
+    publishProcesses: o,
+    subscriptions: c
+  });
+}), js = T(({ context: e, event: t }) => {
+  const { subscriptions: n } = e, { seedLocalId: a, newSubscription: s } = t;
+  return s && n.set(a, s), {
+    subscriptions: new Map(n)
+  };
+}), Ue = K("seedProtocol:services:PublishManager:actors:savePublish"), Ot = /* @__PURE__ */ new Map();
+function Ys(e, t) {
+  const a = (Ot.get(e) ?? Promise.resolve()).then(t);
+  return Ot.set(e, a.catch(() => {
+  })), a;
+}
+function Js(e) {
+  return e.status === "done" ? e.value === "success" ? "completed" : e.value === "failure" ? "failed" : "completed" : "in_progress";
+}
+const zs = 500, Te = 2e3;
+function Zs(e) {
+  return JSON.stringify(e, (t, n) => typeof n == "bigint" ? n.toString() : n);
+}
+function Bt(e) {
+  if (e == null || typeof e != "object") return;
+  const t = e, n = t.snapshot, s = (t.context ?? n?.context)?.publishRunId;
+  return typeof s == "string" && s.length > 0 ? s : void 0;
+}
+function Ks(e, t) {
+  if (!e?.error) return {};
+  if (t !== "failed" && t !== "in_progress") return {};
+  const n = e.error, a = n != null ? (n instanceof Error ? n.message : String(n)).slice(0, zs) : void 0, s = e.errorStep;
+  let r;
+  if (n instanceof Error && n.stack)
+    r = n.stack.slice(0, Te);
+  else if (n != null && typeof n == "object")
+    try {
+      r = JSON.stringify(n).slice(0, Te);
+    } catch {
+      r = String(n).slice(0, Te);
+    }
+  else n != null && (r = String(n).slice(0, Te));
+  return { errorMessage: a ?? void 0, errorStep: s, errorDetails: r };
+}
+const Qs = ye(({ sendBack: e, input: { persistedSnapshot: t, seedLocalId: n, triggerPublishDone: a } }) => {
+  Ue("savePublish seedLocalId", n);
+  const s = t;
+  Ys(n, async () => {
+    const o = B.getAppDb();
+    if (!o) {
+      Ue("savePublish: DB not ready, skipping"), e({ type: "SAVE_PUBLISH_DONE", seedLocalId: n, triggerPublishDone: a });
+      return;
+    }
+    const c = await o.select().from(P).where(sa(Z(P.seedLocalId, n), Z(P.status, "in_progress"))).orderBy(fe(P.updatedAt)).limit(1), i = typeof t == "string" ? t : Zs(t), l = Js(s), d = Date.now(), m = Ks(s.context, l);
+    if (c.length > 0) {
+      const p = c[0];
+      await o.update(P).set({
+        persistedSnapshot: i,
+        status: l,
+        updatedAt: d,
+        ...s.status === "done" && l !== "in_progress" ? { completedAt: d } : {},
+        ...m
+      }).where(Z(P.id, p.id));
+    } else {
+      const p = Bt(s);
+      if (p != null && l === "in_progress" && s.status !== "done") {
+        const b = (await o.select().from(P).where(Z(P.seedLocalId, n)).orderBy(fe(P.startedAt)).limit(1))[0];
+        if (b && (b.status === "completed" || b.status === "failed"))
+          try {
+            const g = JSON.parse(b.persistedSnapshot);
+            if (Bt(g) === p) {
+              Ue(
+                "savePublish: skip stale insert — same publishRunId as latest terminal row",
+                n,
+                p
+              );
+              return;
+            }
+          } catch {
+          }
+      }
+      const h = s.context?.item, u = s.context?.modelName ?? h?.modelName ?? "", y = s.context?.schemaId ?? h?.schemaId;
+      await o.insert(P).values({
+        seedLocalId: n,
+        modelName: u,
+        schemaId: y ?? null,
+        status: l,
+        startedAt: d,
+        persistedSnapshot: i,
+        createdAt: d,
+        updatedAt: d,
+        ...m
+      });
+    }
+  }).then(() => {
+    e({ type: "SAVE_PUBLISH_DONE", seedLocalId: n, triggerPublishDone: a });
+  }).catch((o) => {
+    Ue("savePublish error", o), e({ type: "SAVE_PUBLISH_DONE", seedLocalId: n, triggerPublishDone: a });
+  });
+});
+function Xs(e) {
+  try {
+    return e.getPersistedSnapshot?.() ?? e.getSnapshot();
+  } catch {
+    const t = e.getSnapshot(), n = t.context;
+    if (!n?.item) return t;
+    const a = n.item;
+    return {
+      ...t,
+      context: {
+        ...n,
+        item: {
+          seedLocalId: a.seedLocalId,
+          modelName: a.modelName,
+          schemaId: a.schemaId
+        }
+      }
+    };
+  }
+}
+const er = T(({ context: e, event: t, spawn: n }) => {
+  const { publishProcesses: a } = e, { seedLocalId: s, publishProcess: r, triggerPublishDone: o } = t;
+  if (!r)
+    return e;
+  const c = new Map(a);
+  c.set(s, r);
+  const i = Xs(r);
+  return n(Qs, {
+    id: `savePublish_${s}_${Date.now()}`,
+    input: { persistedSnapshot: i, seedLocalId: s, triggerPublishDone: o }
+  }), { publishProcesses: c };
+}), tr = T(({ context: e, event: t }) => {
+  const { publishProcesses: n, subscriptions: a } = e, s = t.seedLocalId, r = a.get(s);
+  r && r.send({ type: "UNSUBSCRIBE" });
+  const o = new Map(n);
+  o.delete(s);
+  const c = new Map(a);
+  return c.delete(s), {
+    publishProcesses: o,
+    subscriptions: c
+  };
+}), nr = T(({ context: e, event: t }) => {
+  const { subscriptions: n } = e, a = t.seedLocalId, s = new Map(n);
+  return s.delete(a), {
+    subscriptions: s
+  };
+}), ar = 6e4, sr = 2e3;
+async function rr(e) {
+  const t = Date.now() + e;
+  for (; Date.now() < t; ) {
+    if (B.PlatformClass && B.getAppDb()) return !0;
+    await new Promise((n) => setTimeout(n, sr));
+  }
+  return !1;
+}
+function or(e) {
+  const t = e.value;
+  return typeof t == "string" ? t : t && typeof t == "object" ? Object.keys(t)[0] ?? "" : "";
+}
+function ir(e) {
+  const t = or(e);
+  if (t === "pollingForConfirmation" && (!e.context?.reimbursementTransactionId || !e.context?.requestResponse))
+    return !1;
+  if (t === "uploadingData") {
+    const n = e.context?.arweaveTransactions, a = e.context?.publishUploads;
+    if (!Array.isArray(n) || n.length === 0 || !Array.isArray(a)) return !1;
+  }
+  return !0;
+}
+const cr = ye(
+  ({ sendBack: e, input: { context: t } }) => {
+    (async () => {
+      const a = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+      if (!await rr(ar))
+        return e({ type: "RESTORE_FROM_DB_DONE", publishProcesses: a, subscriptions: s }), { newPublishProcesses: a, newSubscriptions: s };
+      const o = B.getAppDb();
+      if (!o)
+        return e({ type: "RESTORE_FROM_DB_DONE", publishProcesses: a, subscriptions: s }), { newPublishProcesses: a, newSubscriptions: s };
+      const c = await o.select().from(P).where(Z(P.status, "in_progress")), i = /* @__PURE__ */ new Map(), l = [...c].sort(
+        (m, p) => (p.updatedAt ?? p.createdAt ?? 0) - (m.updatedAt ?? m.createdAt ?? 0)
+      );
+      for (const m of l)
+        i.has(m.seedLocalId) || i.set(m.seedLocalId, m);
+      const d = Array.from(i.values());
+      for (const m of d) {
+        let p;
+        try {
+          p = JSON.parse(m.persistedSnapshot);
+        } catch {
+          continue;
+        }
+        if (p.status === "done") continue;
+        const h = p.context?.item?.seedLocalId ?? m.seedLocalId;
+        if (!h || !ir(p)) continue;
+        p.context = p.context ?? {}, p.context.item = {
+          ...p.context.item,
+          seedLocalId: h,
+          modelName: p.context.item?.modelName ?? p.context.modelName ?? m.modelName ?? "",
+          schemaId: p.context.item?.schemaId ?? p.context.schemaId ?? m.schemaId ?? void 0
+        };
+        const u = et(fn, {
+          snapshot: p,
+          input: void 0
+        }), y = et(yn, {
+          input: {
+            publishProcess: u,
+            seedLocalId: h
+          }
+        });
+        a.set(h, u), s.set(h, y), u.start(), y.start();
+      }
+      return { newPublishProcesses: a, newSubscriptions: s };
+    })().then((a) => {
+      if (!a) return;
+      const { newPublishProcesses: s, newSubscriptions: r } = a;
+      e({
+        type: "RESTORE_FROM_DB_DONE",
+        publishProcesses: s,
+        subscriptions: r
+      });
+    });
+  }
+), gn = K("seedProtocol:PublishManager:index"), dr = qt({
+  types: {
+    context: {},
+    input: {},
+    events: {}
+  },
+  actors: {
+    restoreFromDb: cr
+  },
+  actions: {
+    assignRestoreFromDb: Ns,
+    createPublish: Hs,
+    addSubscription: js,
+    requestSavePublish: er,
+    publishDone: tr,
+    removeSubscription: nr,
+    retryAttestations: $s,
+    stopPublish: Vs,
+    stopAll: Ws,
+    query: Gs
+  }
+}).createMachine({
+  id: "publishManager",
+  initial: "restoreFromDb",
+  context: {
+    publishProcesses: /* @__PURE__ */ new Map(),
+    subscriptions: /* @__PURE__ */ new Map()
+  },
+  states: {
+    restoreFromDb: {
+      on: {
+        RESTORE_FROM_DB_DONE: {
+          target: "active",
+          actions: ["assignRestoreFromDb"]
+        }
+      },
+      invoke: {
+        src: "restoreFromDb",
+        input: ({ context: e }) => ({ context: e })
+      }
+    },
+    active: {
+      on: {
+        CREATE_PUBLISH: {
+          actions: ["createPublish"]
+        },
+        ADD_SUBSCRIPTION: {
+          actions: ["addSubscription"]
+        },
+        REQUEST_SAVE_PUBLISH: {
+          actions: ["requestSavePublish"]
+        },
+        SAVE_PUBLISH_DONE: [
+          {
+            guard: ({ event: e }) => e.triggerPublishDone === !0,
+            actions: ["publishDone"]
+          }
+        ],
+        PUBLISH_DONE: {
+          actions: ["publishDone"]
+        },
+        REMOVE_SUBSCRIPTION: {
+          actions: ["removeSubscription"]
+        },
+        RETRY_ATTESTATIONS: {
+          actions: ["retryAttestations"]
+        },
+        STOP_PUBLISH: {
+          actions: ["stopPublish"]
+        },
+        QUERY: {
+          actions: ["query"]
+        },
+        STOP_ALL: {
+          actions: ["stopAll"]
+        }
+      }
+    }
+  }
+}), O = et(dr, {
+  input: {
+    publishProcesses: /* @__PURE__ */ new Map(),
+    subscriptions: /* @__PURE__ */ new Map()
+  }
+});
+Fs({
+  savePublish: (e, t, n) => {
+    O.send({
+      type: "REQUEST_SAVE_PUBLISH",
+      seedLocalId: e,
+      publishProcess: t,
+      triggerPublishDone: n?.triggerPublishDone
+    });
+  },
+  onPublishDone: (e) => {
+    O.send({ type: "PUBLISH_DONE", seedLocalId: e });
+  },
+  removeSubscription: (e) => {
+    O.send({ type: "REMOVE_SUBSCRIPTION", seedLocalId: e });
+  }
+});
+const lr = O.subscribe((e) => {
+  gn("PublishManager snapshot:", e);
+});
+typeof document < "u" && (O.start(), window.addEventListener("load", () => {
+  gn("PublishManager started");
+}), window.addEventListener("beforeunload", () => {
+  lr.unsubscribe(), O.stop();
+}));
+const at = {
+  getService: () => O,
+  createPublish: (e, t, n, a) => O.send({ type: "CREATE_PUBLISH", item: e, address: t, account: n, options: a }),
+  retryAttestations: (e, t) => O.send({ type: "RETRY_ATTESTATIONS", seedLocalId: e, account: t }),
+  stopPublish: (e) => O.send({ type: "STOP_PUBLISH", seedLocalId: e }),
+  query: (e) => O.send({ type: "QUERY", seedLocalId: e }),
+  stopAll: () => O.send({ type: "STOP_ALL" }),
+  getPublish: (e) => O.getSnapshot().context.publishProcesses.get(e),
+  savePublish: (e, t) => O.send({ type: "REQUEST_SAVE_PUBLISH", seedLocalId: e, publishProcess: t }),
+  addSubscription: (e, t) => O.send({ type: "ADD_SUBSCRIPTION", seedLocalId: e, newSubscription: t }),
+  removeSubscription: (e) => O.send({ type: "REMOVE_SUBSCRIPTION", seedLocalId: e })
+};
+function Ho(e) {
+  return e === "creatingAttestationsDirectToEas" ? "creatingAttestations" : e;
+}
+function ur(e, t, n) {
+  return e != null ? n : t?.status === "completed" ? L.SUCCESS : t?.status === "failed" ? L.FAILURE : n;
+}
+function pr(e) {
+  if (e) {
+    if (e.status === "failed") return L.FAILURE;
+    if (e.status === "completed") return L.SUCCESS;
+    if (e.completedAt != null) {
+      try {
+        const t = JSON.parse(e.persistedSnapshot);
+        if (t.status === "done" && t.value === L.FAILURE)
+          return L.FAILURE;
+      } catch {
+      }
+      return L.SUCCESS;
+    }
+    try {
+      const t = JSON.parse(e.persistedSnapshot);
+      if (t.status === "done") {
+        if (t.value === L.SUCCESS) return L.SUCCESS;
+        if (t.value === L.FAILURE) return L.FAILURE;
+      }
+      if (typeof t.value == "string") return t.value;
+    } catch {
+      return;
+    }
+  }
+}
+function mr(e) {
+  return !e || e.status !== "done" ? !1 : e.value === L.SUCCESS || e.value === L.FAILURE;
+}
+function fr(e) {
+  const t = at.getService(), n = ia(t, (h) => h?.context?.publishProcesses?.get(e) ?? null), a = Ht(null);
+  te(() => {
+    a.current = null;
+  }, [e]);
+  const [s, r] = Ae(void 0), [o, c] = Ae(null), i = B.getAppDb(), d = ve(
+    e && i ? i.select().from(P).where(Z(P.seedLocalId, e)).orderBy(fe(P.startedAt)).limit(1) : null
+  )?.[0], m = d?.status, p = $t(() => {
+    if (n != null)
+      return s;
+    if (o === "success" || o === "failure")
+      return o;
+    const h = pr(d);
+    return h === L.SUCCESS || h === L.FAILURE ? h : ur(
+      n,
+      m != null ? { status: m } : void 0,
+      s
+    );
+  }, [n, m, s, o, d]);
+  return te(() => {
+    c(null);
+  }, [e]), te(() => {
+    n == null && (m === "completed" ? c("success") : m === "failed" && c("failure"));
+  }, [m, n]), te(() => {
+    n != null && c(null);
+  }, [n]), te(() => {
+    if (!n) {
+      const y = a.current;
+      mr(y) ? (r(y.value), y.value === L.SUCCESS ? c("success") : y.value === L.FAILURE && c("failure")) : r(void 0);
+      return;
+    }
+    const h = n.getSnapshot();
+    a.current = { value: h?.value, status: h.status }, r(h?.value);
+    const u = n.subscribe((y) => {
+      a.current = { value: y?.value, status: y?.status }, r(y?.value);
+    });
+    return () => {
+      u.unsubscribe();
+    };
+  }, [n, e]), {
+    publishProcess: n ?? null,
+    value: p
+  };
+}
+function $o(e) {
+  const [t, n] = Ae(!0);
+  return te(() => {
+    if (!e) {
+      n(!1);
+      return;
+    }
+    Ft(e).then(n).catch(() => n(!1));
+  }, [e?.seedLocalId]), t;
+}
+function hr(e) {
+  const t = B.getAppDb(), a = ve(
+    e && t ? t.select().from(De).where(Z(De.seedLocalId, e)).orderBy(fe(De.updatedAt)) : null
+  ) ?? [];
+  return $t(() => {
+    const r = a.filter((c) => c.phase === "pending_l1").length, o = a.filter((c) => c.phase === "confirmed").length;
+    return {
+      hasPendingL1: r > 0,
+      pendingCount: r,
+      confirmedCount: o,
+      jobs: a
+    };
+  }, [a]);
+}
+function Vo(e) {
+  const { publishProcess: t, value: n } = fr(e ?? ""), a = hr(e), s = B.getAppDb(), o = ve(
+    e && s ? s.select().from(P).where(Z(P.seedLocalId, e)).orderBy(fe(P.startedAt)).limit(1) : null
+  )?.[0], c = !!t || o?.status === "in_progress";
+  return {
+    latestRecord: o,
+    publishProcess: t,
+    isActive: c,
+    publishValue: n,
+    arweaveL1Pending: a.hasPendingL1,
+    arweaveL1Jobs: a.jobs,
+    arweaveL1Summary: a
+  };
+}
+function yr() {
+  const e = B.getAppDb();
+  return ve(
+    e ? e.select().from(P).orderBy(fe(P.startedAt)) : null
+  );
+}
+function qo() {
+  const e = yr();
+  if (e !== void 0)
+    return e.filter((t) => t.status !== "in_progress").length;
+}
+function Wo(e) {
+  const t = B.getAppDb(), n = ve(
+    e != null && t ? t.select().from(P).where(Z(P.id, e)).limit(1) : null
+  ), a = n === void 0;
+  return { record: n && n.length > 0 ? n[0] : null, isLoading: a };
+}
+async function Go() {
+  const e = B.getAppDb();
+  e && await e.delete(P).where(ra(P.status, ["in_progress"]));
+}
+async function jo() {
+  const e = B.getAppDb();
+  e && await e.delete(P);
+}
+async function Yo() {
+  const e = B.getAppDb();
+  e && await e.delete(kn);
+}
+async function Jo(e) {
+  const t = B.getAppDb();
+  t && await t.delete(P).where(Z(P.seedLocalId, e));
+}
+async function zo(e) {
+  const t = B.getAppDb();
+  t && await t.delete(P).where(Z(P.id, e));
+}
+async function Zo(e) {
+  if (e.length === 0) return;
+  const t = B.getAppDb();
+  t && await t.delete(P).where(oa(P.id, e));
+}
+function Ko(e) {
+  try {
+    return (JSON.parse(e.persistedSnapshot).context?.arweaveTransactions ?? []).map((a) => a.transaction?.id).filter((a) => typeof a == "string");
+  } catch {
+    return [];
+  }
+}
+function Qo(e) {
+  try {
+    return JSON.parse(e.persistedSnapshot).context?.easPayload ?? void 0;
+  } catch {
+    return;
+  }
+}
+function Xo(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (let n = 0; n < e.length; n++) {
+    const a = e[n]?.localId;
+    a != null && t.set(a, BigInt(n));
+  }
+  return e.map((n, a) => {
+    const s = (n.propertiesToUpdate ?? []).map((c) => {
+      const i = c.publishLocalId, l = i != null ? t.get(i) : void 0;
+      if (i != null && i !== "" && l === void 0)
+        throw new Error(
+          `publishLocalId "${i}" not found in payload (valid localIds: ${Array.from(t.keys()).join(", ")})`
+        );
+      const { publishLocalId: d, ...m } = c;
+      return {
+        ...m,
+        publishLocalIdIndex: l ?? BigInt(0)
+      };
+    }), { localId: r, ...o } = n;
+    return {
+      ...o,
+      localIdIndex: BigInt(a),
+      propertiesToUpdate: s
+    };
+  });
+}
+const gr = "A connected wallet is required for publishing with the modular executor. Connect your wallet and try again.";
+async function ei(e, t, n, a) {
+  const s = x(), r = await n();
+  if (!r || !r.trim())
+    return { outcome: "no_address" };
+  if (s.useModularExecutor) {
+    if (!t)
+      return {
+        outcome: "managed_not_ready",
+        error: new Q(gr, "MANAGED_ACCOUNT_UNAVAILABLE")
+      };
+    const c = await dn();
+    if (!c.ok)
+      return { outcome: "managed_not_ready", error: c.error };
+    const i = c.managedAddress, l = await gt(t ?? null);
+    return "needsDeploy" in l ? { outcome: "needs_deploy" } : (at.createPublish(e, i, l.account, {
+      dataItemSigner: l.account,
+      ...a
+    }), { outcome: "started" });
+  }
+  const o = await gt(t ?? null);
+  return "address" in o ? (at.createPublish(e, o.address, o.account, {
+    dataItemSigner: o.account,
+    ...a
+  }), { outcome: "started" }) : { outcome: "needs_deploy" };
+}
+export {
+  ot as $,
+  Zt as A,
+  _e as B,
+  Wr as C,
+  Ya as D,
+  es as E,
+  Ho as F,
+  pr as G,
+  ur as H,
+  Xo as I,
+  ei as J,
+  tt as K,
+  Ut as L,
+  Q as M,
+  ys as N,
+  dn as O,
+  Gr as P,
+  R as Q,
+  Nr as R,
+  Fr as S,
+  kr as T,
+  Yt as U,
+  Jt as V,
+  Re as W,
+  gt as X,
+  Hr as Y,
+  fa as Z,
+  $r as _,
+  At as a,
+  ha as a0,
+  Me as a1,
+  it as a2,
+  ya as a3,
+  jr as a4,
+  Yr as a5,
+  Jr as a6,
+  zr as a7,
+  Na as a8,
+  Zr as a9,
+  Eo as aA,
+  Io as aB,
+  Po as aC,
+  Uo as aD,
+  To as aE,
+  Do as aF,
+  xo as aG,
+  Co as aH,
+  Ro as aI,
+  _o as aJ,
+  Lo as aK,
+  Mo as aL,
+  vt as aM,
+  Oo as aN,
+  Bo as aO,
+  No as aP,
+  Fo as aQ,
+  ko as aR,
+  Kr as aa,
+  Qr as ab,
+  Fa as ac,
+  Xr as ad,
+  eo as ae,
+  to as af,
+  no as ag,
+  ao as ah,
+  so as ai,
+  ro as aj,
+  oo as ak,
+  io as al,
+  co as am,
+  lo as an,
+  uo as ao,
+  po as ap,
+  mo as aq,
+  fo as ar,
+  ho as as,
+  yo as at,
+  go as au,
+  wo as av,
+  bo as aw,
+  Ao as ax,
+  vo as ay,
+  So as az,
+  Ta as b,
+  Vr as c,
+  qr as d,
+  Oe as e,
+  at as f,
+  x as g,
+  fr as h,
+  zt as i,
+  $o as j,
+  Vo as k,
+  yr as l,
+  qo as m,
+  Wo as n,
+  Go as o,
+  fn as p,
+  jo as q,
+  Yo as r,
+  Ua as s,
+  Jo as t,
+  Da as u,
+  zo as v,
+  Zo as w,
+  Ko as x,
+  Qo as y,
+  hr as z
+};
+//# sourceMappingURL=index-BfABV7U1.js.map