openzoo 0.51.7 → 0.51.8

package/lib/chatgpt-spend.js

@@ -1,6 +1,7 @@
 /** Read-only savings overlay for the OpenZoo ChatGPT profile. */
 import fs from 'node:fs';
 import path from 'node:path';
+import os from 'node:os';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { cdpSession, listCdpPages } from './ozSpendChip.js';
@@ -149,7 +150,27 @@ export async function watchChatGptSpend({ profile, proxyPort, fetchImpl = fetch,
   } finally { for (const session of sessions.values()) session.close(); }
 }
 
+/** A current launcher supplies a native pill even when the chat app disables debugging. */
+export function nativeSavingsLauncher({ platform = process.platform, home = os.homedir(), env = process.env, exists = fs.existsSync } = {}) {
+  const roots = platform === 'darwin'
+    ? ['/Applications/OpenZoo Launcher.app/Contents', path.join(home, 'Applications/OpenZoo Launcher.app/Contents')]
+    : platform === 'win32' ? [path.join(env.LOCALAPPDATA || home, 'Programs/openzoo-launcher'), path.join(env.LOCALAPPDATA || home, 'Programs/OpenZoo Launcher')] : [];
+  for (const root of roots) {
+    const resources = path.join(root, platform === 'darwin' ? 'Resources' : 'resources');
+    const executable = platform === 'darwin' ? path.join(root, 'MacOS/OpenZoo Launcher') : path.join(root, 'OpenZoo Launcher.exe');
+    if (exists(path.join(resources, 'openzoo-overlay.json')) && exists(executable)) return executable;
+  }
+  return null;
+}
+
 export async function startChatGptSpend({ profile, proxyPort, spawnImpl = spawn } = {}) {
+  const native = nativeSavingsLauncher();
+  if (native && proxyPort === 8402) {
+    const child = spawnImpl(native, ['--savings-only'], { detached: true, stdio: 'ignore' });
+    await new Promise((resolve, reject) => { child.once('spawn', resolve); child.once('error', reject); });
+    child.unref();
+    return;
+  }
   fs.mkdirSync(profile, { recursive: true });
   const fd = fs.openSync(path.join(profile, 'openzoo-savings.log'), 'a', 0o600);
   try {

package/lib/evm.js

@@ -9,7 +9,7 @@ const ERC20_ABI = [
 
 const evmClients = new Map();
 function clientFor(rpcUrl) {
-  if (!evmClients.has(rpcUrl)) evmClients.set(rpcUrl, createPublicClient({ transport: http(rpcUrl) }));
+  if (!evmClients.has(rpcUrl)) evmClients.set(rpcUrl, createPublicClient({ transport: http(rpcUrl, { timeout: 4000, retryCount: 0 }) }));
   return evmClients.get(rpcUrl);
 }
 

package/lib/funding-status.js

@@ -0,0 +1,17 @@
+/** Coalesce live reads, retain unknowns, and never cache an empty balance for a minute. */
+export function liveBalance(read, { ttlMs = 3000, now = Date.now } = {}) {
+  let value = null, at = 0, inflight;
+  return {
+    get value() { return value; },
+    get checkedAt() { return at || null; },
+    async refresh(force = false) {
+      if (inflight) return inflight;
+      if (!force && at && now() - at < ttlMs) return value;
+      inflight = Promise.resolve().then(read).then(next => {
+        if (typeof next !== 'number' || !Number.isFinite(next) || next < 0) throw new Error('Balance unavailable');
+        value = next; at = now(); return value;
+      }).catch(() => value).finally(() => { inflight = null; });
+      return inflight;
+    },
+  };
+}

package/lib/info.js

@@ -259,14 +259,12 @@ export { CREDIT_TIMEOUT_MS };
 
 export async function creditBalance() {
   const { withNamespace } = await import('./namespace.js');
-  try {
-    const r = await fetch(`${config.apiBase}/v1/credits`, {
-      headers: withNamespace({}),
-      signal: AbortSignal.timeout(CREDIT_TIMEOUT_MS),
-    });
-    const j = await r.json();
-    return Number(j.balanceUsd) || 0;
-  } catch {
-    return 0;
-  }
+  const r = await fetch(`${config.apiBase}/v1/credits`, {
+    headers: withNamespace({}), cache: 'no-store',
+    signal: AbortSignal.timeout(CREDIT_TIMEOUT_MS),
+  });
+  if (!r.ok) throw new Error('Credit balance is temporarily unavailable');
+  const j = await r.json();
+  if (typeof j.balanceUsd !== 'number' || !Number.isFinite(j.balanceUsd) || j.balanceUsd < 0) throw new Error('Credit balance is temporarily unavailable');
+  return j.balanceUsd;
 }

package/lib/pay.js

@@ -27,6 +27,10 @@ export class QuoteTooHighError extends Error {
   }
 }
 
+export class BalanceUnavailableError extends Error {
+  constructor() { super('We couldn’t check your balance right now. Please try again. You don’t need to add funds again.'); }
+}
+
 export class UnderfundedError extends Error {
   constructor(accept, usdcUi, address, { line } = {}) {
     const usd = Number(accept?.extra?.billedUsd);
@@ -149,14 +153,10 @@ export function chainName(network) {
 
 const memoKey = (a) => `${a?.network || ''}|${a?.asset || ''}`;
 
-/** lastGood first, known-underfunded last (never dropped — only deprioritised). */
-export function orderCandidatesByMemory(cands, now = Date.now()) {
-  const skip = (c) => (underfundedUntil.get(memoKey(c)) ?? 0) > now;
+/** Prefer a confirmed successful payer; recheck other balances on every request. */
+export function orderCandidatesByMemory(cands) {
   const good = (c) => lastGoodAsset && memoKey(c) === lastGoodAsset;
-  // Stable partition: proven payer, then untried, then recently-underfunded. The
-  // last group is KEPT so a wallet funded seconds ago is still reachable in the
-  // same call if nothing else works.
-  return [...cands].sort((a, b) => (good(b) - good(a)) || (skip(a) - skip(b)));
+  return [...cands].sort((a, b) => good(b) - good(a));
 }
 
 /** Test seam: forget everything the rail memory learned. */
@@ -259,7 +259,7 @@ export class PayClient {
     const rail = railOf(accept);
     if (rail === 'solana') {
       const need = BigInt(accept.maxAmountRequired);
-      const bal = await cachedTokenBalance(this.connection, this.keypair.publicKey, accept.asset, { force: true });
+      const bal = await cachedTokenBalance(this.connection, this.keypair.publicKey, accept.asset, { force: true }).catch(() => { throw new BalanceUnavailableError(); });
       // SHORT IS SHORT. The 402 quotes the raw native mint, so there is nothing
       // to convert and no pool to walk: the wallet either holds the asset or it
       // does not. This branch used to run resolvePool + poolState + a wrap
@@ -302,7 +302,7 @@ export class PayClient {
         });
       }
       if (owner) {
-        const bal = await evmTokenBalance({ rpcUrl, token: accept.asset, owner }).catch(() => null);
+        const bal = await evmTokenBalance({ rpcUrl, token: accept.asset, owner }).catch(() => { throw new BalanceUnavailableError(); });
         if (bal !== null && bal < BigInt(accept.maxAmountRequired)) {
           // Robinhood used to quote an ERC-4626 vault twin here and the shim
           // ran approve+deposit to mint it. The gateway now quotes canonical
@@ -377,6 +377,7 @@ export class PayClient {
     let accept = null;
     let payment = null;
     const fundErrs = [];
+    let balanceError = null;
     let tooHigh = null;
     for (const cand of candidates) {
       const billedUsd = Number(cand?.extra?.billedUsd ?? NaN);
@@ -388,13 +389,13 @@ export class PayClient {
         payment = await this.buildPaymentFor(cand, onStage, quote);
         if (fundErrs.length) railNote(`paying on ${railLabel(cand)}`);
         accept = cand;
-        lastGoodAsset = memoKey(cand);
         underfundedUntil.delete(memoKey(cand));
         if (railOf(cand) === 'solana') {
           try { debitCachedBalance(this.keypair.publicKey, cand.asset, BigInt(cand.maxAmountRequired)); } catch { /* advisory */ }
         }
         break;
       } catch (e) {
+        if (e instanceof BalanceUnavailableError) { balanceError = e; continue; }
         if (!(e instanceof UnderfundedError)) throw e;
         // Remember it so the next call does not re-pay the discovery cost.
         underfundedUntil.set(memoKey(cand), Date.now() + RAIL_MEMO_MS);
@@ -411,6 +412,7 @@ export class PayClient {
       }
     }
     if (!payment) {
+      if (balanceError) throw balanceError;
       if (!fundErrs.length && tooHigh) throw tooHigh;
       if (fundErrs.length === 1) throw fundErrs[0].err;
       throw new UnderfundedError(candidates[0], null, this.address, {
@@ -452,11 +454,11 @@ export class PayClient {
           });
           if (again.status !== 402) {
             accept = cand; payment = retry; response = again;
-            lastGoodAsset = memoKey(cand);
+            if (again.ok) lastGoodAsset = memoKey(cand);
             break;
           }
         } catch (e) {
-          if (!(e instanceof UnderfundedError)) throw e;
+          if (!(e instanceof UnderfundedError) && !(e instanceof BalanceUnavailableError)) throw e;
         }
       }
     }
@@ -513,6 +515,9 @@ export class PayClient {
         this._rebuilt = false;
       }
     }
+    if (response.ok) lastGoodAsset = memoKey(accept);
+    else if (lastGoodAsset === memoKey(accept)) lastGoodAsset = null;
+
     // NEVER PRESENT OUR OWN SIGNATURE AS THE TRANSACTION.
     //
     // This fell back to `{ signature: payment.ownerSignature }`, and on Solana

package/lib/payment-error.js

@@ -0,0 +1,15 @@
+import { randomUUID } from 'node:crypto';
+/** Report a failed turn through the client's response stream, not transport-error prose. */
+export function paymentError(res, req, init, status, message) {
+  let body = {};
+  try { body = JSON.parse(String(init?.body || '{}')); } catch {}
+  if (/\/responses(?:\?|$)/.test(req.url || '') && body.stream === true) {
+    const response = { id: `resp_${randomUUID()}`, object: 'response', created_at: Math.floor(Date.now()/1000), status: 'failed',
+      error: { code: 'server_error', message }, output: [], usage: null, model: body.model || '', incomplete_details: null };
+    res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache' });
+    res.end(`event: response.failed\ndata: ${JSON.stringify({ type: 'response.failed', sequence_number: 0, response })}\n\n`);
+    return;
+  }
+  res.writeHead(status, { 'content-type': 'application/json' });
+  res.end(JSON.stringify({ error: { message } }));
+}

package/lib/proxy.js

@@ -1,3 +1,5 @@
+import { liveBalance } from './funding-status.js';
+import { paymentError } from './payment-error.js';
 import { readFileSync, appendFileSync, mkdirSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -8,8 +10,8 @@ import {
   config, FUNDING_ASSETS, EVM_FUNDING_ASSETS, evmRpcFor, fundingLine, liveRails, railFundingHint, railFundingAddresses, unfundableRails, RAIL_FUNDING,
 } from './config.js';
 import { execSync } from 'node:child_process';
-import { PayClient, QuoteTooHighError, UnderfundedError } from './pay.js';
-import { withOnrampLink, settleFailCopy } from './stripeOnramp.js';
+import { PayClient, QuoteTooHighError, UnderfundedError, BalanceUnavailableError, resetBalanceCache, resetRailMemory } from './pay.js';
+import { withOnrampLink, settleFailCopy, whopFundBlurb } from './stripeOnramp.js';
 import { tokenBalance } from './x402.js';
 import { evmTokenBalance } from './evm.js';
 import { autoContext } from './autobind.js';
@@ -451,7 +453,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   let refreshBalances = async () => {};
   let refreshPending = false;
   const scheduleRefresh = (ms) => {
-    if (silent || refreshPending) return;
+    if (refreshPending) return;
     refreshPending = true;
     const t = setTimeout(async () => { refreshPending = false; await refreshBalances(); }, ms);
     t.unref?.();
@@ -471,11 +473,10 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // billed for ONLY those calls whose real cost we learned — the honest
   // numerator for markupX.
   let billedWithActual = 0;
-  // CREDIT, CACHED. Refreshed at most every 20s and served stale in between —
+  // CREDIT, CACHED. Refreshed every few seconds and served stale in between —
   // a status line must never add latency to the thing it is describing.
   let creditUsd = null;
   let creditAt = 0;
-  let creditInflight = null;
   let lastPrices = {};
   let pricesAt = 0;
   // WALLET BALANCE, CACHED LIKE CREDIT.
@@ -490,40 +491,38 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // behind it — the same contract refreshCredit() keeps.
   let walletUsd = null;
   let walletAt = 0;
-  let walletInflight = null;
+  const walletStatus = liveBalance(async () => {
+    const snap = await snapshotBalances(client);
+    if (!snap.length) throw new Error('Balances unavailable');
+    const previous = new Map((lastSnap || []).map(b => [`${b.chain}:${b.symbol}`, b]));
+    for (const b of snap) {
+      const old = previous.get(`${b.chain}:${b.symbol}`);
+      if (b.ui > (old?.ui ?? 0)) { resetBalanceCache(); resetRailMemory(); }
+      previous.set(`${b.chain}:${b.symbol}`, b);
+    }
+    lastSnap = [...previous.values()];
+    return priceHoldings(lastSnap, lastPrices).chainUsd;
+  });
+  const creditStatus = liveBalance(creditBalance);
   const refreshWallet = async (force = false) => {
-    if (!force && Date.now() - walletAt < 60000 && walletUsd != null) return walletUsd;
-    if (walletInflight) return walletInflight;
-    walletInflight = (async () => {
-      try {
-        const { affordableUsd } = await import('./info.js');
-        const v = await affordableUsd();
-        if (Number.isFinite(v)) { walletUsd = v; walletAt = Date.now(); }
-      } catch { /* keep last known */ }
-      walletInflight = null;
-      return walletUsd;
-    })();
-    return walletInflight;
+    walletUsd = await walletStatus.refresh(force);
+    walletAt = walletStatus.checkedAt;
+    return walletUsd;
   };
   const refreshCredit = async (force = false) => {
-    if (!force && Date.now() - creditAt < 20000 && creditUsd != null) return creditUsd;
-    if (creditInflight) return creditInflight;
-    creditInflight = (async () => {
-      try {
-        creditUsd = await creditBalance();
-        creditAt = Date.now();
-      } catch { /* keep last known */ }
-      creditInflight = null;
-      return creditUsd;
-    })();
-    return creditInflight;
+    creditUsd = await creditStatus.refresh(force);
+    creditAt = creditStatus.checkedAt;
+    return creditUsd;
   };
+  let pricesInflight = null;
   const refreshPrices = async () => {
-    if (Date.now() - pricesAt < 60000 && Object.keys(lastPrices).length) return lastPrices;
-    try {
-      lastPrices = await quotedPrices();
+    if (Date.now() - pricesAt < 60000) return lastPrices;
+    if (!pricesInflight) {
       pricesAt = Date.now();
-    } catch { /* keep last */ }
+      pricesInflight = quotedPrices().then(prices => { lastPrices = prices; })
+        .catch(() => {}).finally(() => { pricesInflight = null; });
+    }
+    await pricesInflight;
     return lastPrices;
   };
   const walletMoney = () => priceHoldings(lastSnap || [], lastPrices);
@@ -570,6 +569,13 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       return;
     }
 
+    if (req.method === 'GET' && (req.url || '').split('?')[0] === '/v1/funding') {
+      await Promise.all([refreshCredit(true), refreshWallet(true), refreshBalances()]);
+      res.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+      res.end(JSON.stringify({ creditUsd, walletUsd, creditCheckedAt: creditAt || null, walletCheckedAt: walletAt || null }));
+      return;
+    }
+
     if ((req.url || '').split('?')[0] === '/mcp') {
       try {
         const { handleMcpRequest } = await import('./mcphttp.js');
@@ -1068,21 +1074,24 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         // USDC on Base — so every 402 after a payment carries all three, not
         // only the ones the gateway managed to classify as insufficient funds.
         msg = await withOnrampLink(msg, { solana: client.address, evm: client.evmAddress, usd, code: copy.code, force: true });
-        log(/ties to your account/i.test(msg) ? 'onramp: whop + copy-paste solana' : `402: ${msg.slice(0, 140)}`);
-        jsonErr(res, paid ? copy.status : 402, msg);
+        log(/At checkout/i.test(msg) ? 'onramp: whop + copy-paste solana' : `402: ${msg.slice(0, 140)}`);
+        log(`payment diagnostic: ${copy.reason}`);
+        paymentError(res, req, init, paid ? copy.status : 402, msg);
         return;
       }
       await relay(res, response, meterStreamed);
     } catch (err) {
       if (err instanceof QuoteTooHighError) {
         log(err.message);
-        jsonErr(res, 402, err.message, { quote: err.quote });
+        paymentError(res, req, init, 400, 'This request exceeds your spending limit. Try a shorter request or change your limit.');
       } else if (err instanceof UnderfundedError) {
         const msg = await withOnrampLink(err.message, {
           solana: client.address, evm: client.evmAddress, usd: Number(err.accept?.extra?.billedUsd),
         });
         log(msg);
-        jsonErr(res, 402, msg);
+        paymentError(res, req, init, 402, `Your available balance does not cover this request yet.\n\n${whopFundBlurb(client.address, client.evmAddress)}`);
+      } else if (err instanceof BalanceUnavailableError) {
+        paymentError(res, req, init, 503, `${err.message}\n\n${whopFundBlurb(client.address, client.evmAddress)}`);
       } else {
         // "fetch failed" alone is undiagnosable — undici hides the real
         // network error in `cause`. Surface it or every transport hiccup looks
@@ -1092,7 +1101,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         const detail = raw;
         log(`proxy error: ${detail}`);
         if (process.env.OPENZOO_DEBUG) console.error(err.stack);
-        jsonErr(res, 502, `openzoo proxy error: ${detail}`);
+        paymentError(res, req, init, 502, 'OpenZoo couldn’t connect right now. Please try again.');
       }
     }
   });
@@ -1130,6 +1139,13 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     }
   }
 
+  // Funding checks run for desktop/background launches as well as terminal sessions.
+  refreshBalances = () => refreshWallet(true);
+  refreshWallet(); refreshCredit(); refreshPrices();
+  const fundingTimer = setInterval(() => { refreshCredit(); refreshWallet(); refreshPrices(); }, 3000);
+  fundingTimer.unref?.();
+  server.on('close', () => clearInterval(fundingTimer));
+
   // AUTO-PREPAY. Paying on-chain per call is where the latency lives: credit
   // is applied automatically server-side whenever a balance covers the quote,
   // so buying it once makes every later call skip verify+settle entirely.
@@ -1183,31 +1199,6 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     } catch { /* RPC hiccup: balance is advisory */ }
     refreshCredit();
     refreshPrices();
-    // LIVE REFRESH: poll on an interval (and shortly after each paid call),
-    // print ONLY on change, and call out arrivals explicitly.
-    refreshBalances = async () => {
-      try {
-        const snap = await snapshotBalances(client);
-        if (!snap.length) return;
-        const prev = new Map((lastSnap || []).map((b) => [`${b.chain}:${b.symbol}`, b.ui]));
-        const changed = snap.some((b) => Math.abs((prev.get(`${b.chain}:${b.symbol}`) ?? 0) - b.ui) > 1e-9)
-          || snap.length !== (lastSnap || []).length;
-        if (!changed) return;
-        if (lastSnap) {
-          for (const b of snap) {
-            const gain = b.ui - (prev.get(`${b.chain}:${b.symbol}`) ?? 0);
-            if (gain > 1e-9) console.log(`funding arrived: +${gain.toFixed(6)} ${b.symbol}${b.chain !== 'solana' ? ` (${b.chain})` : ''}`);
-          }
-        }
-        lastSnap = snap;
-        console.log(`balance: ${balanceLine(snap)}`);
-      } catch { /* advisory — never noisy on RPC trouble */ }
-    };
-    const pollSecs = Number(process.env.OPENZOO_BALANCE_POLL_SECS ?? 45);
-    if (pollSecs > 0) {
-      const timer = setInterval(refreshBalances, pollSecs * 1000);
-      timer.unref?.();
-    }
     // Which rails the zoo will actually settle right now, straight off a live
     // 402 — so nobody funds a lane the resource is not currently offering.
     try {

package/lib/stripeOnramp.js

@@ -97,15 +97,12 @@ export function whopFundBlurb(solana, evm) {
   const url = whopBuyUrl();
   const base = String(evm || '').trim();
   return [
-    `Hey — buy this: ${url}`,
-    '',
-    'Copy-paste THIS Solana address into "what is your Solana address?" so it ties to your account:',
-    addr,
-    // OR FUND THE WALLET DIRECTLY. Every failed payment ends here: card via
-    // Whop, or USDC to either address — those are the only three moves a
-    // stuck caller has, so they are the whole message.
-    '',
-    `Or send USDC directly — Solana: ${addr}${base ? `  ·  Base: ${base}` : ''}`,
+    'Funding options:',
+    `Card: ${url}`,
+    `At checkout, use this Solana wallet address to link your purchase: ${addr}`,
+    `Solana (USDC): ${addr}`,
+    ...(base ? [`Base (USDC): ${base}`] : []),
+    'Your balance refreshes automatically once the payment is confirmed.',
   ].join('\n');
 }
 
@@ -151,11 +148,10 @@ export function settleFailCopy(q402) {
   const reason = gatewayReason(q402);
   const code = q402?.advice?.code || q402?.error?.code || '';
   const fund = isFundInstruction(reason, { code, advice: q402?.advice });
-  const message = reason
-    ? `openzoo payment did not settle: ${reason}`
-    : 'openzoo payment did not settle';
-  const upstreamish = /upstream|facilitator|internal(?: server)? error|settle(?:ment)? (?:failed|error)/i.test(reason) && !fund;
-  return { message, status: upstreamish ? 502 : 402, fund, reason, code: String(code || '') };
+  const message = fund
+    ? 'Your available balance does not cover this request yet. If you just added funds, wait for confirmation and try again.'
+    : 'We couldn’t complete the payment for this request. Please try again. If you already added funds, you don’t need to add them again.';
+  return { message, status: fund ? 402 : 503, fund, reason, code: String(code || '') };
 }
 
 export async function withOnrampLink(text, dest) {
@@ -164,5 +160,5 @@ export async function withOnrampLink(text, dest) {
   const blurb = whopFundBlurb(dest?.solana, dest?.evm);
   if (!blurb) return body;
   if (/ties to your account/i.test(body) && body.includes(String(dest.solana))) return body;
-  return `${blurb}\n\n${body}`;
+  return `${body}\n\n${blurb}`;
 }

package/lib/x402.js

@@ -422,8 +422,9 @@ export async function tokenBalance(connection, owner, mintStr) {
     const ata = getAssociatedTokenAddressSync(new PublicKey(mintStr), owner, false, programId);
     const bal = await connection.getTokenAccountBalance(ata);
     return { raw: BigInt(bal.value.amount), ui: bal.value.uiAmount };
-  } catch {
-    return { raw: 0n, ui: 0 };
+  } catch (error) {
+    if (/could not find account|account.*(?:does not exist|not found)/i.test(error.message)) return { raw: 0n, ui: 0 };
+    throw error;
   }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openzoo",
-  "version": "0.51.7",
-  "description": "Local x402-paying proxy + MCP server for openzoo.fun \u2014 point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
+  "version": "0.51.8",
+  "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",
   "bin": {