@tempoxyz/patron 0.0.29 → 0.0.31

package/dist/bin.js

@@ -1,17 +1,25 @@
 #!/usr/bin/env node
 import { createRequire as __patronCreateRequire } from 'node:module'
 const require = __patronCreateRequire(import.meta.url)
+import {
+  inferHome
+} from "./chunks/chunk-NDBTADXZ.js";
+import "./chunks/chunk-GTMLTZRN.js";
 
 // src/bin.ts
+if (!process.env.PATRON_HOME) {
+  const home = inferHome(process.argv[1]);
+  if (home) process.env.PATRON_HOME = home;
+}
 if (process.argv[2] === "hook") {
-  const { runHookProcess } = await import("./chunks/hook-process-6WSLYXC7.js");
+  const { runHookProcess } = await import("./chunks/hook-process-W3ZK5FT3.js");
   await runHookProcess().catch(() => void 0);
   process.exit(0);
 } else if (process.argv[2] === "pay") {
-  const { runPayProcess } = await import("./chunks/hook-process-6WSLYXC7.js");
+  const { runPayProcess } = await import("./chunks/hook-process-W3ZK5FT3.js");
   await runPayProcess().catch(() => void 0);
   process.exit(0);
 } else {
-  const { run } = await import("./chunks/-OLVAZG3H.js");
+  const { run } = await import("./chunks/-K6MPD575.js");
   process.exitCode = await run(process.argv.slice(2));
 }

package/dist/chunks/{-OLVAZG3H.js → -K6MPD575.js}

@@ -21,7 +21,9 @@ import {
   purchasableTokens,
   readJsonObject,
   redeem,
+  refillSize,
   removeCodex,
+  storedIssuer,
   tipTokens,
   upgradeCodex,
   withHooksKey,
@@ -29,41 +31,44 @@ import {
   withPatronStatus,
   withoutPatronHandlers,
   writeJsonObject
-} from "./chunk-SAEZ54SS.js";
+} from "./chunk-AN64RW3X.js";
 import {
+  awaitRedemptions,
+  gatewayTurn,
   startRefill
-} from "./chunk-3CYJJJR3.js";
+} from "./chunk-IIB6TI3U.js";
 import {
+  inferHome,
   resolveSettings,
   settingsFor
-} from "./chunk-OQXACACU.js";
+} from "./chunk-NDBTADXZ.js";
 import {
-  AGENT_IDS,
   LeaderboardResponse,
   PatronInfo,
-  ensureHome,
-  profileMessage,
-  readConfig,
-  readJson,
-  readUsage,
-  statePaths,
-  updateUsage,
-  writeConfig,
-  writePrivateFile
-} from "./chunk-ZOQJ4CZE.js";
+  profileMessage
+} from "./chunk-GBZCXMDZ.js";
 import {
+  AGENT_IDS,
   DEFAULT_MONTHLY_BUDGET_USD,
   MAX_TOKENS_PER_PAGE,
   MIN_TOKENS_PER_PAGE,
   PACK_SIZE,
   TOKEN_PRICE_UNITS,
   clampTokensPerPage,
+  ensureHome,
   formatUsd,
   normalizePayee,
+  readConfig,
+  readJson,
+  readUsage,
+  statePaths,
   tokensToUnits,
   tryLock,
-  withLock
-} from "./chunk-EISHX7Q3.js";
+  updateUsage,
+  withLock,
+  writeConfig,
+  writePrivateFile
+} from "./chunk-JTPFWITF.js";
 import "./chunk-GTMLTZRN.js";
 
 // src/index.ts
@@ -356,15 +361,16 @@ import {
   realpath,
   rename,
   rm as rm3,
-  symlink
+  symlink,
+  writeFile as writeFile2
 } from "node:fs/promises";
 import { basename, dirname as dirname3, join as join4 } from "node:path";
 function stableBin(home) {
   return join4(home, "cli", "current", "dist", "bin.js");
 }
