@mesub/node 0.0.0-stage → 0.1.2

package/dist/testing.cjs

@@ -0,0 +1,1488 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+
+
+
+var _chunk4JSJOX35cjs = require('./chunk-4JSJOX35.cjs');
+
+// src/testing.ts
+var ACCESS_ATTEMPTS = 5;
+var NOTHING = {
+  subscription_id: null,
+  access: false,
+  status: "none",
+  paused: false,
+  end_reason: null,
+  late_reason: null,
+  stop_reason: null,
+  payment_status: "none",
+  blocked_since: null,
+  blocked_reason: null,
+  subscribed_since: null,
+  first_subscribed_at: null,
+  current_period_end: null,
+  cancelled_at: null,
+  access_until: null,
+  next_charge_at: null,
+  next_retry_at: null,
+  retry_deadline: null
+};
+var REVALIDATE_MIN_S = 10;
+var REVALIDATE_MAX_S = 300;
+var OUTAGE = {
+  status: 503,
+  code: "unavailable",
+  message: "Mesub is unavailable."
+};
+var FAKE_WEBHOOK_SECRET = "whsec_bWVzdWItZmFrZS13ZWJob29rLWtleS0x";
+var FAKE_WALLET = "11111111111111111111111111111111";
+var TEST_EVENT_ID = "evt_test";
+var EVENTS_WINDOW_MS = 30 * 24 * 3600 * 1e3;
+var EVENTS_LIMIT = 25;
+var EVENTS_LIMIT_MAX = 100;
+var EVENT_TYPES = [
+  "subscription.created",
+  "subscription.renewal_upcoming",
+  "subscription.renewed",
+  "subscription.payment_failed",
+  "subscription.stopped",
+  "subscription.cancelled",
+  "subscription.resumed",
+  "subscription.ended",
+  "subscription.expired",
+  "subscription.access_granted",
+  "subscription.access_revoked",
+  "subscription.paused",
+  "subscription.unpaused"
+];
+var RESOURCE_ID = /^[A-Za-z0-9_-]{1,64}$/;
+var REQUEST_ID_HEADER = "Mesub-Request-Id";
+var USDC = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var PERIOD_MS = 30 * 24 * 3600 * 1e3;
+var DAY_MS = 24 * 3600 * 1e3;
+var TEST_SUBSCRIPTION = {
+  id: "sub_test",
+  status: "active",
+  paused: false,
+  end_reason: null,
+  late_reason: null,
+  stop_reason: null,
+  access: true,
+  payment_status: "paid",
+  blocked_since: null,
+  blocked_reason: null,
+  plan: "pro",
+  wallet: FAKE_WALLET,
+  email: "subscriber@example.com",
+  external_id: "user_123",
+  current_period_start: "2026-01-01T00:00:00.000Z",
+  current_period_end: "2026-01-31T00:00:00.000Z",
+  next_charge_at: "2026-01-31T00:00:00.000Z",
+  next_retry_at: null,
+  retry_deadline: null,
+  next_retry_number: null,
+  retries_allowed: null,
+  access_until: "2026-01-31T00:00:00.000Z",
+  closable: false,
+  closable_from: null,
+  created_at: "2026-01-01T00:00:00.000Z",
+  confirmed_at: "2026-01-01T00:00:00.000Z"
+};
+var FREE_RETRY_WAIT_MS = 10 * 60 * 1e3;
+var FREE_HAND_RETRIES = 3;
+var PAID_RETRY_WAIT_MS = 20 * 60 * 1e3;
+var CLOCK_MARGIN_MS = 2 * 60 * 1e3;
+var TRANSACTION_LIFE_MS = 3e4;
+var REASONS = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  409: "Conflict",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  503: "Service Unavailable"
+};
+var FakeMesub = (_class = class {
+  
+  
+  
+  /** Every call received, oldest first. */
+  __init() {this.requests = []}
+  /** Hand it to `new Mesub({ fetch })`, or use `client()`. */
+  
+  #plans;
+  #planList;
+  #answers = /* @__PURE__ */ new Map();
+  /** The ends `grantLastPeriod` and `endPlan` gave a plan, by slug: they win over `plans`. */
+  #ends = /* @__PURE__ */ new Map();
+  #subscriptions = [];
+  /** The subscriptions a cancel, resume or close transaction was built for, by id. */
+  #built = /* @__PURE__ */ new Map();
+  /** The rows ended with their plan whose close landed: nothing of them is left on chain. */
+  #gone = /* @__PURE__ */ new Set();
+  /** The attempts `setAttempts` gave each subscription, newest first, by id. */
+  #attempts = /* @__PURE__ */ new Map();
+  #attemptsRoute;
+  #revalidateAfter;
+  #attemptIds = 0;
+  #eventIds = 0;
+  /** The last `sequence` given to each subscription's events, by id. */
+  #sequences = /* @__PURE__ */ new Map();
+  #accessEvents;
+  #requestIds = 0;
+  /** Every event raised or added, as `/v1/events` serves it. */
+  #events = [];
+  #eventsSince;
+  #failure = null;
+  #ids = 0;
+  /** The made-up subscriptions of `webhook` and `addEvent`, apart: they take no `sub_fake_` id. */
+  #madeUpIds = 0;
+  #deliveryIds = 0;
+  #tier;
+  /** The hand retries fired on each late subscription, and when the last one was, by id. */
+  #handRetries = /* @__PURE__ */ new Map();
+  constructor(options = {}) {;_class.prototype.__init.call(this);
+    this.baseUrl = (_nullishCoalesce(options.baseUrl, () => ( "https://api.mesub.test"))).replace(/\/+$/, "");
+    this.apiKey = _nullishCoalesce(options.apiKey, () => ( "SUB_test_fake"));
+    const plans = _optionalChain([options, 'access', _ => _.plans, 'optionalAccess', _2 => _2.map, 'call', _3 => _3(
+      (plan) => typeof plan === "string" ? fakePlan(plan) : fakePlan(plan.slug, plan)
+    )]);
+    this.#plans = plans ? new Set(plans.map((plan) => plan.slug)) : null;
+    this.#planList = (_nullishCoalesce(plans, () => ( []))).sort((a, b) => a.slug.localeCompare(b.slug));
+    this.webhookSecret = _nullishCoalesce(options.webhookSecret, () => ( FAKE_WEBHOOK_SECRET));
+    this.#attemptsRoute = _nullishCoalesce(options.attemptsRoute, () => ( true));
+    this.#revalidateAfter = options.revalidateAfter;
+    this.#accessEvents = _nullishCoalesce(options.accessEvents, () => ( false));
+    this.#tier = _nullishCoalesce(options.tier, () => ( "dev"));
+    this.#eventsSince = new Date(
+      _nullishCoalesce(options.eventsSince, () => ( Date.now() - EVENTS_WINDOW_MS))
+    ).toISOString();
+    this.fetch = (input, init) => this.#handle(input, init);
+  }
+  /**
+   * A client wired to this fake: its key, base URL and fetch, and no retry
+   * unless asked, so a failure shows at once. Any other option is passed on.
+   */
+  client(options = {}) {
+    return new (0, _chunk4JSJOX35cjs.Mesub)({
+      maxRetries: 0,
+      ...options,
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      fetch: this.fetch,
+      webhookSecret: this.webhookSecret
+    });
+  }
+  /**
+   * That customer has access to that plan: active and paid, unless `fields`
+   * say otherwise. The customer is named as `access` names them, and only
+   * that way answers: a wallet granted is not found by its external id.
+   */
+  grant(customer, plan, fields = {}) {
+    return this.setAccess(customer, plan, {
+      access: true,
+      status: "active",
+      payment_status: "paid",
+      ...fields
+    });
+  }
+  /** That customer has no access to that plan: `status` says why, `none` by default. */
+  deny(customer, plan, fields = {}) {
+    return this.setAccess(customer, plan, { ...fields, access: false });
+  }
+  /**
+   * That customer is in the last period of a plan that ends at `endsAt`:
+   * active and paid, access until the end and no charge ahead, unless
+   * `fields` say otherwise. The plan gets that `ends_at`, and from then on
+   * the fake refuses everyone on it, as Mesub does, whatever `status` reads.
+   */
+  grantLastPeriod(customer, plan, endsAt, fields = {}) {
+    const end = new Date(endsAt).toISOString();
+    this.#ends.set(plan, end);
+    return this.grant(customer, plan, { access_until: end, ...fields });
+  }
+  /**
+   * That plan reached its end, at `at` or now: it takes nobody new, and
+   * what the fake holds on it is ended as Mesub ends it, `plan_ended` for a
+   * running or late one, `cancelled` for one that had cancelled. Before
+   * this is called, a plan past its `ends_at` already refuses everyone,
+   * with `status` unchanged: the minutes Mesub takes to end the rows.
+   */
+  endPlan(plan, at = /* @__PURE__ */ new Date()) {
+    this.#ends.set(plan, new Date(at).toISOString());
+    for (const [key, answer] of this.#answers) {
+      if (answer.plan === plan) this.#answers.set(key, { ...answer, ...endedBy(answer) });
+    }
+    for (const subscription of this.#subscriptions) {
+      if (subscription.plan !== plan) continue;
+      const ended = endedBy(subscription);
+      Object.assign(subscription, ended, "status" in ended && NO_RETRY);
+    }
+  }
+  /**
+   * Parks that subscription's seat, as Mesub does when a project holds more
+   * subscribers than its tier allows: `paused`, no next charge, access and
+   * status unchanged (the fake moves no clock, so the paid period never
+   * runs out). With `accessEvents`, raises `subscription.paused`
+   * (Mesub-io/backend#509), sent behind the same flag. Throws for an id the
+   * fake does not hold.
+   */
+  park(id) {
+    return this.#seat(id, true);
+  }
+  /**
+   * Brings a parked seat back: not `paused`, charged again at the end of
+   * its period. With `accessEvents`, raises `subscription.unpaused`.
+   */
+  unpark(id) {
+    return this.#seat(id, false);
+  }
+  #seat(id, paused) {
+    const subscription = this.#subscriptions.find((each) => each.id === id);
+    if (!subscription) throw new Error(`The fake holds no subscription ${id}.`);
+    if (subscription.paused === paused) return this.#view(subscription);
+    const before = this.#view(subscription).access;
+    const next_charge_at = paused ? null : subscription.current_period_end;
+    Object.assign(subscription, { paused, next_charge_at });
+    this.#answer(subscription, { paused, next_charge_at });
+    if (this.#accessEvents) {
+      this.#raise(
+        paused ? "subscription.paused" : "subscription.unpaused",
+        subscription,
+        before
+      );
+    }
+    return this.#view(subscription);
+  }
+  /**
+   * What `/v1/access` answers that customer on that plan, on top of the
+   * answer for a customer with nothing. `wallet` defaults to the wallet
+   * asked about, and to null for an external id or an email.
+   */
+  setAccess(customer, plan, fields) {
+    const asked = _chunk4JSJOX35cjs.customerOf.call(void 0, customer);
+    const answer = { ...nothing(asked, plan), ...fields, plan };
+    this.#answers.set(keyOf(asked, plan), answer);
+    return this.#fresh(answer);
+  }
+  /**
+   * A subscription `retrieve` and `list` answer, active by default, dated
+   * as Mesub dates a row of that `status` unless `fields` say otherwise:
+   * active, paid for a period ending in 30 days and charged then; unpaid,
+   * that period over, late, with access and a retry tomorrow, or on `free`
+   * no access and hand retries until `retry_deadline`; cancelled, access to
+   * the end of the period; stopped (`out_of_retries`) or ended (`closed`),
+   * no access. Its access answer is left as it is: set it with `grant`.
+   * Throws for a wallet Mesub would refuse. Its plan may be one `plans`
+   * leaves out: Mesub serves the rows of a plan it no longer has.
+   */
+  addSubscription(fields) {
+    if (!BASE58_ADDRESS.test(fields.wallet)) {
+      throw new Error(`${fields.wallet} is not a wallet: a base58 Solana address.`);
+    }
+    const subscription = this.#subscription(fields);
+    this.#subscriptions.push(subscription);
+    return subscription;
+  }
+  /**
+   * The pull attempts of that subscription, every one it ever had: what
+   * `subscriptions.attempts` answers for it, with their `paid` total, and
+   * the five newest through `/v1/access` with `attempts`, whose answer
+   * becomes about that subscription. Each is a paid one of 9.99 USDC now,
+   * priced 9.99 dollars, not a retry, unless told otherwise; one given
+   * another `amount` and no `amount_usd` is not priced. Newest first.
+   * Throws for an id the fake does not hold.
+   */
+  setAttempts(id, attempts) {
+    const subscription = this.#subscriptions.find((each) => each.id === id);
+    if (!subscription) throw new Error(`The fake holds no subscription ${id}.`);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const filled = attempts.map((attempt) => ({
+      id: `att_fake_${this.#attemptIds += 1}`,
+      attempted_at: now,
+      outcome: "paid",
+      reason: null,
+      amount: "9990000",
+      // The default amount's worth only: no price is guessed for another.
+      amount_usd: attempt.amount === void 0 ? "9.99" : null,
+      // A mint that withholds nothing: the receiver got it all.
+      amount_received: _nullishCoalesce(attempt.amount, () => ( "9990000")),
+      signature: "fake_signature",
+      retry: false,
+      retry_number: null,
+      retries_allowed: null,
+      period_start: null,
+      ...attempt
+    })).sort((a, b) => Date.parse(b.attempted_at) - Date.parse(a.attempted_at));
+    this.#attempts.set(id, filled);
+    this.#answer(subscription, {
+      subscribed_since: subscription.confirmed_at,
+      attempts: filled.slice(0, ACCESS_ATTEMPTS).map(({ outcome, reason, amount, attempted_at, signature }) => ({
+        outcome,
+        reason,
+        amount,
+        attempted_at,
+        signature
+      }))
+    });
+    return filled;
+  }
+  /**
+   * A webhook of that type, as Mesub posts it to an endpoint: the event's
+   * body (Mesub-io/backend#482), on a made-up subscription and detail
+   * unless `fields` say otherwise, the subscription the fake holds under
+   * `fields.subscription.id` when it holds one, signed with
+   * `webhookSecret`. The `test` event is Mesub's test delivery: `test:
+   * true`, `evt_test`, on its sample subscription (`sub_test`,
+   * `user_123`). Post it to your own handler, or hand it to
+   * `webhooks.verify` of a `client()`. Nothing is added to the fake.
+   */
+  async webhook(type, fields = {}) {
+    const now = /* @__PURE__ */ new Date();
+    const test = type === "test";
+    const data = test ? { ...TEST_SUBSCRIPTION, ...fields.subscription } : withClosing(this.#madeUp(type, fields.subscription));
+    const sequence = fields.sequence === void 0 ? test ? 1 : this.#nextSequence(data.id) : fields.sequence;
+    const payload = {
+      id: _nullishCoalesce(fields.id, () => ( (test ? TEST_EVENT_ID : this.#nextEventId()))),
+      object: "event",
+      type,
+      created_at: _nullishCoalesce(fields.created_at, () => ( now.toISOString())),
+      network: "mainnet-beta",
+      api_version: _chunk4JSJOX35cjs.API_VERSION,
+      ...sequence !== null && { sequence },
+      data,
+      detail: _nullishCoalesce(fields.detail, () => ( detailOf(type, now, data))),
+      ...test && { test: true }
+    };
+    return signWebhook(payload, {
+      secret: this.webhookSecret,
+      id: _nullishCoalesce(fields.delivery_id, () => ( `msg_fake_${this.#deliveryIds += 1}`)),
+      ...fields.timestamp !== void 0 && { timestamp: fields.timestamp }
+    });
+  }
+  /**
+   * The subscription an event carries: the one the fake holds under
+   * `fields.id` when it holds one, else a made-up one, active and paid on
+   * `pro` unless the type says otherwise; `fields` on top.
+   */
+  #madeUp(type, fields = {}) {
+    const held = this.#subscriptions.find((each) => each.id === fields.id);
+    const base = held ? this.#view(held) : {
+      id: _nullishCoalesce(fields.id, () => ( `sub_fake_event_${this.#madeUpIds += 1}`)),
+      wallet: FAKE_WALLET,
+      plan: "pro",
+      ...subscriptionOf(type)
+    };
+    return this.#subscription({ ...base, ...fields });
+  }
+  /**
+   * An event `/v1/events` serves from now on, as Mesub would have raised
+   * it: a made-up subscription and detail unless `fields` say otherwise,
+   * the subscription the fake holds under `fields.subscription.id` when it
+   * holds one. Nothing else changes: what it says happened is not done.
+   */
+  addEvent(type, fields = {}) {
+    const now = /* @__PURE__ */ new Date();
+    const data = withClosing(this.#madeUp(type, fields.subscription));
+    const sequence = fields.sequence === void 0 ? this.#nextSequence(data.id) : fields.sequence;
+    const event = {
+      id: _nullishCoalesce(fields.id, () => ( this.#nextEventId())),
+      object: "event",
+      type,
+      created_at: _nullishCoalesce(fields.created_at, () => ( now.toISOString())),
+      network: "mainnet-beta",
+      api_version: _chunk4JSJOX35cjs.API_VERSION,
+      ...sequence !== null && { sequence },
+      data,
+      detail: _nullishCoalesce(fields.detail, () => ( detailOf(type, now, data)))
+    };
+    this.#events.push(event);
+    return structuredClone(event);
+  }
+  /**
+   * Every call answers that error from now on, `'outage'` a 503, until
+   * `fail(null)`.
+   */
+  fail(failure) {
+    this.#failure = failure === "outage" ? OUTAGE : failure;
+  }
+  /**
+   * Forgets every answer, subscription, failure and request, and starts
+   * every id over: the same test makes the same ids, whatever ran before.
+   */
+  reset() {
+    this.#answers.clear();
+    this.#ends.clear();
+    this.#subscriptions = [];
+    this.#built.clear();
+    this.#gone.clear();
+    this.#attempts.clear();
+    this.#events = [];
+    this.#sequences.clear();
+    this.#handRetries.clear();
+    this.#failure = null;
+    this.requests.length = 0;
+    this.#ids = 0;
+    this.#madeUpIds = 0;
+    this.#eventIds = 0;
+    this.#attemptIds = 0;
+    this.#requestIds = 0;
+    this.#deliveryIds = 0;
+  }
+  /** A subscription with every field, dated as Mesub dates one of its `status`. */
+  #subscription(fields) {
+    const now = Date.now();
+    const iso = (ms) => new Date(ms).toISOString();
+    return {
+      id: _nullishCoalesce(fields.id, () => ( this.#nextId())),
+      status: "active",
+      paused: false,
+      end_reason: null,
+      late_reason: null,
+      stop_reason: null,
+      blocked_since: null,
+      blocked_reason: null,
+      email: null,
+      external_id: null,
+      next_retry_at: null,
+      retry_deadline: null,
+      next_retry_number: null,
+      retries_allowed: null,
+      closable: false,
+      closable_from: null,
+      created_at: iso(now),
+      confirmed_at: iso(now),
+      ...datesOf(_nullishCoalesce(fields.status, () => ( "active")), this.#tier, now),
+      ...fields
+    };
+  }
+  /**
+   * An answer as `/v1/access` serves it now: bounded by its plan's end, and
+   * fresh for as long as Mesub keeps it, unless a test said otherwise.
+   */
+  #fresh(answer) {
+    const end = this.#endOf(answer.plan);
+    const served = bounded(answer, end);
+    const closes = closingOf(served);
+    const closed = {
+      ...served,
+      closable: _nullishCoalesce(served.closable, () => ( closes.closable)),
+      closable_from: served.closable_from === void 0 ? closes.closable_from : served.closable_from
+    };
+    return {
+      ...closed,
+      revalidate_after: _nullishCoalesce(_nullishCoalesce(served.revalidate_after, () => ( this.#revalidateAfter)), () => ( revalidateAfter(closed, end)))
+    };
+  }
+  /**
+   * A subscription as Mesub serves it now: bounded by its plan's end, and
+   * `closable` as the fake's close would take it.
+   */
+  #view(subscription) {
+    const served = bounded(subscription, this.#endOf(subscription.plan));
+    return { ...served, ...closingOf(served, this.#gone.has(subscription.id)) };
+  }
+  /**
+   * Records the event Mesub raises for a change to that subscription, as
+   * it stands now, then, with `accessEvents`, the access event of the same
+   * change when access flipped from `before`: the same `data`, one
+   * `sequence` later.
+   */
+  #raise(type, subscription, before, detail = {}) {
+    const created_at = (/* @__PURE__ */ new Date()).toISOString();
+    const data = this.#view(subscription);
+    const push = (each, eachDetail) => this.#events.push({
+      id: this.#nextEventId(),
+      object: "event",
+      type: each,
+      created_at,
+      network: "mainnet-beta",
+      api_version: _chunk4JSJOX35cjs.API_VERSION,
+      sequence: this.#nextSequence(subscription.id),
+      data: structuredClone(data),
+      detail: eachDetail
+    });
+    push(type, detail);
+    if (this.#accessEvents && data.access !== before) {
+      const flip = data.access ? "subscription.access_granted" : "subscription.access_revoked";
+      push(flip, accessDetailOf(data, created_at));
+    }
+  }
+  /** The next `sequence` of that subscription's events: 1, 2, 3... */
+  #nextSequence(id) {
+    const next = (_nullishCoalesce(this.#sequences.get(id), () => ( 0))) + 1;
+    this.#sequences.set(id, next);
+    return next;
+  }
+  /** A plan's end: the one a test gave it, else its `ends_at` in `plans`. */
+  #endOf(slug) {
+    if (slug === null) return null;
+    return _nullishCoalesce(_nullishCoalesce(this.#ends.get(slug), () => ( _optionalChain([this, 'access', _4 => _4.#planList, 'access', _5 => _5.find, 'call', _6 => _6((each) => each.slug === slug), 'optionalAccess', _7 => _7.ends_at]))), () => ( null));
+  }
+  /** Whether that plan is past its end, where it takes nobody new. */
+  #over(slug) {
+    const end = this.#endOf(slug);
+    return end !== null && Date.parse(end) <= Date.now();
+  }
+  /** A plan as served: with its end, and taking nobody new once past it. */
+  #served(plan) {
+    const ends_at = this.#endOf(plan.slug);
+    return { ...plan, ends_at, available: plan.available && !this.#over(plan.slug) };
+  }
+  #nextId() {
+    this.#ids += 1;
+    return `sub_fake_${this.#ids}`;
+  }
+  #nextEventId() {
+    this.#eventIds += 1;
+    return `evt_fake_${this.#eventIds}`;
+  }
+  async #handle(input, init = {}) {
+    const url = new URL(input instanceof Request ? input.url : String(input));
+    const base = new URL(this.baseUrl);
+    const prefix = base.pathname.replace(/\/+$/, "");
+    if (url.origin !== base.origin || !url.pathname.startsWith(`${prefix}/`)) {
+      return new Response("Not Found", { status: 404 });
+    }
+    this.#requestIds += 1;
+    const id = `req_fake${String(this.#requestIds).padStart(20, "0")}`;
+    return stamped(await this.#route(url, url.pathname.slice(prefix.length), init), id);
+  }
+  async #route(url, path, init) {
+    const method = (_nullishCoalesce(init.method, () => ( "GET"))).toUpperCase();
+    const headers = new Headers(init.headers);
+    const query = Object.fromEntries(url.searchParams);
+    const body = typeof init.body === "string" ? JSON.parse(init.body) : void 0;
+    this.requests.push({ method, path, query, headers, body });
+    const [scheme, key] = (_nullishCoalesce(headers.get("authorization"), () => ( ""))).split(" ");
+    if (_optionalChain([scheme, 'optionalAccess', _8 => _8.toLowerCase, 'call', _9 => _9()]) !== "bearer" || !key) {
+      return error(401, "missing_api_key", "Send your API key as a bearer token.");
+    }
+    if (key !== this.apiKey) {
+      return error(401, "invalid_api_key", "That API key is not valid.");
+    }
+    const version = headers.get(_chunk4JSJOX35cjs.API_VERSION_HEADER);
+    if (version !== null && version !== _chunk4JSJOX35cjs.API_VERSION) {
+      return error(
+        400,
+        "unsupported_version",
+        `${_chunk4JSJOX35cjs.API_VERSION_HEADER} must be one of the versions this API serves: ${_chunk4JSJOX35cjs.API_VERSION}.`
+      );
+    }
+    if (this.#failure) {
+      const { status, code, message, retryable } = this.#failure;
+      const retryAfter = _nullishCoalesce(this.#failure.retryAfter, () => ( waitOf(method, path, status, code, this.#tier)));
+      return error(status, code, _nullishCoalesce(message, () => ( `Mesub answered ${status}.`)), {
+        ...retryable !== void 0 && { retryable },
+        ...retryAfter !== void 0 && { retryAfter }
+      });
+    }
+    if (method === "GET" && path === "/v1/plans") {
+      return Response.json({ plans: this.#planList.map((plan) => this.#served(plan)) });
+    }
+    const slug = _optionalChain([/^\/v1\/plans\/([^/]+)$/, 'access', _10 => _10.exec, 'call', _11 => _11(path), 'optionalAccess', _12 => _12[1]]);
+    if (method === "GET" && slug !== void 0) {
+      const plan = _nullishCoalesce(this.#planList.find((each) => each.slug === slug), () => ( // No list given: every slug exists, as for access.
+      (this.#plans === null ? fakePlan(slug) : void 0)));
+      return plan ? Response.json(this.#served(plan)) : error(404, "plan_not_found", `No plan under slug ${slug}`);
+    }
+    if (method === "GET" && path === "/v1/access") return this.#access(query);
+    if (method === "GET" && path === "/v1/events") return this.#eventList(query);
+    const eventId = _optionalChain([/^\/v1\/events\/([^/]+)$/, 'access', _13 => _13.exec, 'call', _14 => _14(path), 'optionalAccess', _15 => _15[1]]);
+    if (method === "GET" && eventId !== void 0) {
+      const event = this.#servedEvents().find(
+        (each) => each.id === decodeURIComponent(eventId)
+      );
+      return event ? Response.json(event) : error(
+        404,
+        "event_not_found",
+        "No event of yours under that id in the last 30 days."
+      );
+    }
+    if (method === "GET" && path === "/v1/subscriptions") return this.#list(query);
+    if (method === "POST" && path === "/v1/subscriptions") return this.#create(body);
+    const [, id, step, confirm] = _nullishCoalesce(/^\/v1\/subscriptions\/([^/]+)(?:\/(submit|transaction|cancel|resume|close|attempts|retry)(\/confirm)?)?$/.exec(
+      path
+    ), () => ( []));
+    if (step === "attempts" && (confirm || !this.#attemptsRoute)) {
+      return error(404, "not_found", `Cannot ${method} ${path}`);
+    }
+    if (method === "POST" && step === "submit" && !confirm) {
+      const invalid = invalidSubmit(body);
+      if (invalid) return invalid;
+    }
+    if (id !== void 0) {
+      const subscription = this.#subscriptions.find((s) => s.id === decodeURIComponent(id));
+      if (!subscription) {
+        return error(404, "subscription_not_found", "No subscription under that id.");
+      }
+      if (method === "GET" && !step) return Response.json(this.#view(subscription));
+      if (step === "attempts") {
+        return method === "GET" ? this.#attemptsOf(subscription, query) : error(404, "not_found", `Cannot ${method} ${path}`);
+      }
+      if (method === "POST" && step === "submit" && !confirm) {
+        return this.#submit(subscription);
+      }
+      if (step === "transaction") {
+        return method === "POST" && !confirm ? this.#transaction(subscription) : error(404, "not_found", `Cannot ${method} ${path}`);
+      }
+      if (step === "retry") {
+        return method === "POST" && !confirm ? this.#retry(subscription) : error(404, "not_found", `Cannot ${method} ${path}`);
+      }
+      if (method === "POST" && step && step !== "submit") {
+        return confirm ? this.#confirm(step, subscription, body) : this.#build(step, subscription);
+      }
+    }
+    return error(404, "not_found", `Cannot ${method} ${path}`);
+  }
+  #access(query) {
+    const invalid = invalidContact(query);
+    if (invalid) return invalid;
+    const asked = askedIn(query);
+    if (!asked)
+      return error(400, "invalid_request", "Name one of wallet, external_id or email.");
+    const { plan } = query;
+    const attempts = query["attempts"] === "true";
+    if (plan === void 0) {
+      const plans = [...this.#answers.entries()].filter(([key]) => key.startsWith(keyOf(asked, ""))).map(([, answer2]) => withAttempts(this.#fresh(answer2), attempts));
+      const granted = plans.filter((answer2) => answer2.access);
+      return Response.json({
+        plans,
+        revalidate_after: granted.length ? Math.min(...granted.map((answer2) => answer2.revalidate_after)) : _nullishCoalesce(this.#revalidateAfter, () => ( REVALIDATE_MIN_S))
+      });
+    }
+    if (this.#plans && !this.#plans.has(plan)) {
+      return error(404, "plan_not_found", `No plan under slug ${plan}`);
+    }
+    const answer = _nullishCoalesce(this.#answers.get(keyOf(asked, plan)), () => ( nothing(asked, plan)));
+    return Response.json(withAttempts(this.#fresh(answer), attempts));
+  }
+  #list(query) {
+    const invalid = invalidContact(query);
+    if (invalid) return invalid;
+    const asked = askedIn(query);
+    if (!asked)
+      return error(400, "invalid_request", "Name one of wallet, external_id or email.");
+    const limit = query["limit"] === void 0 ? 20 : limitOf(query["limit"]);
+    if (limit === null) return error(400, "invalid_request", [LIMIT_MESSAGE]);
+    const all = [...this.#subscriptions].reverse();
+    const after = query["starting_after"];
+    const from = after === void 0 ? 0 : all.findIndex((s) => s.id === after) + 1;
+    if (after !== void 0 && from === 0) {
+      return error(400, "invalid_request", "starting_after is not a subscription of yours.");
+    }
+    const data = all.slice(from).filter((s) => s.status !== "superseded").filter((s) => s[asked.kind] === asked.value).filter((s) => query["plan"] === void 0 || s.plan === query["plan"]);
+    const page = {
+      data: data.slice(0, limit).map((s) => this.#view(s)),
+      has_more: data.length > limit
+    };
+    return Response.json(page);
+  }
+  /** The events Mesub serves now: within the window and from `available_since`, newest first. */
+  #servedEvents() {
+    const floor = Math.max(Date.now() - EVENTS_WINDOW_MS, Date.parse(this.#eventsSince));
+    return this.#events.filter((event) => Date.parse(event.created_at) >= floor).sort(
+      (a, b) => Date.parse(b.created_at) - Date.parse(a.created_at) || // Within a millisecond, by `sequence`, highest first, as Mesub.
+      (_nullishCoalesce(b.sequence, () => ( 0))) - (_nullishCoalesce(a.sequence, () => ( 0))) || (a.id < b.id ? 1 : a.id > b.id ? -1 : 0)
+    );
+  }
+  #eventList(query) {
+    const { type, subscription, starting_after: after } = query;
+    const limit = Number(_nullishCoalesce(query["limit"], () => ( EVENTS_LIMIT)));
+    const reasons = [
+      !Number.isInteger(limit) || limit < 1 || limit > EVENTS_LIMIT_MAX ? `limit must be a whole number from 1 to ${EVENTS_LIMIT_MAX}` : null,
+      type !== void 0 && !EVENT_TYPES.includes(type) ? `type is one of ${EVENT_TYPES.join(", ")}` : null,
+      subscription !== void 0 && !RESOURCE_ID.test(subscription) ? "subscription must be a subscription id" : null,
+      after !== void 0 && !RESOURCE_ID.test(after) ? "starting_after must be an event id" : null
+    ].filter((reason) => reason !== null);
+    if (reasons.length) return error(400, "invalid_request", reasons);
+    const all = this.#servedEvents();
+    const from = after === void 0 ? 0 : all.findIndex((each) => each.id === after) + 1;
+    if (after !== void 0 && from === 0) {
+      return error(400, "invalid_request", "starting_after is not an event of yours.");
+    }
+    const data = all.slice(from).filter((each) => type === void 0 || each.type === type).filter((each) => subscription === void 0 || each.data.id === subscription);
+    const page = {
+      data: data.slice(0, limit),
+      has_more: data.length > limit,
+      available_since: this.#eventsSince
+    };
+    return Response.json(page);
+  }
+  #attemptsOf(subscription, query) {
+    const all = _nullishCoalesce(this.#attempts.get(subscription.id), () => ( []));
+    const limit = Number(_nullishCoalesce(query["limit"], () => ( 20)));
+    const after = query["starting_after"];
+    const from = after === void 0 ? 0 : all.findIndex((each) => each.id === after) + 1;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+      return error(400, "invalid_request", "limit must be a whole number from 1 to 100");
+    }
+    if (after !== void 0 && from === 0) {
+      return error(
+        400,
+        "invalid_request",
+        "starting_after is not an attempt of this subscription."
+      );
+    }
+    const paid = all.filter((each) => each.outcome === "paid");
+    const page = {
+      data: all.slice(from, from + limit),
+      has_more: all.length > from + limit,
+      // Over every attempt, not the page; an amount that is no whole number counts for 0.
+      paid: {
+        count: paid.length,
+        amount: paid.reduce(
+          (sum, each) => sum + (/^\d+$/.test(each.amount) ? BigInt(each.amount) : 0n),
+          0n
+        ).toString()
+      }
+    };
+    return Response.json(page);
+  }
+  #create(body) {
+    const { plan, wallet, email, external_id } = _nullishCoalesce(body, () => ( {}));
+    if (typeof plan !== "string" || typeof wallet !== "string") {
+      return error(400, "invalid_request", "plan and wallet are required.");
+    }
+    const invalid = invalidContact({ wallet, email });
+    if (invalid) return invalid;
+    if (this.#plans && !this.#plans.has(plan)) {
+      return error(404, "plan_not_found", `No plan under slug ${plan}`);
+    }
+    if (this.#over(plan)) return error(409, "plan_ended", "This plan has ended.");
+    const contact = {
+      email: typeof email === "string" ? email.trim().toLowerCase() : null,
+      external_id: typeof external_id === "string" ? external_id.trim() : null
+    };
+    const held = this.#subscriptions.filter((s) => s.plan === plan && s.wallet === wallet);
+    const refusal = liveRefusal(held);
+    if (refusal) return refusal;
+    const waiting = held.find(
+      (s) => s.status === "pending" && holderOf(s) === holderOf(contact)
+    );
+    if (waiting && contact.email !== null) waiting.email = contact.email;
+    const subscription = _nullishCoalesce(waiting, () => ( this.addSubscription({
+      plan,
+      wallet,
+      ...contact,
+      status: "pending",
+      access: false,
+      payment_status: "none",
+      current_period_start: null,
+      confirmed_at: null
+    })));
+    return Response.json(handedOut(subscription), { status: 201 });
+  }
+  /**
+   * A fresh transaction for a subscription still pending, with the same
+   * terms message as `create` gave it: a signature held stays good. Refused
+   * as Mesub refuses it otherwise.
+   */
+  #transaction(subscription) {
+    if (subscription.status !== "pending") {
+      return error(409, "not_awaiting_signature", "That subscription awaits no signature.");
+    }
+    if (this.#over(subscription.plan)) return error(409, "plan_ended", "This plan has ended.");
+    const refusal = liveRefusal(
+      this.#subscriptions.filter(
+        (s) => s.plan === subscription.plan && s.wallet === subscription.wallet
+      )
+    );
+    if (refusal) return refusal;
+    return Response.json(handedOut(subscription), { status: 201 });
+  }
+  /**
+   * Lands at once: the subscription turns active and its customer is granted
+   * the plan. The other checkouts waiting on that wallet expire, as on Mesub.
+   */
+  #submit(subscription) {
+    if (subscription.status !== "pending") {
+      return error(409, "not_awaiting_signature", "That subscription awaits no signature.");
+    }
+    if (this.#over(subscription.plan)) return error(409, "plan_ended", "This plan has ended.");
+    for (const other of this.#subscriptions) {
+      const beside = other.plan === subscription.plan && other.wallet === subscription.wallet;
+      if (beside && other !== subscription && other.status === "pending") {
+        other.status = "expired";
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    const end = new Date(now.getTime() + PERIOD_MS).toISOString();
+    const dates = bounded(
+      { access: true, access_until: end, next_charge_at: end, next_retry_at: null },
+      this.#endOf(subscription.plan)
+    );
+    Object.assign(subscription, {
+      status: "active",
+      payment_status: "paid",
+      current_period_start: now.toISOString(),
+      current_period_end: end,
+      confirmed_at: now.toISOString(),
+      ...dates
+    });
+    const plan = _nullishCoalesce(subscription.plan, () => ( ""));
+    const fields = {
+      wallet: subscription.wallet,
+      subscription_id: subscription.id,
+      subscribed_since: now.toISOString(),
+      first_subscribed_at: now.toISOString(),
+      current_period_end: end,
+      access_until: dates.access_until,
+      next_charge_at: dates.next_charge_at
+    };
+    this.grant({ wallet: subscription.wallet }, plan, fields);
+    if (subscription.external_id) {
+      this.grant({ external_id: subscription.external_id }, plan, fields);
+    }
+    if (subscription.email) this.grant({ email: subscription.email }, plan, fields);
+    const terms = this.#planList.find((each) => each.slug === subscription.plan);
+    this.#raise("subscription.created", subscription, false, {
+      first_payment: {
+        amount: _nullishCoalesce(_optionalChain([terms, 'optionalAccess', _16 => _16.amount]), () => ( "9990000")),
+        mint: _nullishCoalesce(_optionalChain([terms, 'optionalAccess', _17 => _17.mint]), () => ( USDC)),
+        signature: "fake_signature"
+      }
+    });
+    return Response.json({ subscription: this.#view(subscription) }, { status: 201 });
+  }
+  /**
+   * A hand retry, refused as Mesub's `RetryNowService` refuses it from what
+   * the fake holds, in its order: a parked late seat, a row not late, a
+   * plan past its end, the wait since the last one (by `tier`, with
+   * `Retry-After`), and on Free a `retry_deadline` passed or the three
+   * retries spent. Taken, it pulls nothing and the row stays `unpaid`: the
+   * fake counts it as one more that failed. What only the chain or a race
+   * decides (`insufficient_balance`, `retry_cannot_succeed`,
+   * `pull_running`, `subscription_changed`) is answered with `fail()`.
+   */
+  #retry(subscription) {
+    if (subscription.status === "unpaid" && subscription.paused) {
+      return error(
+        409,
+        "subscription_paused",
+        "This subscription is paused over the merchant's tier limit, so it cannot be retried."
+      );
+    }
+    if (subscription.status !== "unpaid") {
+      return error(
+        409,
+        "subscription_not_late",
+        "This subscription is not behind on its payment."
+      );
+    }
+    if (this.#over(subscription.plan)) {
+      return error(
+        409,
+        "plan_ended",
+        "This plan has ended, so this payment can no longer be collected."
+      );
+    }
+    const now = Date.now();
+    const free = this.#tier === "free";
+    const fired = _nullishCoalesce(this.#handRetries.get(subscription.id), () => ( { count: 0, at: 0 }));
+    const openAt = fired.count === 0 ? 0 : fired.at + (free ? FREE_RETRY_WAIT_MS : PAID_RETRY_WAIT_MS * 2 ** (fired.count - 1));
+    if (openAt > now) {
+      const minutes = Math.ceil((openAt - now) / 6e4);
+      return error(
+        409,
+        "retry_too_soon",
+        `Try again in ${minutes} ${minutes === 1 ? "minute" : "minutes"}.`,
+        { retryAfter: Math.ceil((openAt - now) / 1e3) }
+      );
+    }
+    if (free) {
+      const deadline = subscription.retry_deadline;
+      if (deadline !== null && Date.parse(deadline) <= now) {
+        return error(
+          409,
+          "retry_deadline_passed",
+          "The missed period ends too soon to retry."
+        );
+      }
+      if (fired.count >= FREE_HAND_RETRIES) {
+        return error(409, "retries_spent", "This subscription has no retries left.");
+      }
+    }
+    this.#handRetries.set(subscription.id, { count: fired.count + 1, at: now });
+    return Response.json(this.#view(subscription), { status: 202 });
+  }
+  /** The transaction of a cancel, resume or close, or Mesub's refusal of it. */
+  #build(action, subscription) {
+    const refusal = refusalOf(action, subscription, this.#gone.has(subscription.id));
+    if (refusal) return refusal;
+    const built = _nullishCoalesce(this.#built.get(subscription.id), () => ( /* @__PURE__ */ new Set()));
+    this.#built.set(subscription.id, built.add(action));
+    const answer = {
+      transaction: btoa(`fake ${action} transaction`),
+      last_valid_block_height: "0",
+      transaction_expires_at: expiresAt()
+    };
+    return Response.json(answer, { status: 201 });
+  }
+  /** Lands at once: the subscription moves, and so do its customer's access answers. */
+  #confirm(action, subscription, body) {
+    const { signature } = _nullishCoalesce(body, () => ( {}));
+    if (typeof signature !== "string" || signature === "") {
+      return error(400, "invalid_request", "signature must be a transaction signature.");
+    }
+    const gone = this.#gone.has(subscription.id);
+    const done = subscription.status === DONE[action] && !(endedWithPlan(subscription) && !gone);
+    const refusal = done ? null : refusalOf(action, subscription, gone);
+    if (refusal) return refusal;
+    if (!_optionalChain([this, 'access', _18 => _18.#built, 'access', _19 => _19.get, 'call', _20 => _20(subscription.id), 'optionalAccess', _21 => _21.has, 'call', _22 => _22(action)])) {
+      return error(400, "nothing_to_confirm", "There is no transaction to confirm yet.");
+    }
+    if (done) return Response.json({ subscription: this.#view(subscription) }, { status: 201 });
+    this.#built.set(subscription.id, /* @__PURE__ */ new Set([action]));
+    const before = this.#view(subscription).access;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const end = subscription.current_period_end;
+    if (action === "close" && endedWithPlan(subscription)) {
+      this.#gone.add(subscription.id);
+      this.#answer(subscription, {});
+      return Response.json({ subscription: this.#view(subscription) }, { status: 201 });
+    }
+    if (action === "cancel") {
+      Object.assign(subscription, {
+        status: "cancelled",
+        stop_reason: null,
+        ...NO_BLOCK,
+        next_charge_at: null,
+        next_retry_at: null,
+        retry_deadline: null,
+        next_retry_number: null,
+        retries_allowed: null,
+        access_until: subscription.access ? _nullishCoalesce(subscription.access_until, () => ( end)) : null
+      });
+      this.#answer(subscription, {
+        status: "cancelled",
+        stop_reason: null,
+        ...NO_BLOCK,
+        // The access a cancellation keeps, also where no grant dated it.
+        access_until: subscription.access_until,
+        cancelled_at: now,
+        next_charge_at: null,
+        next_retry_at: null,
+        retry_deadline: null
+      });
+    } else if (action === "resume") {
+      Object.assign(subscription, {
+        status: "active",
+        next_charge_at: end
+      });
+      this.#answer(subscription, {
+        status: "active",
+        cancelled_at: null,
+        next_charge_at: end
+      });
+    } else {
+      Object.assign(subscription, {
+        status: "ended",
+        end_reason: "closed",
+        stop_reason: null,
+        ...NO_BLOCK,
+        access: false,
+        payment_status: "none",
+        access_until: null,
+        next_charge_at: null,
+        next_retry_at: null,
+        retry_deadline: null,
+        next_retry_number: null,
+        retries_allowed: null
+      });
+      this.#answer(subscription, {
+        access: false,
+        status: "ended",
+        end_reason: "closed",
+        stop_reason: null,
+        ...NO_BLOCK,
+        payment_status: "none",
+        access_until: null,
+        next_charge_at: null,
+        next_retry_at: null,
+        retry_deadline: null
+      });
+    }
+    this.#raise(EVENT_OF[action], subscription, before);
+    return Response.json({ subscription: this.#view(subscription) }, { status: 201 });
+  }
+  /**
+   * Changes what `/v1/access` answers a subscription's customer, by wallet,
+   * external id and email, on top of what each was answered before.
+   */
+  #answer(subscription, fields) {
+    const plan = _nullishCoalesce(subscription.plan, () => ( ""));
+    const customers = [{ wallet: subscription.wallet }];
+    if (subscription.external_id) customers.push({ external_id: subscription.external_id });
+    if (subscription.email) customers.push({ email: subscription.email });
+    for (const customer of customers) {
+      const before = this.#answers.get(keyOf(_chunk4JSJOX35cjs.customerOf.call(void 0, customer), plan));
+      this.setAccess(customer, plan, {
+        wallet: subscription.wallet,
+        access: subscription.access,
+        payment_status: subscription.payment_status,
+        ...before,
+        subscription_id: subscription.id,
+        // A row whose close landed has nothing left to close; any
+        // other is worked out when served.
+        ...this.#gone.has(subscription.id) && { closable: false, closable_from: null },
+        ...fields
+      });
+    }
+  }
+}, _class);
+function revalidateAfter(answer, planEnd) {
+  if (!answer.access) return REVALIDATE_MIN_S;
+  const next = soonest(
+    _nullishCoalesce(_nullishCoalesce(answer.next_retry_at, () => ( answer.next_charge_at)), () => ( soonest(
+      answer.paused ? answer.current_period_end : null,
+      answer.status === "cancelled" ? answer.access_until : null
+    ))),
+    planEnd,
+    answer.blocked_since === null ? null : answer.access_until
+  );
+  if (next === null) return REVALIDATE_MAX_S;
+  const seconds = Math.floor((Date.parse(next) - Date.now()) / 1e3);
+  return Math.min(REVALIDATE_MAX_S, Math.max(REVALIDATE_MIN_S, seconds));
+}
+function soonest(...dates) {
+  return dates.reduce(
+    (first, date) => date === null || first !== null && Date.parse(first) <= Date.parse(date) ? first : date,
+    null
+  );
+}
+function bounded(row, end) {
+  if (end === null || !row.access) return row;
+  const at = Date.parse(end);
+  const none = { next_charge_at: null, next_retry_at: null };
+  if (at <= Date.now()) return { ...row, ...none, access: false, access_until: null };
+  const ahead = (date) => date !== null && Date.parse(date) < at ? date : null;
+  return {
+    ...row,
+    access_until: row.access_until !== null && Date.parse(row.access_until) > at ? end : row.access_until,
+    next_charge_at: ahead(row.next_charge_at),
+    next_retry_at: ahead(row.next_retry_at)
+  };
+}
+function datesOf(status, tier, now) {
+  const iso = (ms) => new Date(ms).toISOString();
+  const running = { current_period_start: iso(now), current_period_end: iso(now + PERIOD_MS) };
+  const behind = { current_period_start: iso(now - PERIOD_MS), current_period_end: iso(now) };
+  const nothing2 = {
+    access: false,
+    payment_status: "none",
+    next_charge_at: null,
+    access_until: null
+  };
+  switch (status) {
+    case "active":
+      return {
+        ...running,
+        access: true,
+        payment_status: "paid",
+        next_charge_at: running.current_period_end,
+        access_until: running.current_period_end
+      };
+    case "cancelled":
+      return {
+        ...running,
+        access: true,
+        payment_status: "paid",
+        next_charge_at: null,
+        access_until: running.current_period_end
+      };
+    case "unpaid": {
+      const late = {
+        ...behind,
+        late_reason: "insufficient_balance",
+        payment_status: "late",
+        next_charge_at: null
+      };
+      if (tier === "free") {
+        const deadline = iso(now + PERIOD_MS - CLOCK_MARGIN_MS);
+        return { ...late, access: false, access_until: null, retry_deadline: deadline };
+      }
+      const retry = iso(now + DAY_MS);
+      return {
+        ...late,
+        access: true,
+        // Its last retry: access stops there if that one fails too.
+        access_until: retry,
+        next_retry_at: retry,
+        next_retry_number: 1,
+        retries_allowed: 1
+      };
+    }
+    case "stopped":
+      return { ...behind, ...nothing2, stop_reason: "out_of_retries" };
+    case "ended":
+      return { ...behind, ...nothing2, end_reason: "closed" };
+    case "superseded":
+      return { ...behind, ...nothing2 };
+    default:
+      return {
+        ...nothing2,
+        current_period_start: null,
+        current_period_end: null,
+        confirmed_at: null
+      };
+  }
+}
+function expiresAt() {
+  return new Date(Date.now() + TRANSACTION_LIFE_MS).toISOString();
+}
+function handedOut(subscription) {
+  const zero = "0";
+  return {
+    subscription: { id: subscription.id, status: "pending" },
+    transaction: btoa("fake transaction"),
+    last_valid_block_height: zero,
+    transaction_expires_at: expiresAt(),
+    costs: {
+      rent: { subscription: zero, authority: null, total: zero },
+      fee: { signatures: 2, per_signature: zero, priority: zero, total: zero },
+      total: zero
+    },
+    terms: {
+      message: `Fake Mesub terms: ${subscription.wallet} subscribes to ${subscription.plan}.`,
+      expires_at: new Date(Date.now() + 5 * 6e4).toISOString()
+    }
+  };
+}
+var NO_BLOCK = { blocked_since: null, blocked_reason: null };
+var NO_RETRY = { next_retry_number: null, retries_allowed: null };
+function endedBy(row) {
+  const running = row.status === "active" || row.status === "unpaid";
+  if (!running && row.status !== "cancelled") return {};
+  return {
+    status: "ended",
+    end_reason: running ? "plan_ended" : "cancelled",
+    late_reason: null,
+    ...NO_BLOCK,
+    paused: false,
+    access: false,
+    payment_status: "none",
+    access_until: null,
+    next_charge_at: null,
+    next_retry_at: null,
+    retry_deadline: null
+  };
+}
+var EVENT_OF = {
+  cancel: "subscription.cancelled",
+  resume: "subscription.resumed",
+  close: "subscription.ended"
+};
+function closingOf(row, gone = false) {
+  const closable = refusalOf("close", row, gone) === null;
+  const ahead = row.access_until !== null && Date.parse(row.access_until) > Date.now();
+  return {
+    closable,
+    closable_from: !closable && row.status === "cancelled" && ahead ? row.access_until : null
+  };
+}
+function withClosing(subscription) {
+  return { ...subscription, ...closingOf(subscription) };
+}
+var DONE = {
+  cancel: "cancelled",
+  resume: "active",
+  close: "ended"
+};
+function refusalOf(action, subscription, gone = false) {
+  const { status, access_until } = subscription;
+  const over = access_until === null || Date.parse(access_until) <= Date.now();
+  const cancelled = status === "cancelled" || status === "ended" && subscription.end_reason === "cancelled";
+  if (action === "cancel") {
+    if (status === "cancelled") {
+      return error(409, "subscription_cancelled", "This subscription is cancelled already.");
+    }
+    return ["active", "unpaid", "stopped"].includes(status) ? null : error(409, "subscription_not_active", "This subscription is not running.");
+  }
+  if (action === "resume") {
+    if (status !== "cancelled") {
+      return error(409, "subscription_not_cancelled", "This subscription is not cancelled.");
+    }
+    return over ? error(409, "subscription_ended", "The period paid for is over: subscribe again.") : null;
+  }
+  if (endedWithPlan(subscription)) {
+    return gone ? error(
+      409,
+      "subscription_not_on_chain",
+      "This subscription was closed outside Mesub, so it has ended."
+    ) : null;
+  }
+  if (isClosed(subscription)) {
+    return error(409, "subscription_not_on_chain", "This subscription is closed already.");
+  }
+  if (status === "ended" && !cancelled) {
+    return error(
+      409,
+      "subscription_not_on_chain",
+      "This subscription has ended and cannot be closed through Mesub."
+    );
+  }
+  if (status === "stopped" && subscription.stop_reason === "authority_closed") return null;
+  if (!cancelled) {
+    return error(
+      409,
+      "subscription_not_cancelled",
+      "Cancel this subscription before closing it."
+    );
+  }
+  return over ? null : error(409, "close_too_early", `This subscription runs until ${access_until}.`);
+}
+function liveRefusal(held) {
+  const live = held.find(
+    (s) => ["active", "cancelled", "unpaid"].includes(s.status) || s.status === "ended" && s.end_reason === "cancelled"
+  );
+  const dead = held.find((s) => s.status === "stopped" && s.stop_reason === "authority_closed");
+  if (dead && !live) {
+    return error(
+      409,
+      "subscription_stopped",
+      "Your wallet's approval for this token was closed for good, so this subscription cannot restart. Close it, then subscribe again."
+    );
+  }
+  if (!live) return null;
+  if (live.status === "active") {
+    return error(409, "already_subscribed", "You are already subscribed to this plan.");
+  }
+  if (live.status === "unpaid") {
+    return error(
+      409,
+      "payment_pending",
+      "You already have a subscription to this plan, and its last payment is late. Open it in your subscriptions to see how to fix it, or cancel it."
+    );
+  }
+  const until = live.status === "cancelled" ? live.access_until : null;
+  return error(
+    409,
+    "subscription_cancelled",
+    until !== null && Date.parse(until) > Date.now() ? `Your subscription to this plan is cancelled but runs until ${until}: resume it instead of subscribing again.` : "Your cancelled subscription to this plan must be closed first: close it, then subscribe again."
+  );
+}
+function holderOf(contact) {
+  if (contact.external_id) return `x:${contact.external_id}`;
+  return contact.email ? `e:${contact.email}` : "-";
+}
+var WITH_ITS_PLAN = [
+  "plan_removed",
+  "plan_replaced",
+  "plan_ended"
+];
+function endedWithPlan(subscription) {
+  return subscription.status === "ended" && WITH_ITS_PLAN.includes(subscription.end_reason);
+}
+function isClosed(subscription) {
+  return subscription.status === "ended" && subscription.end_reason === "closed";
+}
+function keyOf(asked, plan) {
+  return `${asked.kind}:${asked.value}
+${plan}`;
+}
+var signedIds = 0;
+async function signWebhook(payload, options) {
+  const body = typeof payload === "string" ? payload : JSON.stringify(payload);
+  const id = _nullishCoalesce(options.id, () => ( `msg_signed_${signedIds += 1}`));
+  const timestamp = _nullishCoalesce(options.timestamp, () => ( Math.floor(Date.now() / 1e3)));
+  return { body, headers: await _chunk4JSJOX35cjs.signedHeaders.call(void 0, options.secret, id, timestamp, body) };
+}
+function detailOf(type, now, data) {
+  const start = now.toISOString();
+  const end = new Date(now.getTime() + PERIOD_MS).toISOString();
+  const paid = { amount: "9990000", mint: USDC, period_start: start, period_end: end };
+  switch (type) {
+    case "subscription.renewal_upcoming":
+      return {
+        can_pay: true,
+        renewal_issue: null,
+        amount: paid.amount,
+        mint: USDC,
+        // The check's window opens three days before the charge at most.
+        due_at: new Date(now.getTime() + 3 * 24 * 3600 * 1e3).toISOString()
+      };
+    case "subscription.renewed":
+      return { ...paid, signature: "fake_signature" };
+    case "subscription.payment_failed":
+      return {
+        ...paid,
+        reason: "insufficient_balance",
+        next_retry_at: new Date(now.getTime() + 24 * 3600 * 1e3).toISOString(),
+        retry_deadline: null,
+        retries_left: 1,
+        retry_mode: "scheduled"
+      };
+    case "subscription.stopped":
+      return { reason: "insufficient_balance" };
+    case "subscription.access_granted":
+    case "subscription.access_revoked":
+      return accessDetailOf(data, start);
+    case "subscription.created":
+      return {
+        first_payment: { amount: paid.amount, mint: USDC, signature: "fake_signature" }
+      };
+    case "subscription.ended":
+      return data.end_reason === "cancelled" ? { changed_at: start, end_reason: "cancelled" } : {};
+    default:
+      return {};
+  }
+}
+function accessDetailOf(data, changedAt) {
+  const { access, blocked_reason, access_until, status, end_reason } = data;
+  const dated = blocked_reason !== null || status === "ended" && (end_reason === "cancelled" || end_reason === "plan_ended");
+  return {
+    changed_at: changedAt,
+    blocked_reason,
+    access_until: access ? blocked_reason === null ? null : access_until : _nullishCoalesce(access_until, () => ( (dated ? changedAt : null)))
+  };
+}
+function subscriptionOf(type) {
+  if (type === "subscription.paused") return { paused: true, next_charge_at: null };
+  if (type !== "subscription.access_revoked") return {};
+  return {
+    status: "ended",
+    end_reason: "cancelled",
+    access: false,
+    payment_status: "none",
+    next_charge_at: null,
+    access_until: null
+  };
+}
+function nothing(asked, plan) {
+  return { wallet: asked.kind === "wallet" ? asked.value : null, plan, ...NOTHING };
+}
+var BASE58_ADDRESS = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+var EMAIL = /^[^\s@]+@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/;
+function invalidContact({ wallet, email }) {
+  const reasons = [];
+  if (typeof wallet === "string" && !BASE58_ADDRESS.test(wallet)) {
+    reasons.push("wallet must be a base58 Solana address");
+  }
+  if (typeof email === "string") {
+    const normalised = email.trim().toLowerCase();
+    if (!EMAIL.test(normalised)) reasons.push("email must be an email address");
+    if (normalised.length > 254) {
+      reasons.push("email must be shorter than or equal to 254 characters");
+    }
+  }
+  return reasons.length ? error(400, "invalid_request", reasons) : null;
+}
+var LIMIT_MESSAGE = "limit must be a whole number from 1 to 100";
+function limitOf(value) {
+  const limit = /^\d{1,4}$/.test(value) ? Number(value) : NaN;
+  return limit >= 1 && limit <= 100 ? limit : null;
+}
+function invalidSubmit(body) {
+  const { transaction, terms_signature } = _nullishCoalesce(body, () => ( {}));
+  const reasons = [];
+  if (typeof transaction !== "string" || transaction.length > 2048) {
+    reasons.push("transaction must be shorter than or equal to 2048 characters");
+  }
+  if (typeof transaction !== "string" || !/^[A-Za-z0-9+/]+={0,2}$/.test(transaction)) {
+    reasons.push("transaction must be base64");
+  }
+  if (typeof terms_signature !== "string" || terms_signature === "") {
+    reasons.push("terms_signature must be a base58 signature");
+  }
+  return reasons.length ? error(400, "invalid_request", reasons) : null;
+}
+function askedIn(query) {
+  try {
+    return _chunk4JSJOX35cjs.customerOf.call(void 0, {
+      wallet: query["wallet"],
+      external_id: query["external_id"],
+      email: query["email"]
+    });
+  } catch (e) {
+    return null;
+  }
+}
+function withAttempts(answer, attempts) {
+  if (attempts) return { ...answer, attempts: _nullishCoalesce(answer.attempts, () => ( [])) };
+  const light = { ...answer };
+  delete light.attempts;
+  return light;
+}
+function fakePlan(slug, { token, ...over } = {}) {
+  const symbol = over.symbol === void 0 ? token ? null : "USDC" : over.symbol;
+  const vouched = token === void 0 && symbol !== null;
+  return {
+    slug,
+    name: slug,
+    description: null,
+    project_name: "Test project",
+    logo_url: null,
+    amount: "9990000",
+    amount_display: "9.99",
+    amount_usd: vouched ? _nullishCoalesce(over.amount_display, () => ( "9.99")) : null,
+    decimals: 6,
+    symbol,
+    token: {
+      symbol: token ? null : symbol,
+      name: vouched && symbol === "USDC" ? "USD Coin" : null,
+      logo_url: null,
+      verified: vouched,
+      ...token
+    },
+    mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    period_hours: 720,
+    network: "mainnet-beta",
+    status: "active",
+    available: true,
+    ends_at: null,
+    ...over
+  };
+}
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "rate_limited",
+  "internal_error",
+  "unavailable",
+  "comeback_in_flight",
+  "comeback_period_rolling",
+  "pending_cap_reached",
+  "subscription_changed",
+  "retry_too_soon",
+  "pull_running",
+  "network_unavailable"
+]);
+function waitOf(method, path, status, code, tier) {
+  if (code === "retry_too_soon")
+    return (tier === "free" ? FREE_RETRY_WAIT_MS : PAID_RETRY_WAIT_MS) / 1e3;
+  if (status !== 503 || method !== "POST" || !path.startsWith("/v1/subscriptions")) {
+    return void 0;
+  }
+  if (code === "unavailable" && path.endsWith("/submit")) return 2;
+  if (code === "unavailable" && path.endsWith("/retry")) return 20;
+  return 10;
+}
+function error(status, code, message, { retryable, retryAfter } = {}) {
+  return Response.json(
+    {
+      statusCode: status,
+      error: _nullishCoalesce(REASONS[status], () => ( "Error")),
+      message,
+      code,
+      retryable: _nullishCoalesce(retryable, () => ( (RETRYABLE_CODES.has(code) || status === 408 || status === 429 || status >= 500)))
+    },
+    {
+      status,
+      ...retryAfter !== void 0 && { headers: { "Retry-After": String(retryAfter) } }
+    }
+  );
+}
+async function stamped(response, id) {
+  const headers = new Headers(response.headers);
+  headers.set(REQUEST_ID_HEADER, id);
+  headers.set(_chunk4JSJOX35cjs.API_VERSION_HEADER, _chunk4JSJOX35cjs.API_VERSION);
+  if (response.ok) return new Response(response.body, { status: response.status, headers });
+  const body = await response.json();
+  return Response.json({ ...body, request_id: id }, { status: response.status, headers });
+}
+
+
+
+exports.FakeMesub = FakeMesub; exports.signWebhook = signWebhook;
+//# sourceMappingURL=testing.cjs.map