-async function installStableCli(home, script = process.argv[1]) {
+async function installStableCli(home, script = process.argv[1], anySource = process.platform === "win32" && Boolean(process.env.PATRON_HOME)) {
   const resolved = script ? await realpath(script).catch(() => void 0) : void 0;
-  if (!resolved || !/[/\\]_npx[/\\]/.test(resolved) || basename(resolved) !== "bin.js")
+  if (!resolved || !anySource && !/[/\\]_npx[/\\]/.test(resolved) || basename(resolved) !== "bin.js")
     return void 0;
   const packageDir = dirname3(dirname3(resolved));
   const { version } = JSON.parse(await readFile3(join4(packageDir, "package.json"), "utf8"));
@@ -377,6 +383,7 @@ async function installStableCli(home, script = process.argv[1]) {
     await rm3(staging, { force: true, recursive: true });
     await cp(join4(packageDir, "dist"), join4(staging, "dist"), { recursive: true });
     await cp(join4(packageDir, "package.json"), join4(staging, "package.json"));
+    await writeFile2(join4(staging, "origin.json"), JSON.stringify({ bin: resolved }));
     await rm3(target, { force: true, recursive: true });
     await rename(staging, target);
   }
@@ -549,23 +556,45 @@ function failure(agent, error) {
     state: "failed"
   };
 }
-async function hookCommand(env = process.env, script = process.argv[1], node = process.execPath, patronHome = env.PATRON_HOME || join5(homedir(), ".patron")) {
+async function hookCommand(env = process.env, script = process.argv[1], node = process.execPath, patronHome = env.PATRON_HOME || join5(homedir(), ".patron"), platform = process.platform) {
   if (env.PATRON_HOOK_COMMAND) return env.PATRON_HOOK_COMMAND;
-  return withPatronHome(await runCommand(script, node, patronHome), env.PATRON_HOME);
-}
-async function runCommand(script, node, patronHome) {
+  const windows = platform === "win32";
+  const run2 = await runCommand(
+    script,
+    node,
+    patronHome,
+    windows && Boolean(env.PATRON_HOME),
+    platform
+  );
+  if (!env.PATRON_HOME || windows || await runsFromHome(run2.bin, patronHome))
+    return run2.command;
+  return withPatronHome(run2.command, env.PATRON_HOME);
+}
+async function runCommand(script, node, patronHome, preferCopy, platform) {
+  const run2 = (bin) => ({
+    bin,
+    command: `${quote(node, platform)} ${quote(bin, platform)} hook`
+  });
+  const stable = stableBin(patronHome);
+  if (preferCopy && await exists(stable)) return run2(stable);
   const resolved = script ? await realpath2(script).catch(() => void 0) : void 0;
   if (resolved && /[/\\]bin\.js$/.test(resolved) && !/[/\\]_npx[/\\]/.test(resolved))
-    return `${quote(node)} ${quote(resolved)} hook`;
-  if (await exists(stableBin(patronHome)))
-    return `${quote(node)} ${quote(stableBin(patronHome))} hook`;
-  return "npx -y @tempoxyz/patron hook";
+    return run2(resolved);
+  if (await exists(stable)) return run2(stable);
+  return { command: "npx -y @tempoxyz/patron hook" };
+}
+async function runsFromHome(bin, patronHome) {
+  const inferred = inferHome(bin);
+  if (!inferred) return false;
+  const real = (path) => realpath2(path).catch(() => resolve(path));
+  return await real(inferred) === await real(patronHome);
 }
 function withPatronHome(command, patronHome) {
   return patronHome ? `PATRON_HOME=${quote(resolve(patronHome))} ${command}` : command;
 }
-function quote(value) {
-  return /^[\w./:@-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+function quote(value, platform = process.platform) {
+  if (/^[\w./:@-]+$/.test(value)) return value;
+  return platform === "win32" ? `"${value}"` : `'${value.replaceAll("'", "'\\''")}'`;
 }
 async function exists(path) {
   return access2(path).then(
@@ -751,10 +780,10 @@ async function linkRefillFailedAt(home) {
 }
 var defaultOpenWallet = async (settings, config, issuer, maxUnits) => {
   if (config.wallet === "link") {
-    const { openLinkWallet } = await import("./wallet-LOLL66ID.js");
+    const { openLinkWallet } = await import("./wallet-WR6EBMN6.js");
     return openLinkWallet(config, maxUnits);
   }
-  const { openWallet } = await import("./wallet-LOLL66ID.js");
+  const { openWallet } = await import("./wallet-WR6EBMN6.js");
   return openWallet(settings, config.wallet, issuer, maxUnits);
 };
 var REFILL_LOCK_STALE_MS = 5 * 60 * 1e3;
@@ -794,23 +823,43 @@ async function delayedRefill(base, openWallet = defaultOpenWallet, sleep = (ms)
   if (!await readConfig(base.home)) return 0;
   const release = await tryLock(
     statePaths(base.home).refillWait,
-    REFILL_DELAY_MS.max + REFILL_LOCK_STALE_MS
+    REFILL_DELAY_MS.max + REFILL_GATEWAY_WAIT_MS + REFILL_LOCK_STALE_MS
   );
   if (!release) return 0;
   try {
     await sleep(
       REFILL_DELAY_MS.min + random() * (REFILL_DELAY_MS.max - REFILL_DELAY_MS.min)
     );
+    return await refill(base, openWallet, Date.now, sleep);
   } finally {
     await release();
   }
-  return refill(base, openWallet);
 }
-async function refill(base, openWallet = defaultOpenWallet, now = Date.now) {
+var REFILL_GATEWAY_WAIT_MS = 15 * 60 * 1e3;
+async function refill(base, openWallet = defaultOpenWallet, now = Date.now, sleep) {
   const config = await readConfig(base.home);
   if (!config || config.paused) return 0;
   const settings = settingsFor(base, config);
-  await loadIssuer(settings.home, settings.gatewayUrl).catch(() => void 0);
+  const stale = (await storedIssuer(settings.home, settings.gatewayUrl))?.stale ?? true;
+  const low = needsRefill(await new FileTokenStore(settings.home).count()) && await linkBackedOff(settings.home, config, now()) === false && await readUsage(settings.home).then(
+    (usage) => refillSize(config, usage) > 0,
+    () => true
+  );
+  if (!stale && !low) return 0;
+  const bought = await gatewayTurn(
+    settings.home,
+    async () => {
+      const current = await readConfig(base.home);
+      if (!current || current.paused) return 0;
+      const latest = settingsFor(base, current);
+      if (stale) await loadIssuer(latest.home, latest.gatewayUrl).catch(() => void 0);
+      return low ? refillLocked(latest, current, openWallet, now) : 0;
+    },
+    { maxWaitMs: REFILL_GATEWAY_WAIT_MS, ...sleep ? { sleep } : {} }
+  );
+  return bought ?? 0;
+}
+async function refillLocked(settings, config, openWallet, now) {
   const release = await tryLock(
     statePaths(settings.home).refillLock,
     REFILL_LOCK_STALE_MS
@@ -820,8 +869,7 @@ async function refill(base, openWallet = defaultOpenWallet, now = Date.now) {
     if (!needsRefill(await new FileTokenStore(settings.home).count())) return 0;
     if (config.wallet !== "link")
       return await buyWithinBudget(settings, config, PACK_SIZE, openWallet);
-    const failedAt = await linkRefillFailedAt(settings.home);
-    if (failedAt !== void 0 && now() - failedAt < LINK_REFILL_BACKOFF_MS) return 0;
+    if (await linkBackedOff(settings.home, config, now())) return 0;
     const path = statePaths(settings.home).linkRefill;
     try {
       const bought = await buyWithinBudget(settings, config, PACK_SIZE, openWallet);
@@ -835,6 +883,11 @@ async function refill(base, openWallet = defaultOpenWallet, now = Date.now) {
     await release();
   }
 }
+async function linkBackedOff(home, config, now) {
+  if (config.wallet !== "link") return false;
+  const failedAt = await linkRefillFailedAt(home);
+  return failedAt !== void 0 && now - failedAt < LINK_REFILL_BACKOFF_MS;
+}
 
 // src/render.ts
 function tokensUsd(tokens) {
@@ -871,9 +924,20 @@ function formatStatus(view, color) {
     ),
     row(
       "Rank",
-      standing?.rank ? `#${standing.rank} \xB7 ${tokensUsd(standing.tokens)} added` : styleText("not ranked yet", "dim", color),
+      standing?.rank ? `#${standing.rank} \xB7 ${tokensUsd(standing.tokens)} added${view.standingSkipped ? styleText(" (last check)", "dim", color) : ""}` : view.standingSkipped ? styleText("not checked right now", "dim", color) : styleText("not ranked yet", "dim", color),
       color
     ),
+    ...view.standingSkipped ? [
+      row(
+        "",
+        styleText(
+          "Checked once your agents' payments go quiet, so the two can't be linked.",
+          "dim",
+          color
+        ),
+        color
+      )
+    ] : [],
     row(
       "Agents",
       config.agents.length > 0 ? config.agents.map((agent) => AGENT_LABELS[agent]).join(", ") : styleText("none", "dim", color),
@@ -925,6 +989,76 @@ PATRON_WALLET=link (pay with Link through link-cli), PATRON_LINK_CLI (its path).
 var UsageError = class extends Error {
 };
 var TIP_BATCH = 8;
+var TIP_REDEEM_TIMEOUT_MS = 3e4;
+var TIP_BATCH_LEASE_MS = 6e4;
+async function inGatewayTurn(deps, fn) {
+  const result = await gatewayTurn(
+    deps.settings.home,
+    async () => ({ value: await fn() }),
+    gatewayWaiting(deps)
+  );
+  return result.value;
+}
+function gatewayWaiting(deps) {
+  return {
+    ...waiting(deps),
+    onWait: (ms) => say(
+      deps,
+      styleText(
+        `  Waiting ${minutes(ms)} after the last payment, so Patron can't link the two.`,
+        "dim",
+        deps.color
+      )
+    )
+  };
+}
+async function currentIssuer(deps, settings) {
+  const stored = await storedIssuer(settings.home, settings.gatewayUrl);
+  if (stored && !stored.stale) return stored.issuer;
+  return inGatewayTurn(
+    deps,
+    () => loadIssuer(settings.home, settings.gatewayUrl, { fetch: deps.fetch, fresh: true })
+  );
+}
+async function standingFor(deps, settings, config) {
+  const address = config.address.toLowerCase();
+  if (!address) return {};
+  const path = statePaths(settings.home).standing;
+  const fetched = await gatewayTurn(
+    settings.home,
+    async () => ({
+      standing: await fetchStanding(
+        settings.gatewayUrl,
+        address,
+        config.name,
+        deps.fetch
+      ).catch(() => void 0)
+    }),
+    { maxWaitMs: 0, want: false }
+  ).catch(() => void 0);
+  if (fetched) {
+    if (fetched.standing)
+      await writePrivateFile(
+        path,
+        JSON.stringify({
+          address,
+          gatewayUrl: settings.gatewayUrl,
+          standing: fetched.standing
+        })
+      ).catch(() => void 0);
+    return { standing: fetched.standing };
+  }
+  const cached = await readJson(path).catch(() => void 0);
+  const last = cached?.address === address && cached.gatewayUrl === settings.gatewayUrl ? cached.standing : void 0;
+  return { skipped: true, standing: last };
+}
+function waiting(deps) {
+  return deps.sleep ? { sleep: deps.sleep } : {};
+}
+function minutes(ms) {
+  const count = Math.max(1, Math.ceil(ms / 6e4));
+  return count === 1 ? "about a minute" : `about ${count} minutes`;
+}
 function defaults() {
   const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
   const color = supportsColor(process.stdout);
@@ -936,7 +1070,7 @@ function defaults() {
     prompter: () => createPrompter(process.stdout, color),
     settings: resolveSettings(),
     stderr: process.stderr,
-    startRefill: () => startRefill(),
+    startRefill: (options) => startRefill(options),
     stdout: process.stdout
   };
 }
@@ -1086,10 +1220,13 @@ async function setup(deps) {
   const settings = deps.settings;
   say(deps, scrollBanner(VERSION, deps.color));
   say(deps);
-  const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
-    fetch: deps.fetch,
-    fresh: true
-  }).catch((error) => {
+  const issuer = await inGatewayTurn(
+    deps,
+    () => loadIssuer(settings.home, settings.gatewayUrl, {
+      fetch: deps.fetch,
+      fresh: true
+    })
+  ).catch((error) => {
     throw new Error(`Cannot reach Patron at ${settings.gatewayUrl}: ${error.message}`);
   });
   const budget = await askBudget(deps, DEFAULT_MONTHLY_BUDGET_USD);
@@ -1114,7 +1251,10 @@ async function setup(deps) {
   const starter = config.wallet === "link" ? PACK_SIZE : STARTER_TOKENS;
   const first = purchasableTokens(config, await readUsage(settings.home), starter);
   step(deps, `Adding ${tokensUsd(first)} to your balance`);
-  const bought = await buyWithinBudget(settings, config, starter, deps.openWallet);
+  const bought = await inGatewayTurn(
+    deps,
+    () => buyWithinBudget(settings, config, starter, deps.openWallet)
+  );
   done(deps, `${tokensUsd(bought)} ready to pay sites`);
   deps.startRefill();
   await installStableCli(settings.home).catch(() => void 0);
@@ -1163,7 +1303,7 @@ async function tempoSignIn(deps, budgetUnits, issuer) {
     deps,
     deps.settings.privateKey ? "Using PATRON_PRIVATE_KEY" : "Signing in with Tempo Wallet"
   );
-  const { signIn } = await import("./wallet-LOLL66ID.js");
+  const { signIn } = await import("./wallet-WR6EBMN6.js");
   const account = await signIn(deps.settings, {
     budgetUnits,
     issuer,
@@ -1221,18 +1361,23 @@ async function askBudget(deps, fallback) {
 }
 async function status(deps, menu) {
   const { config, settings } = await loadSetup(deps);
-  const [tokensLeft, usage, standing, refillFailedAt] = await Promise.all([
+  const [tokensLeft, usage, rank, refillFailedAt] = await Promise.all([
     new FileTokenStore(settings.home).count(),
     readUsage(settings.home),
-    config.address ? fetchStanding(settings.gatewayUrl, config.address, config.name, deps.fetch).catch(
-      () => void 0
-    ) : void 0,
+    standingFor(deps, settings, config),
     config.wallet === "link" ? linkRefillFailedAt(settings.home) : void 0
   ]);
   say(
     deps,
     formatStatus(
-      { config, linkRefillFailedAt: refillFailedAt, standing, tokensLeft, usage },
+      {
+        config,
+        linkRefillFailedAt: refillFailedAt,
+        standing: rank.standing,
+        ...rank.skipped ? { standingSkipped: true } : {},
+        tokensLeft,
+        usage
+      },
       deps.color
     )
   );
@@ -1277,10 +1422,8 @@ async function changeBudget(deps, input) {
   } else budget = await askBudget(deps, config.monthlyBudgetUsd);
   if (config.wallet === "tempo" && budget >= config.monthlyBudgetUsd) {
     step(deps, "Approve the new spending limit in Tempo Wallet");
-    const { authorizeBudget } = await import("./wallet-LOLL66ID.js");
-    const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
-      fetch: deps.fetch
-    });
+    const { authorizeBudget } = await import("./wallet-WR6EBMN6.js");
+    const issuer = await currentIssuer(deps, settings);
     await authorizeBudget(settings, {
       budgetUnits: BigInt(budgetTokens(budget)) * TOKEN_PRICE_UNITS,
       issuer,
@@ -1333,11 +1476,37 @@ async function tip(deps, url, amount = "0.10") {
       );
     const amount2 = Math.max(missing, purchasableTokens(config, usage, PACK_SIZE));
     step(deps, `Adding ${tokensUsd(amount2)} to your balance`);
-    await buyWithinBudget(settings, config, amount2, deps.openWallet);
+    await inGatewayTurn(
+      deps,
+      () => buyWithinBudget(settings, config, amount2, deps.openWallet)
+    );
   }
-  const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
-    fetch: deps.fetch
+  const stored = await storedIssuer(settings.home, settings.gatewayUrl);
+  let issuer = stored?.issuer ?? await inGatewayTurn(
+    deps,
+    () => loadIssuer(settings.home, settings.gatewayUrl, { fetch: deps.fetch, fresh: true })
+  );
+  let stale = stored?.stale ?? false;
+  let refreshed = false;
+  const redeemFetch = (input, init) => deps.fetch(input, { ...init, signal: AbortSignal.timeout(TIP_REDEEM_TIMEOUT_MS) });
+  let told = false;
+  const claimBatch = (cancelled) => awaitRedemptions(settings.home, TIP_BATCH_LEASE_MS, {
+    ...waiting(deps),
+    ...cancelled ? { cancelled } : {},
+    onWait: (ms) => {
+      if (told) return;
+      told = true;
+      say(
+        deps,
+        styleText(
+          `  Waiting ${minutes(ms)} after a recent purchase, so Patron can't link it to this tip. Ctrl-C keeps your balance.`,
+          "dim",
+          deps.color
+        )
+      );
+    }
   });
+  await claimBatch();
   let stopped = false;
   const stop = () => {
     stopped = true;
@@ -1349,8 +1518,11 @@ async function tip(deps, url, amount = "0.10") {
   let paid = 0;
   let sent = 0;
   let rejection;
+  let claimed = true;
   try {
     while (sent < count && !stopped) {
+      if (!claimed && !await claimBatch(() => stopped)) break;
+      claimed = false;
       const batch = await store.takeMany(Math.min(TIP_BATCH, count - sent));
       if (batch.length === 0) break;
       sent += batch.length;
@@ -1360,7 +1532,7 @@ async function tip(deps, url, amount = "0.10") {
         batch.map(
           (token) => redeem({
             domain,
-            fetch: deps.fetch,
+            fetch: redeemFetch,
             issuer,
             relayUrl: settings.relayUrl,
             token
@@ -1393,12 +1565,31 @@ async function tip(deps, url, amount = "0.10") {
             deps.color
           )
         );
-      if (ok === 0 && (rejected > 0 || unsent.length > 0)) break;
+      if (ok === 0 && (rejected > 0 || unsent.length > 0)) {
+        if (rejected === 0 && stale && !refreshed) {
+          refreshed = true;
+          const fresh = await gatewayTurn(
+            settings.home,
+            () => loadIssuer(settings.home, settings.gatewayUrl, {
+              fetch: deps.fetch,
+              fresh: true
+            }),
+            { ...gatewayWaiting(deps), cancelled: () => stopped }
+          ).catch(() => void 0);
+          if (fresh) {
+            issuer = fresh;
+            stale = false;
+            continue;
+          }
+        }
+        break;
+      }
     }
   } finally {
     process.off("SIGINT", stop);
     process.off("SIGTERM", stop);
   }
+  if (stale) deps.startRefill({ delayed: true });
   if (stopped && sent < count)
     throw new Error(
       `Tip stopped: tipped ${domain} ${tokensUsd(paid)} of ${tokensUsd(count)}; the rest stays in your balance.`
@@ -1426,12 +1617,13 @@ async function setName(deps, name) {
     throw new UsageError(
       "Leaderboard names belong to Tempo addresses; Link purchases are not ranked."
     );
-  const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
-    fetch: deps.fetch
-  });
-  const open = deps.openWallet ?? (async (s, c, i, max) => (await import("./wallet-LOLL66ID.js")).openWallet(s, c.wallet, i, max));
+  const issuer = await currentIssuer(deps, settings);
+  const open = deps.openWallet ?? (async (s, c, i, max) => (await import("./wallet-WR6EBMN6.js")).openWallet(s, c.wallet, i, max));
   const wallet = await open(settings, config, issuer, 0n);
-  await setProfile(settings.gatewayUrl, wallet, name, deps.fetch);
+  await inGatewayTurn(
+    deps,
+    () => setProfile(settings.gatewayUrl, wallet, name, deps.fetch)
+  );
   await writeConfig(settings.home, { ...config, name });
   done(deps, `Leaderboard name set to ${name}.`);
 }

package/dist/chunks/{chunk-HQ2ZLUTT.js → chunk-6G6SAUGB.js}

@@ -3,7 +3,7 @@ const require = __patronCreateRequire(import.meta.url)
 import {
   isExcludedByDefault,
   normalizePayee
-} from "./chunk-EISHX7Q3.js";
+} from "./chunk-JTPFWITF.js";
 
 // src/hook-input.ts
 var HOOK_TIMEOUT_MS = 2e3;

package/dist/chunks/{chunk-SAEZ54SS.js → chunk-AN64RW3X.js}

@@ -3,22 +3,22 @@ const require = __patronCreateRequire(import.meta.url)
 import {
   IssueResponse,
   IssuerInfo,
-  RedeemResponse,
-  ensureHome,
-  readJson,
-  statePaths,
-  writePrivateFile
-} from "./chunk-ZOQJ4CZE.js";
+  RedeemResponse
+} from "./chunk-GBZCXMDZ.js";
 import {
   ISSUER_NAME,
   MAX_TOKENS_PER_PURCHASE,
   PACK_SIZE,
   TOKEN_PRICE_UNITS,
   TOKEN_TYPE,
+  ensureHome,
   fromBase64Url,
+  readJson,
+  statePaths,
   toBase64Url,
-  withLock
-} from "./chunk-EISHX7Q3.js";
+  withLock,
+  writePrivateFile
+} from "./chunk-JTPFWITF.js";
 import {
   __commonJS,
   __export,