reveclicat 0.1.0

package/dist/cli.js

@@ -0,0 +1,1905 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { CommanderError } from "commander";
+
+// src/program.ts
+import { Command } from "commander";
+
+// package.json
+var package_default = {
+  name: "reveclicat",
+  version: "0.1.0",
+  description: "Unofficial CLI to simulate RevenueCat subscription lifecycles and test webhooks locally and in CI. Not affiliated with RevenueCat, Inc.",
+  type: "module",
+  license: "MIT",
+  engines: {
+    node: ">=20"
+  },
+  bin: {
+    rcc: "dist/cli.js",
+    purr: "dist/cli.js"
+  },
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "scenarios",
+    "examples",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsx src/cli.ts",
+    test: "vitest run",
+    "test:watch": "vitest",
+    lint: "eslint .",
+    typecheck: "tsc --noEmit",
+    check: "npm run typecheck && npm run lint && npm test",
+    prepublishOnly: "npm run check && npm run build"
+  },
+  keywords: [
+    "revenuecat",
+    "webhooks",
+    "cli",
+    "subscriptions",
+    "testing",
+    "ci"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/RadW2020/ReveCliCat.git"
+  },
+  dependencies: {
+    commander: "15.0.0",
+    yaml: "2.9.0",
+    zod: "4.5.1"
+  },
+  devDependencies: {
+    "@eslint/js": "10.0.1",
+    "@types/express": "5.0.6",
+    "@types/node": "26.4.0",
+    eslint: "10.9.1",
+    express: "5.2.1",
+    tsup: "8.5.1",
+    tsx: "4.23.12",
+    typescript: "6.0.3",
+    "typescript-eslint": "8.68.0",
+    vitest: "4.1.11"
+  },
+  homepage: "https://github.com/RadW2020/ReveCliCat#readme",
+  bugs: {
+    url: "https://github.com/RadW2020/ReveCliCat/issues"
+  },
+  author: "RadW2020"
+};
+
+// src/core/colors.ts
+var ESC = String.fromCharCode(27);
+var enabled = () => process.env["NO_COLOR"] === void 0 && process.env["FORCE_COLOR"] !== "0" && (process.stdout.isTTY || process.env["FORCE_COLOR"] !== void 0);
+var wrap = (open, close = 39) => (s) => enabled() ? `${ESC}[${open}m${s}${ESC}[${close}m` : s;
+var red = wrap(31);
+var green = wrap(32);
+var yellow = wrap(33);
+var cyan = wrap(36);
+var magenta = wrap(35);
+var dim = wrap(2, 22);
+var bold = wrap(1, 22);
+
+// src/core/errors.ts
+var RccError = class extends Error {
+  hint;
+  exitCode;
+  constructor(message, opts = {}) {
+    super(message, opts.cause === void 0 ? void 0 : { cause: opts.cause });
+    this.name = "RccError";
+    this.hint = opts.hint;
+    this.exitCode = opts.exitCode ?? 1;
+  }
+};
+function formatError(err) {
+  const debug = process.env["RCC_DEBUG"] === "1";
+  const mark = red("\u2716");
+  if (err instanceof RccError) {
+    let out = `${mark} ${err.message}`;
+    if (err.hint) out += `
+  ${dim("\u2192 " + err.hint)}`;
+    if (debug && err.stack) out += `
+${dim(err.stack)}`;
+    return out;
+  }
+  if (err instanceof Error) {
+    return debug ? `${mark} ${err.stack ?? err.message}` : `${mark} ${err.message}
+  ${dim("\u2192 Set RCC_DEBUG=1 for a stack trace.")}`;
+  }
+  return `${mark} ${String(err)}`;
+}
+function exitCodeFor(err) {
+  return err instanceof RccError ? err.exitCode : 1;
+}
+
+// src/core/config.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+
+// src/schemas/common.ts
+var EVENT_TYPES = [
+  "TEST",
+  "INITIAL_PURCHASE",
+  "RENEWAL",
+  "CANCELLATION",
+  "UNCANCELLATION",
+  "BILLING_ISSUE",
+  "EXPIRATION"
+];
+var ENVIRONMENTS = ["SANDBOX", "PRODUCTION"];
+var STORES = [
+  "AMAZON",
+  "APP_STORE",
+  "MAC_APP_STORE",
+  "PADDLE",
+  "PLAY_STORE",
+  "PROMOTIONAL",
+  "RC_BILLING",
+  "ROKU",
+  "STRIPE",
+  "TEST_STORE"
+];
+var PERIOD_TYPES = ["TRIAL", "INTRO", "NORMAL", "PROMOTIONAL", "PREPAID"];
+var CANCEL_REASONS = [
+  "UNSUBSCRIBE",
+  "BILLING_ERROR",
+  "DEVELOPER_INITIATED",
+  "PRICE_INCREASE",
+  "CUSTOMER_SUPPORT",
+  "UNKNOWN"
+];
+var EXPIRATION_REASONS = [...CANCEL_REASONS, "SUBSCRIPTION_PAUSED"];
+var CLI_STORES = ["app_store"];
+var CLI_STORE_TO_STORE = { app_store: "APP_STORE" };
+
+// src/core/config.ts
+var CONFIG_FILE = "reveclicat.config.json";
+var DEFAULT_TARGET = "http://localhost:3000/webhook";
+var ConfigSchema = z.strictObject({
+  to: z.url({ error: "`to` must be an absolute http(s) URL." }).optional(),
+  authHeader: z.string().optional(),
+  store: z.enum(CLI_STORES, { error: `\`store\` must be one of: ${CLI_STORES.join(", ")}.` }).optional(),
+  environment: z.enum(ENVIRONMENTS, { error: `\`environment\` must be one of: ${ENVIRONMENTS.join(", ")}.` }).optional()
+});
+function loadConfig(dir = process.cwd()) {
+  const file = join(dir, CONFIG_FILE);
+  if (!existsSync(file)) return {};
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(file, "utf8"));
+  } catch (cause) {
+    throw new RccError(`${file} is not valid JSON.`, { hint: "Fix the file or delete it and run `rcc init` again.", cause });
+  }
+  const result = ConfigSchema.safeParse(raw);
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    const detail = issue.code === "unrecognized_keys" ? `unknown key ${issue.keys.map((k) => `"${k}"`).join(", ")} (allowed: to, authHeader, store, environment)` : `${issue.path.join(".")}: ${issue.message}`;
+    throw new RccError(`${file}: ${detail}`, { hint: "See the config format in the README." });
+  }
+  return result.data;
+}
+function resolveDefaults(flags, config) {
+  return {
+    to: flags.to ?? config.to ?? DEFAULT_TARGET,
+    authHeader: flags.authHeader ?? config.authHeader,
+    store: flags.store ?? config.store ?? "app_store",
+    environment: flags.environment ?? config.environment ?? "SANDBOX"
+  };
+}
+function packageRoot() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 6; i++) {
+    const pkg = join(dir, "package.json");
+    if (existsSync(pkg)) {
+      try {
+        if (JSON.parse(readFileSync(pkg, "utf8")).name === "reveclicat") return dir;
+      } catch {
+      }
+    }
+    dir = dirname(dir);
+  }
+  throw new RccError("Could not locate the reveclicat package root.", { hint: "Reinstall the package: npm i -g reveclicat" });
+}
+
+// src/core/clock.ts
+var InvalidDurationError = class extends RccError {
+  constructor(input) {
+    super(
+      input === "" ? "Duration is empty." : `Invalid ISO-8601 duration: "${input}".`,
+      { hint: "Use the form PnYnMnWnDTnHnMnS, e.g. P1M (one month), P1W (one week), P3D, PT12H." }
+    );
+    this.name = "InvalidDurationError";
+  }
+};
+var ClockError = class extends RccError {
+  constructor(message, hint) {
+    super(message, hint === void 0 ? {} : { hint });
+    this.name = "ClockError";
+  }
+};
+var DURATION_RE = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/;
+function parseDuration(input) {
+  if (input === "") throw new InvalidDurationError(input);
+  const m = DURATION_RE.exec(input);
+  if (!m || input === "P" || input.endsWith("T")) throw new InvalidDurationError(input);
+  const n = (i) => m[i] === void 0 ? 0 : Number(m[i]);
+  return {
+    years: n(1),
+    months: n(2),
+    weeks: n(3),
+    days: n(4),
+    hours: n(5),
+    minutes: n(6),
+    seconds: n(7)
+  };
+}
+function formatDuration(d) {
+  let out = "P";
+  if (d.years) out += `${d.years}Y`;
+  if (d.months) out += `${d.months}M`;
+  if (d.weeks) out += `${d.weeks}W`;
+  if (d.days) out += `${d.days}D`;
+  if (d.hours || d.minutes || d.seconds) {
+    out += "T";
+    if (d.hours) out += `${d.hours}H`;
+    if (d.minutes) out += `${d.minutes}M`;
+    if (d.seconds) out += `${d.seconds}S`;
+  }
+  return out === "P" ? "PT0S" : out;
+}
+function isZeroDuration(d) {
+  return Object.values(d).every((v) => v === 0);
+}
+var MS = { second: 1e3, minute: 6e4, hour: 36e5, day: 864e5, week: 6048e5 };
+function addDuration(ms2, d) {
+  const date = new Date(ms2);
+  if (d.years || d.months) {
+    const totalMonths = date.getUTCFullYear() * 12 + date.getUTCMonth() + d.years * 12 + d.months;
+    const year = Math.floor(totalMonths / 12);
+    const month = totalMonths % 12;
+    const lastDay = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+    const day = Math.min(date.getUTCDate(), lastDay);
+    date.setUTCFullYear(year, month, day);
+  }
+  return date.getTime() + d.weeks * MS.week + d.days * MS.day + d.hours * MS.hour + d.minutes * MS.minute + d.seconds * MS.second;
+}
+var SEEDED_EPOCH_MS = Date.UTC(2025, 0, 1);
+var VirtualClock = class _VirtualClock {
+  current;
+  constructor(startMs) {
+    this.current = startMs;
+  }
+  /** Seeded runs start at a fixed epoch so payloads are reproducible; unseeded runs start now. */
+  static forSeed(seed, startAt) {
+    if (startAt !== void 0) return new _VirtualClock(startAt);
+    return new _VirtualClock(seed === void 0 ? Date.now() : SEEDED_EPOCH_MS);
+  }
+  now() {
+    return this.current;
+  }
+  iso() {
+    return new Date(this.current).toISOString();
+  }
+  /** Advance by a Duration or ISO-8601 string. Returns the new now(). */
+  advance(duration2) {
+    const d = typeof duration2 === "string" ? parseDuration(duration2) : duration2;
+    if (isZeroDuration(d)) {
+      throw new ClockError(
+        `Cannot advance the clock by a zero-length duration (${formatDuration(d)}).`,
+        "The virtual clock only moves forward; use a positive duration such as P1D."
+      );
+    }
+    const next = addDuration(this.current, d);
+    if (next <= this.current) {
+      throw new ClockError("The virtual clock cannot move backwards.");
+    }
+    this.current = next;
+    return next;
+  }
+};
+
+// src/core/http.ts
+function unreachableError(url, cause) {
+  return new RccError(`Could not reach ${url}. Is your server running? Try \`rcc listen\` to test locally.`, {
+    hint: `Then send events with: rcc send INITIAL_PURCHASE --to http://localhost:8787/webhook`,
+    cause
+  });
+}
+async function postEvent(url, envelope, opts = {}) {
+  const headers = { "content-type": "application/json", "user-agent": "reveclicat" };
+  if (opts.authHeader !== void 0) headers["authorization"] = opts.authHeader;
+  const started = performance.now();
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(envelope),
+      signal: AbortSignal.timeout(opts.timeoutMs ?? 3e4)
+    });
+  } catch (cause) {
+    throw unreachableError(url, cause);
+  }
+  const body = await res.text().catch(() => "");
+  return { status: res.status, latencyMs: Math.round(performance.now() - started), body };
+}
+function assertUrl(value, flag) {
+  try {
+    const u = new URL(value);
+    if (u.protocol !== "http:" && u.protocol !== "https:") throw new Error("protocol");
+    return value;
+  } catch {
+    throw new RccError(`Invalid URL for ${flag}: "${value}".`, { hint: "Use an absolute http(s) URL, e.g. http://localhost:3000/webhook." });
+  }
+}
+
+// src/core/rng.ts
+import { randomUUID } from "crypto";
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h >>> 0;
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var HEX = "0123456789abcdef";
+function normalizeSeed(seed) {
+  return typeof seed === "number" ? seed >>> 0 : fnv1a(seed);
+}
+function createRng(seed) {
+  const seeded = seed !== void 0;
+  const next = seeded ? mulberry32(normalizeSeed(seed)) : Math.random;
+  const hex = (n) => {
+    let s = "";
+    for (let i = 0; i < n; i++) s += HEX[Math.floor(next() * 16)];
+    return s;
+  };
+  return {
+    next,
+    int: (max) => Math.floor(next() * max),
+    hex,
+    uuid: () => {
+      if (!seeded) return randomUUID();
+      const variant = HEX[8 + Math.floor(next() * 4)];
+      return `${hex(8)}-${hex(4)}-4${hex(3)}-${variant}${hex(3)}-${hex(12)}`;
+    }
+  };
+}
+
+// src/core/set-path.ts
+function setPath(target, path, value) {
+  const keys = path.split(".");
+  let cur = target;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = keys[i];
+    const next = cur[k];
+    if (typeof next !== "object" || next === null || Array.isArray(next)) {
+      const fresh = {};
+      cur[k] = fresh;
+      cur = fresh;
+    } else {
+      cur = next;
+    }
+  }
+  cur[keys[keys.length - 1]] = value;
+  return target;
+}
+function applyOverrides(target, overrides) {
+  for (const [k, v] of Object.entries(overrides)) setPath(target, k, v);
+  return target;
+}
+
+// src/core/state-machine.ts
+var IllegalTransitionError = class extends RccError {
+  state;
+  event;
+  legal;
+  constructor(state, event) {
+    const legal = legalEvents(state);
+    super(
+      `Illegal transition: cannot apply ${event} while the subscription is "${state}". Legal events from "${state}": ${legal.join(", ")}.`,
+      { hint: "Check the order of the steps in your scenario (e.g. a RENEWAL needs an INITIAL_PURCHASE first)." }
+    );
+    this.name = "IllegalTransitionError";
+    this.state = state;
+    this.event = event;
+    this.legal = legal;
+  }
+};
+var TABLE = {
+  none: { INITIAL_PURCHASE: (ctx) => ctx.hasTrial ? "trial" : "active" },
+  trial: {
+    RENEWAL: () => "active",
+    CANCELLATION: () => "cancelled_pending_expiration",
+    BILLING_ISSUE: () => "billing_issue",
+    EXPIRATION: () => "expired"
+  },
+  active: {
+    RENEWAL: () => "active",
+    CANCELLATION: () => "cancelled_pending_expiration",
+    BILLING_ISSUE: () => "billing_issue",
+    EXPIRATION: () => "expired"
+  },
+  cancelled_pending_expiration: {
+    UNCANCELLATION: (ctx) => ctx.resumeState,
+    EXPIRATION: () => "expired"
+  },
+  billing_issue: {
+    RENEWAL: () => "active",
+    EXPIRATION: () => "expired",
+    CANCELLATION: () => "cancelled_pending_expiration"
+  },
+  expired: { INITIAL_PURCHASE: () => "active" }
+};
+function legalEvents(state) {
+  return [...Object.keys(TABLE[state]), "TEST"];
+}
+function transition(state, event, ctx) {
+  if (event === "TEST") return state;
+  const rule = TABLE[state][event];
+  if (!rule) throw new IllegalTransitionError(state, event);
+  return rule(ctx);
+}
+
+// src/schemas/events.ts
+import { z as z2 } from "zod";
+var ms = z2.int();
+var double = z2.number();
+var SubscriberAttributeSchema = z2.looseObject({
+  value: z2.string(),
+  updated_at_ms: ms
+});
+var ExperimentSchema = z2.looseObject({
+  experiment_id: z2.string(),
+  experiment_variant: z2.string(),
+  enrolled_at_ms: ms.nullable()
+});
+var common = {
+  id: z2.string(),
+  event_timestamp_ms: ms,
+  app_id: z2.string().optional()
+};
+var identity = {
+  app_user_id: z2.string(),
+  original_app_user_id: z2.string(),
+  aliases: z2.array(z2.string()),
+  subscriber_attributes: z2.record(z2.string(), SubscriberAttributeSchema).optional(),
+  experiments: z2.array(ExperimentSchema).optional()
+};
+var lifecycle = {
+  product_id: z2.string(),
+  period_type: z2.enum(PERIOD_TYPES),
+  purchased_at_ms: ms,
+  expiration_at_ms: ms.nullable(),
+  environment: z2.enum(ENVIRONMENTS),
+  entitlement_id: z2.string().nullable(),
+  entitlement_ids: z2.array(z2.string()).nullable(),
+  presented_offering_id: z2.string().nullable(),
+  transaction_id: z2.string(),
+  original_transaction_id: z2.string(),
+  // Docs: "Always" = key present, value may be null. Real PROMOTIONAL events carry null here (T-064).
+  is_family_share: z2.boolean().nullable(),
+  country_code: z2.string().nullable(),
+  store: z2.enum(STORES).optional(),
+  currency: z2.string().nullable().optional(),
+  price: double.nullable().optional(),
+  price_in_purchased_currency: double.nullable().optional(),
+  tax_percentage: double.nullable().optional(),
+  commission_percentage: double.nullable().optional(),
+  takehome_percentage: double.nullable().optional(),
+  offer_code: z2.string().nullable().optional(),
+  renewal_number: z2.int().nullable().optional(),
+  metadata: z2.record(z2.string(), z2.unknown()).nullable().optional(),
+  discount_percentage: double.nullable().optional(),
+  discount_amount: double.nullable().optional(),
+  discount_identifier: z2.string().nullable().optional()
+};
+var LifecycleEventBase = z2.looseObject({ ...common, ...identity, ...lifecycle });
+var InitialPurchaseEventSchema = LifecycleEventBase.extend({ type: z2.literal("INITIAL_PURCHASE") });
+var RenewalEventSchema = LifecycleEventBase.extend({
+  type: z2.literal("RENEWAL"),
+  is_trial_conversion: z2.boolean().optional()
+});
+var CancellationEventSchema = LifecycleEventBase.extend({
+  type: z2.literal("CANCELLATION"),
+  cancel_reason: z2.enum(CANCEL_REASONS)
+});
+var UncancellationEventSchema = LifecycleEventBase.extend({ type: z2.literal("UNCANCELLATION") });
+var BillingIssueEventSchema = LifecycleEventBase.extend({
+  type: z2.literal("BILLING_ISSUE"),
+  grace_period_expiration_at_ms: ms.nullable()
+});
+var ExpirationEventSchema = LifecycleEventBase.extend({
+  type: z2.literal("EXPIRATION"),
+  expiration_reason: z2.enum(EXPIRATION_REASONS)
+});
+function nullableOptional(shape) {
+  return Object.fromEntries(Object.entries(shape).map(([k, schema]) => [k, schema.nullable().optional()]));
+}
+var TestEventSchema = z2.looseObject({
+  type: z2.literal("TEST"),
+  ...common,
+  ...identity,
+  ...nullableOptional(lifecycle)
+});
+var EVENT_SCHEMAS = {
+  TEST: TestEventSchema,
+  INITIAL_PURCHASE: InitialPurchaseEventSchema,
+  RENEWAL: RenewalEventSchema,
+  CANCELLATION: CancellationEventSchema,
+  UNCANCELLATION: UncancellationEventSchema,
+  BILLING_ISSUE: BillingIssueEventSchema,
+  EXPIRATION: ExpirationEventSchema
+};
+var EventSchema = z2.discriminatedUnion("type", [
+  TestEventSchema,
+  InitialPurchaseEventSchema,
+  RenewalEventSchema,
+  CancellationEventSchema,
+  UncancellationEventSchema,
+  BillingIssueEventSchema,
+  ExpirationEventSchema
+]);
+var WebhookEnvelopeSchema = z2.looseObject({
+  api_version: z2.string(),
+  event: EventSchema
+});
+var UnknownEventSchema = z2.looseObject({ type: z2.string().min(1), ...common, ...identity });
+var UnknownWebhookEnvelopeSchema = z2.looseObject({ api_version: z2.string(), event: UnknownEventSchema });
+function classifyEnvelope(body) {
+  const known = WebhookEnvelopeSchema.safeParse(body);
+  if (known.success) return { kind: "known", envelope: known.data };
+  const loose = UnknownWebhookEnvelopeSchema.safeParse(body);
+  const typeIsOurs = loose.success && EVENT_TYPES.includes(loose.data.event.type);
+  if (loose.success && !typeIsOurs) return { kind: "unknown-type", type: loose.data.event.type, envelope: loose.data };
+  const source = loose.success ? known : loose;
+  return {
+    kind: "invalid",
+    issues: source.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+  };
+}
+
+// src/core/subscriber.ts
+var PrematureEventError = class extends RccError {
+  constructor(event, nowMs, dueMs) {
+    const remaining = msToDuration(dueMs - nowMs);
+    super(
+      `Cannot emit ${event} yet: the virtual clock is at ${new Date(nowMs).toISOString()} but the subscription runs until ${new Date(dueMs).toISOString()}. Add \`advance: ${remaining}\` (or more) before this step.`,
+      { hint: "The virtual clock must reach expiration_at_ms (or the end of the grace period) before EXPIRATION." }
+    );
+    this.name = "PrematureEventError";
+  }
+};
+function msToDuration(ms2) {
+  const days = Math.ceil(ms2 / 864e5);
+  if (days >= 1) return `P${days}D`;
+  return formatDuration({ ...parseDuration("PT1S"), seconds: Math.max(1, Math.ceil(ms2 / 1e3)) });
+}
+var asDuration = (d) => typeof d === "string" ? parseDuration(d) : d;
+var Subscriber = class {
+  constructor(opts, deps) {
+    this.deps = deps;
+    this.period = asDuration(opts.period);
+    this.trial = opts.trial === void 0 ? void 0 : asDuration(opts.trial);
+    this.grace = asDuration(opts.gracePeriod ?? "P16D");
+    this.store = CLI_STORE_TO_STORE[opts.store ?? "app_store"];
+    this.environment = opts.environment ?? "SANDBOX";
+    this.price = opts.price ?? 9.99;
+    this.currency = opts.currency ?? "USD";
+    this.countryCode = opts.countryCode ?? "US";
+    this.entitlementIds = opts.entitlementIds ?? ["premium"];
+    this.productId = opts.productId;
+    this.appUserId = opts.appUserId === void 0 || opts.appUserId === "auto" ? `$RCAnonymousID:${deps.rng.hex(32)}` : opts.appUserId;
+    this.appId = opts.appId ?? `app${deps.rng.hex(12)}`;
+  }
+  deps;
+  history = [];
+  _state = "none";
+  resumeState = "active";
+  period;
+  trial;
+  grace;
+  store;
+  environment;
+  price;
+  currency;
+  countryCode;
+  entitlementIds;
+  productId;
+  appUserId;
+  appId;
+  originalTransactionId;
+  transactionId;
+  purchasedAtMs;
+  expirationAtMs;
+  periodType = "NORMAL";
+  gracePeriodExpirationAtMs = null;
+  get state() {
+    return this._state;
+  }
+  /** Current period end (ms) or undefined before the first purchase. */
+  get expiresAt() {
+    return this.expirationAtMs;
+  }
+  /** Emit an event: check legality, time guards, build + validate payload, commit state. */
+  emit(type, overrides = {}) {
+    const from = this._state;
+    const next = transition(from, type, { hasTrial: this.trial !== void 0, resumeState: this.resumeState });
+    const now = this.deps.clock.now();
+    if (type === "EXPIRATION") {
+      const due = Math.max(this.expirationAtMs ?? 0, from === "billing_issue" ? this.gracePeriodExpirationAtMs ?? 0 : 0);
+      if (now < due) throw new PrematureEventError(type, now, due);
+    }
+    const draft = this.draftFor(type, from, now);
+    const payload = applyOverrides(this.buildPayload(type, from, now, draft), overrides);
+    const result = EVENT_SCHEMAS[type].safeParse(payload);
+    if (!result.success) {
+      const issue = result.error.issues[0];
+      throw new RccError(`Generated ${type} payload is invalid at "${issue.path.join(".")}": ${issue.message}`, {
+        hint: "Check your --set / set: overrides against the RevenueCat field types (docs/payload-sources.md)."
+      });
+    }
+    if (type !== "TEST") {
+      this.originalTransactionId = draft.originalTransactionId;
+      this.transactionId = draft.transactionId;
+      this.purchasedAtMs = draft.purchasedAtMs;
+      this.expirationAtMs = draft.expirationAtMs;
+      this.periodType = draft.periodType;
+      this.gracePeriodExpirationAtMs = draft.gracePeriodExpirationAtMs;
+      if (type === "CANCELLATION") this.resumeState = from === "trial" ? "trial" : "active";
+      this._state = next;
+    }
+    const event = result.data;
+    this.history.push(event);
+    return event;
+  }
+  /* ----------------------------------------------------------- internals */
+  newTransactionId() {
+    let s = String(1 + this.deps.rng.int(9));
+    for (let i = 0; i < 15; i++) s += String(this.deps.rng.int(10));
+    return s;
+  }
+  draftFor(type, from, now) {
+    const d = {
+      originalTransactionId: this.originalTransactionId,
+      transactionId: this.transactionId,
+      purchasedAtMs: this.purchasedAtMs,
+      expirationAtMs: this.expirationAtMs,
+      periodType: this.periodType,
+      gracePeriodExpirationAtMs: this.gracePeriodExpirationAtMs
+    };
+    switch (type) {
+      case "INITIAL_PURCHASE": {
+        const startsTrial = from === "none" && this.trial !== void 0;
+        d.transactionId = this.newTransactionId();
+        d.originalTransactionId ??= d.transactionId;
+        d.purchasedAtMs = now;
+        d.expirationAtMs = addDuration(now, startsTrial ? this.trial : this.period);
+        d.periodType = startsTrial ? "TRIAL" : "NORMAL";
+        d.gracePeriodExpirationAtMs = null;
+        break;
+      }
+      case "RENEWAL": {
+        const start = d.expirationAtMs ?? now;
+        d.transactionId = this.newTransactionId();
+        d.purchasedAtMs = start;
+        d.expirationAtMs = addDuration(start, this.period);
+        d.periodType = "NORMAL";
+        d.gracePeriodExpirationAtMs = null;
+        break;
+      }
+      case "BILLING_ISSUE":
+        d.gracePeriodExpirationAtMs = addDuration(now, this.grace);
+        break;
+      case "TEST":
+        if (from === "none") {
+          d.transactionId = d.originalTransactionId = this.newTransactionId();
+          d.purchasedAtMs = now;
+          d.expirationAtMs = addDuration(now, this.period);
+          d.periodType = "NORMAL";
+        }
+        break;
+      default:
+        break;
+    }
+    return d;
+  }
+  buildPayload(type, from, now, d) {
+    const isPurchase = type === "INITIAL_PURCHASE" || type === "RENEWAL" || type === "TEST";
+    const price = isPurchase && d.periodType !== "TRIAL" ? this.price : 0;
+    const payload = {
+      type,
+      id: this.deps.rng.uuid(),
+      event_timestamp_ms: now,
+      app_id: this.appId,
+      app_user_id: this.appUserId,
+      original_app_user_id: this.appUserId,
+      aliases: [this.appUserId],
+      subscriber_attributes: {},
+      product_id: this.productId,
+      period_type: d.periodType,
+      purchased_at_ms: d.purchasedAtMs,
+      expiration_at_ms: d.expirationAtMs,
+      environment: this.environment,
+      entitlement_id: null,
+      entitlement_ids: [...this.entitlementIds],
+      presented_offering_id: null,
+      transaction_id: d.transactionId,
+      original_transaction_id: d.originalTransactionId,
+      is_family_share: false,
+      country_code: this.countryCode,
+      store: this.store,
+      currency: this.currency,
+      price,
+      price_in_purchased_currency: price,
+      tax_percentage: 0,
+      commission_percentage: 0.3,
+      takehome_percentage: 0.7,
+      offer_code: null
+    };
+    switch (type) {
+      case "RENEWAL":
+        payload["is_trial_conversion"] = from === "trial";
+        break;
+      case "CANCELLATION":
+        payload["cancel_reason"] = from === "billing_issue" ? "BILLING_ERROR" : "UNSUBSCRIBE";
+        break;
+      case "BILLING_ISSUE":
+        payload["grace_period_expiration_at_ms"] = d.gracePeriodExpirationAtMs;
+        break;
+      case "EXPIRATION":
+        payload["expiration_reason"] = from === "billing_issue" ? "BILLING_ERROR" : "UNSUBSCRIBE";
+        break;
+      default:
+        break;
+    }
+    return payload;
+  }
+};
+
+// src/core/engine.ts
+function createSimulation(opts, seed, startAt) {
+  const clock4 = VirtualClock.forSeed(seed, startAt);
+  const subscriber = new Subscriber(opts, { clock: clock4, rng: createRng(seed) });
+  return { clock: clock4, subscriber };
+}
+function applyStep(sim, step) {
+  if (step.advance !== void 0) {
+    sim.clock.advance(step.advance);
+    return void 0;
+  }
+  return sim.subscriber.emit(step.event, step.set ?? {});
+}
+function spanOf(steps, fromMs) {
+  let t = fromMs;
+  for (const s of steps) if (s.advance !== void 0) t = addDuration(t, parseDuration(s.advance));
+  return t - fromMs;
+}
+function preludeFor(type) {
+  const ip = { event: "INITIAL_PURCHASE" };
+  switch (type) {
+    case "TEST":
+    case "INITIAL_PURCHASE":
+      return [];
+    case "RENEWAL":
+    case "BILLING_ISSUE":
+      return [ip, { advance: "P1M" }];
+    case "CANCELLATION":
+      return [ip, { advance: "P10D" }];
+    case "UNCANCELLATION":
+      return [ip, { advance: "P10D" }, { event: "CANCELLATION" }, { advance: "P1D" }];
+    case "EXPIRATION":
+      return [ip, { advance: "P10D" }, { event: "CANCELLATION" }, { advance: "P21D" }];
+  }
+}
+var sleep = (ms2) => new Promise((r) => setTimeout(r, ms2));
+function subscriberOptions(scenario) {
+  const s = scenario.subscriber;
+  return {
+    appUserId: s.app_user_id,
+    productId: s.product_id,
+    period: s.period,
+    trial: s.trial,
+    gracePeriod: s.grace_period,
+    store: s.store,
+    environment: s.environment
+  };
+}
+function stepLabel(index, source) {
+  const pos = source?.stepPositions[index];
+  return pos ? `step ${index + 1} (${source.file}:${pos.line})` : `step ${index + 1}`;
+}
+async function runScenario(scenario, opts) {
+  const sim = createSimulation(subscriberOptions(scenario), opts.seed);
+  const startedMs = sim.clock.now();
+  const events = [];
+  let delivered = 0;
+  for (const [index, step] of scenario.steps.entries()) {
+    if (step.advance !== void 0) {
+      sim.clock.advance(step.advance);
+      continue;
+    }
+    if (delivered > 0 && opts.speed !== "instant") await sleep(opts.speed);
+    let event;
+    try {
+      event = sim.subscriber.emit(step.event, step.set ?? {});
+    } catch (err) {
+      if (err instanceof RccError) {
+        throw new RccError(`${stepLabel(index, opts.source)}: ${err.message}`, {
+          ...err.hint === void 0 ? {} : { hint: err.hint },
+          exitCode: err.exitCode,
+          cause: err
+        });
+      }
+      throw err;
+    }
+    const envelope = { api_version: "1.0", event };
+    let status = null;
+    let latencyMs = null;
+    if (!opts.dryRun) {
+      const res = await postEvent(opts.to, envelope, { authHeader: opts.authHeader });
+      status = res.status;
+      latencyMs = res.latencyMs;
+    }
+    delivered++;
+    const result = { step: index, type: event.type, virtualTime: new Date(sim.clock.now()).toISOString(), status, latencyMs, event };
+    events.push(result);
+    opts.onEvent?.(result, envelope);
+  }
+  const endedMs = sim.clock.now();
+  const expectations = evaluateExpectations(scenario, events);
+  const allDelivered = events.every((e) => e.status === null || e.status >= 200 && e.status < 300);
+  return {
+    scenario: scenario.name,
+    seed: opts.seed ?? null,
+    startedAt: new Date(startedMs).toISOString(),
+    endedAt: new Date(endedMs).toISOString(),
+    virtualSpanMs: endedMs - startedMs,
+    events,
+    expectations,
+    ok: allDelivered && expectations.every((e) => e.ok)
+  };
+}
+var SKIPPED = "skipped";
+function evaluateExpectations(scenario, events) {
+  const out = [];
+  const label = (e) => `step ${e.step + 1} ${e.type}`;
+  for (const e of events) {
+    const want = scenario.steps[e.step]?.expect?.response_status;
+    if (want === void 0) continue;
+    const skipped = e.status === null;
+    out.push({
+      scope: "step",
+      step: e.step,
+      rule: "response_status",
+      expected: String(want),
+      actual: skipped ? SKIPPED : String(e.status),
+      ok: skipped || e.status === want
+    });
+  }
+  const all = scenario.expect?.all_responses_status;
+  if (all !== void 0) {
+    const offenders = events.filter((e) => e.status !== null && e.status !== all);
+    const skipped = events.every((e) => e.status === null);
+    out.push({
+      scope: "scenario",
+      step: null,
+      rule: "all_responses_status",
+      expected: String(all),
+      actual: skipped ? SKIPPED : offenders.length === 0 ? String(all) : offenders.map((e) => `${e.status} (${label(e)})`).join(", "),
+      ok: skipped || offenders.length === 0
+    });
+  }
+  const max = scenario.expect?.max_response_ms;
+  if (max !== void 0) {
+    const measured = events.filter((e) => e.latencyMs !== null);
+    const slowest = measured.reduce((acc, e) => acc === void 0 || e.latencyMs > acc.latencyMs ? e : acc, void 0);
+    const skipped = slowest === void 0;
+    out.push({
+      scope: "scenario",
+      step: null,
+      rule: "max_response_ms",
+      expected: `\u2264 ${max} ms`,
+      actual: skipped ? SKIPPED : `${slowest.latencyMs} ms (${label(slowest)})`,
+      ok: skipped || slowest.latencyMs <= max
+    });
+  }
+  return out;
+}
+
+// src/core/io.ts
+var defaultIo = { stdout: process.stdout, stderr: process.stderr };
+var println = (w, s = "") => {
+  w.write(s + "\n");
+};
+
+// src/commands/send.ts
+function parseSetFlag(pairs) {
+  const out = {};
+  for (const pair of pairs) {
+    const eq = pair.indexOf("=");
+    if (eq <= 0) {
+      throw new RccError(`Invalid --set "${pair}": expected key=value.`, {
+        hint: "Example: --set price=4.99 --set subscriber_attributes.plan.value=pro"
+      });
+    }
+    const key = pair.slice(0, eq);
+    const raw = pair.slice(eq + 1);
+    let value = raw;
+    try {
+      value = JSON.parse(raw);
+    } catch {
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function parseEventType(input) {
+  const upper = input.toUpperCase();
+  if (EVENT_TYPES.includes(upper)) return upper;
+  throw new RccError(`Unknown event type "${input}". Valid types: ${EVENT_TYPES.join(", ")}.`, {
+    hint: "Example: rcc send INITIAL_PURCHASE"
+  });
+}
+function parseEnvironment(input) {
+  if (ENVIRONMENTS.includes(input)) return input;
+  throw new RccError(`Invalid --environment "${input}". Use one of: ${ENVIRONMENTS.join(", ")}.`);
+}
+function parseStore(input) {
+  if (CLI_STORES.includes(input)) return input;
+  throw new RccError(`Unsupported --store "${input}". v0.1 supports: ${CLI_STORES.join(", ")}.`, {
+    hint: "Other stores are on the roadmap (see docs/BACKLOG.md \u2192 Icebox)."
+  });
+}
+function parseSeed(input) {
+  if (input === void 0) return void 0;
+  return /^\d+$/.test(input) ? Number(input) : input;
+}
+function buildSingleEvent(type, opts) {
+  const seed = parseSeed(opts.seed);
+  const prelude = preludeFor(type);
+  const subscriberOpts = {
+    appUserId: opts.user ?? "auto",
+    productId: opts.product,
+    period: "P1M",
+    store: parseStore(opts.store ?? "app_store"),
+    environment: parseEnvironment(opts.environment ?? "SANDBOX")
+  };
+  const startAt = seed === void 0 ? Date.now() - spanOf(prelude, Date.now()) : void 0;
+  const sim = createSimulation(subscriberOpts, seed, startAt);
+  for (const step of prelude) applyStep(sim, step);
+  const event = sim.subscriber.emit(type, parseSetFlag(opts.set ?? []));
+  return { api_version: "1.0", event };
+}
+function registerSend(program, io) {
+  program.command("send").argument("<EVENT_TYPE>", `event to send: ${EVENT_TYPES.join(" | ")}`).description("Send a single, schema-valid RevenueCat webhook event to your endpoint.").option("--to <url>", `target URL (default: ${DEFAULT_TARGET}, or "to" in ${CONFIG_FILE})`).option("--store <store>", `store: ${CLI_STORES.join(" | ")} (default: app_store, or "store" in ${CONFIG_FILE})`).option("--user <app_user_id>", "app_user_id (default: generated $RCAnonymousID)").option("--product <product_id>", "product_id", "com.example.premium.monthly").option("--auth-header <value>", `value sent as the Authorization header (default: "authHeader" in ${CONFIG_FILE})`).option("--environment <env>", `${ENVIRONMENTS.join(" | ")} (default: SANDBOX, or "environment" in ${CONFIG_FILE})`).option("--set <key=value>", "override a payload field (repeatable, dot paths allowed)", (v, acc) => [...acc ?? [], v]).option("--seed <seed>", "deterministic ids and timestamps").option("--dry-run", "print the payload instead of sending it").addHelpText("after", `
+Examples:
+  $ rcc send INITIAL_PURCHASE
+  $ rcc send RENEWAL --to http://localhost:8787/webhook --auth-header "Bearer dev"
+  $ rcc send CANCELLATION --set cancel_reason=BILLING_ERROR --dry-run | jq .event.type`).action(async (eventType2, opts) => {
+    const type = parseEventType(eventType2);
+    const d = resolveDefaults(opts, loadConfig());
+    const to = assertUrl(d.to, "--to");
+    const envelope = buildSingleEvent(type, { ...opts, to, store: d.store, environment: d.environment, authHeader: d.authHeader });
+    if (opts.dryRun) {
+      println(io.stdout, JSON.stringify(envelope, null, 2));
+      return;
+    }
+    const res = await postEvent(to, envelope, { authHeader: d.authHeader });
+    const ok = res.status >= 200 && res.status < 300;
+    const mark = ok ? green("\u2714") : red("\u2716");
+    println(io.stdout, `${mark} ${type.padEnd(16)} \u2192 ${to}  ${res.status}  ${dim(`(${res.latencyMs} ms)`)}`);
+    if (!ok) {
+      throw new RccError(`Endpoint answered ${res.status} for ${type}.`, {
+        hint: "RevenueCat treats anything other than 200 as a failure and retries. Check your handler logs."
+      });
+    }
+  });
+}
+
+// src/commands/listen.ts
+import { createServer } from "http";
+var DEFAULT_PORT = 8787;
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    req.on("data", (c) => raw += c.toString("utf8"));
+    req.on("end", () => resolve(raw));
+    req.on("error", reject);
+  });
+}
+function json(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+var clock = () => (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+async function startListener(opts) {
+  const { io } = opts;
+  const log = (s) => println(io.stdout, s);
+  const server = createServer((req, res) => {
+    void handle(req, res);
+  });
+  async function handle(req, res) {
+    if (req.method !== "POST") {
+      json(res, 404, { error: `Use POST to deliver webhook events (got ${req.method ?? "?"} ${req.url ?? ""}).` });
+      return;
+    }
+    const raw = await readBody(req);
+    const time = dim(clock());
+    if (opts.authHeader !== void 0 && req.headers["authorization"] !== opts.authHeader) {
+      log(`${time}  ${red(bold("AUTH MISMATCH"))}  Authorization header ${req.headers["authorization"] === void 0 ? "missing" : "does not match --auth-header"}  \u2192 401`);
+      json(res, 401, { error: "Authorization header mismatch" });
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      log(`${time}  ${red(bold("INVALID"))}  body is not JSON  \u2192 400`);
+      json(res, 400, { error: "Body is not valid JSON" });
+      return;
+    }
+    const classified = classifyEnvelope(parsed);
+    if (classified.kind === "invalid") {
+      const issues = classified.issues.map((i) => ({ path: i.path || "(root)", message: i.message }));
+      const shown = issues.slice(0, 3).map((i) => `${i.path}: ${i.message}`).join("; ");
+      const more = issues.length > 3 ? ` (+${issues.length - 3} more)` : "";
+      log(`${time}  ${red(bold("INVALID"))}  ${shown}${more}  \u2192 400`);
+      if (opts.verbose) log(dim(JSON.stringify(parsed, null, 2)));
+      json(res, 400, { error: "Invalid RevenueCat webhook envelope", issues });
+      return;
+    }
+    const ev = classified.envelope.event;
+    const typeLabel = classified.kind === "known" ? cyan(bold(ev.type.padEnd(16))) : `${yellow(bold("UNSUPPORTED"))} ${yellow(ev.type)}`;
+    let status = 200;
+    let suffix = "";
+    if (opts.forward !== void 0) {
+      try {
+        const headers = { "content-type": "application/json" };
+        const auth = req.headers["authorization"];
+        if (auth !== void 0) headers["authorization"] = auth;
+        const started = performance.now();
+        const upstream = await fetch(opts.forward, { method: "POST", headers, body: raw, signal: AbortSignal.timeout(3e4) });
+        status = upstream.status;
+        suffix = `  ${dim("\u2192 forwarded")} ${opts.forward} ${status < 300 ? green(String(status)) : red(String(status))} ${dim(`(${Math.round(performance.now() - started)} ms)`)}`;
+      } catch (err) {
+        status = 502;
+        suffix = `  ${red("forward failed")}: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+    const statusText = status < 300 ? green(String(status)) : red(String(status));
+    const productId = typeof ev["product_id"] === "string" ? ev["product_id"] : "";
+    log(`${time}  ${typeLabel} ${yellow(ev.app_user_id)}  ${productId}  \u2192 ${statusText}${suffix}`);
+    if (opts.verbose) log(dim(JSON.stringify(classified.envelope, null, 2)));
+    json(res, status, { ok: status < 300 });
+  }
+  await new Promise((resolve, reject) => {
+    server.once("error", (err) => {
+      reject(
+        err.code === "EADDRINUSE" ? new RccError(`Port ${opts.port} is already in use.`, { hint: `Pick another one: rcc listen --port ${opts.port + 1}` }) : new RccError(`Could not start the listener: ${err.message}`, { cause: err })
+      );
+    });
+    server.listen(opts.port, () => resolve());
+  });
+  const port = server.address().port;
+  const url = `http://localhost:${port}/webhook`;
+  log(`${green("\u25CF")} Listening on ${bold(url)}`);
+  if (opts.authHeader !== void 0) log(dim(`  expecting Authorization: ${opts.authHeader}`));
+  if (opts.forward !== void 0) log(dim(`  forwarding to ${opts.forward}`));
+  log(dim(`  try: rcc send INITIAL_PURCHASE --to ${url}`));
+  return {
+    url,
+    port,
+    close: () => new Promise((resolve, reject) => {
+      server.closeAllConnections();
+      server.close((err) => err ? reject(err) : resolve());
+    })
+  };
+}
+function registerListen(program, io) {
+  program.command("listen").description("Start a local HTTP server that receives, validates and pretty-prints webhook events.").option("--port <n>", "port to listen on", String(DEFAULT_PORT)).option("--forward <url>", "forward each request (body + Authorization) to this URL and relay its status").option("--auth-header <value>", "expected Authorization header; mismatches are flagged and answered 401").option("--verbose", "print the full JSON payload of each event").addHelpText("after", `
+Examples:
+  $ rcc listen
+  $ rcc listen --port 9000 --auth-header "Bearer dev" --verbose
+  $ rcc listen --forward http://localhost:3000/webhook`).action(async (opts) => {
+    if (!/^\d{1,5}$/.test(opts.port) || Number(opts.port) > 65535) {
+      throw new RccError(`Invalid --port "${opts.port}".`, { hint: "Use an integer between 1 and 65535." });
+    }
+    if (opts.forward !== void 0) assertUrl(opts.forward, "--forward");
+    const listener = await startListener({ ...opts, port: Number(opts.port), io });
+    const stop = () => {
+      void listener.close().finally(() => process.exit(0));
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    await new Promise(() => {
+    });
+  });
+}
+
+// src/core/output.ts
+function humanDays(ms2) {
+  return `${Math.round(ms2 / 864e5)}d`;
+}
+var RUN_HEADERS = ["#", "event", "virtual time", "status", "latency"];
+function createRunTable(scenario) {
+  const eventCount = scenario.steps.filter((s) => s.event !== void 0).length;
+  const eventTypes = scenario.steps.map((s) => s.event ?? "");
+  const widths = [
+    Math.max(RUN_HEADERS[0].length, String(eventCount).length),
+    Math.max(RUN_HEADERS[1].length, ...eventTypes.map((t) => t.length)),
+    Math.max(RUN_HEADERS[2].length, "2025-01-01T00:00:00.000Z".length),
+    RUN_HEADERS[3].length,
+    Math.max(RUN_HEADERS[4].length, "99999 ms".length)
+  ];
+  const pad = (cells, colour) => cells.map((c, i) => {
+    const padded = i === 0 ? c.padStart(widths[i]) : c.padEnd(widths[i]);
+    return colour ? colour(padded, i) : padded;
+  }).join("  ").trimEnd();
+  return {
+    header: () => dim(pad(RUN_HEADERS)),
+    row: (e, index) => pad(
+      [String(index + 1), e.type, e.virtualTime, e.status === null ? "\u2014" : String(e.status), e.latencyMs === null ? "\u2014" : `${e.latencyMs} ms`],
+      (cell, col) => {
+        if (col !== 3) return cell;
+        if (e.status === null) return dim(cell);
+        return e.status >= 200 && e.status < 300 ? green(cell) : red(cell);
+      }
+    )
+  };
+}
+function renderRunSummary(result) {
+  const total = result.events.length;
+  const okCount = result.events.filter((e) => e.status !== null && e.status >= 200 && e.status < 300).length;
+  const failed = result.events.filter((e) => e.status !== null && !(e.status >= 200 && e.status < 300)).length;
+  const span = `${humanDays(result.virtualSpanMs)} (${result.startedAt.slice(0, 10)} \u2192 ${result.endedAt.slice(0, 10)})`;
+  const counts = result.events.some((e) => e.status === null) ? `${total} events \xB7 dry run` : `${total} events \xB7 ${okCount} ok \xB7 ${failed} failed`;
+  const exps = result.expectations;
+  const expText = exps.length ? ` \xB7 ${exps.filter((e) => e.ok).length}/${exps.length} expectations passed` : "";
+  const mark = result.ok ? green("\u2714") : red("\u2716");
+  return `${mark} ${bold(counts)} \xB7 virtual span ${span}${expText}`;
+}
+function renderFailedExpectations(result) {
+  return result.expectations.filter((e) => !e.ok).map((e) => {
+    const where = e.scope === "step" ? `step ${e.step + 1} ${result.events.find((ev) => ev.step === e.step)?.type ?? ""}` : "scenario";
+    return `${red("\u2716")} expectation failed \xB7 ${where} \xB7 ${e.rule}: expected ${e.expected}, got ${e.actual}`;
+  });
+}
+
+// src/core/scenario.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { LineCounter, isMap, isNode, parseDocument } from "yaml";
+import { z as z3 } from "zod";
+var duration = z3.string().superRefine((val, ctx) => {
+  try {
+    parseDuration(val);
+  } catch {
+    ctx.addIssue({ code: "custom", message: `Invalid ISO-8601 duration: "${val}". Examples: P1M, P1W, P3D, PT12H.` });
+  }
+});
+var list = (values) => values.join(", ");
+var eventType = z3.enum(EVENT_TYPES, {
+  error: (iss) => `Unknown event type "${String(iss.input)}". Valid types: ${list(EVENT_TYPES)}.`
+});
+var httpStatus = z3.int({ error: "response_status must be an integer HTTP status (e.g. 200)." }).min(100).max(599);
+var SubscriberConfigSchema = z3.strictObject({
+  app_user_id: z3.string().min(1).default("auto"),
+  product_id: z3.string().min(1).default("com.example.premium.monthly"),
+  period: duration.default("P1M"),
+  trial: duration.optional(),
+  grace_period: duration.default("P16D"),
+  store: z3.enum(CLI_STORES, {
+    error: (iss) => `Unsupported store "${String(iss.input)}". v0.1 supports: ${list(CLI_STORES)}.`
+  }).default("app_store"),
+  environment: z3.enum(ENVIRONMENTS, {
+    error: (iss) => `Invalid environment "${String(iss.input)}". Use one of: ${list(ENVIRONMENTS)}.`
+  }).default("SANDBOX")
+});
+var StepExpectSchema = z3.strictObject({ response_status: httpStatus });
+var SetSchema = z3.record(z3.string(), z3.union([z3.string(), z3.number(), z3.boolean(), z3.null()]));
+var RawStepSchema = z3.strictObject({
+  event: eventType.optional(),
+  advance: duration.optional(),
+  set: SetSchema.optional(),
+  expect: StepExpectSchema.optional()
+});
+var StepSchema = RawStepSchema.superRefine((step, ctx) => {
+  const hasEvent = step.event !== void 0;
+  const hasAdvance = step.advance !== void 0;
+  if (hasEvent === hasAdvance) {
+    ctx.addIssue({
+      code: "custom",
+      message: "A step must have exactly one of `event: <TYPE>` or `advance: <duration>`."
+    });
+    return;
+  }
+  if (hasAdvance && (step.set !== void 0 || step.expect !== void 0)) {
+    ctx.addIssue({ code: "custom", message: "`set` and `expect` are only allowed on `event` steps." });
+  }
+});
+var ScenarioExpectSchema = z3.strictObject({
+  all_responses_status: httpStatus.optional(),
+  max_response_ms: z3.int().positive({ error: "max_response_ms must be a positive integer (milliseconds)." }).optional()
+});
+var ScenarioSchema = z3.strictObject({
+  name: z3.string({ error: "`name` is required." }).regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/, "name may only contain letters, digits, '.', '_' and '-'."),
+  description: z3.string().optional(),
+  subscriber: SubscriberConfigSchema.default({
+    app_user_id: "auto",
+    product_id: "com.example.premium.monthly",
+    period: "P1M",
+    grace_period: "P16D",
+    store: "app_store",
+    environment: "SANDBOX"
+  }),
+  steps: z3.array(StepSchema).min(1, "`steps` must contain at least one step."),
+  expect: ScenarioExpectSchema.optional()
+});
+var ScenarioValidationError = class extends RccError {
+  file;
+  line;
+  column;
+  path;
+  constructor(opts) {
+    const where = opts.path === "" ? "" : `${opts.path}: `;
+    super(`${opts.file}:${opts.line}:${opts.column} \u2014 ${where}${opts.detail}`, {
+      hint: opts.hint ?? "See the scenario format in the README or run `rcc init` for working examples."
+    });
+    this.name = "ScenarioValidationError";
+    this.file = opts.file;
+    this.line = opts.line;
+    this.column = opts.column;
+    this.path = opts.path;
+  }
+};
+function dotted(path) {
+  return path.reduce((acc, seg) => {
+    if (typeof seg === "number") return `${acc}[${seg}]`;
+    return acc === "" ? String(seg) : `${acc}.${String(seg)}`;
+  }, "");
+}
+function locate(doc, counter, path, keyName) {
+  const segs = path.filter((s) => typeof s !== "symbol");
+  for (let depth = segs.length; depth >= 0; depth--) {
+    const sub = segs.slice(0, depth);
+    const node = sub.length === 0 ? doc.contents : doc.getIn(sub, true);
+    if (!isNode(node)) continue;
+    if (keyName !== void 0 && depth === segs.length && isMap(node)) {
+      const pair = node.items.find((p) => isNode(p.key) && String(p.key.toJSON()) === keyName);
+      const keyNode = pair?.key;
+      if (isNode(keyNode) && keyNode.range) return toPos(counter, keyNode.range[0]);
+    }
+    if (node.range) return toPos(counter, node.range[0]);
+  }
+  return { line: 1, column: 1 };
+}
+function toPos(counter, offset) {
+  const { line, col } = counter.linePos(offset);
+  return { line, column: col };
+}
+function parseScenarioWithSource(text, file = "<inline>") {
+  const counter = new LineCounter();
+  const doc = parseDocument(text, { lineCounter: counter, keepSourceTokens: true });
+  const syntax = doc.errors[0];
+  if (syntax) {
+    const pos2 = syntax.linePos?.[0];
+    throw new ScenarioValidationError({
+      file,
+      line: pos2?.line ?? 1,
+      column: pos2?.col ?? 1,
+      path: "",
+      detail: `YAML syntax error: ${syntax.message.split("\n")[0] ?? syntax.code}`
+    });
+  }
+  const result = ScenarioSchema.safeParse(doc.toJS() ?? {});
+  if (result.success) {
+    const stepPositions = result.data.steps.map((_, i) => locate(doc, counter, ["steps", i]));
+    return { scenario: result.data, file, stepPositions };
+  }
+  const issue = result.error.issues[0];
+  const keyName = issue.code === "unrecognized_keys" ? issue.keys[0] : void 0;
+  const pos = locate(doc, counter, issue.path, keyName);
+  const detail = issue.code === "unrecognized_keys" ? `Unknown key${issue.keys.length > 1 ? "s" : ""} ${issue.keys.map((k) => `"${k}"`).join(", ")}.` : issue.code === "invalid_type" && issue.input === void 0 ? `Missing required field \`${String(issue.path.at(-1) ?? "")}\`.` : issue.message;
+  throw new ScenarioValidationError({ file, line: pos.line, column: pos.column, path: dotted(issue.path), detail });
+}
+function loadScenarioWithSource(file) {
+  let text;
+  try {
+    text = readFileSync2(file, "utf8");
+  } catch (cause) {
+    throw new RccError(`Scenario file not found: ${file}`, {
+      hint: "Check the path, or run `rcc init` to create a scenarios/ folder with examples.",
+      cause
+    });
+  }
+  return parseScenarioWithSource(text, file);
+}
+
+// src/commands/run.ts
+function parseSpeed(input) {
+  if (input === "instant") return "instant";
+  const n = Number(input);
+  if (Number.isInteger(n) && n >= 0) return n;
+  throw new RccError(`Invalid --speed "${input}": use \`instant\` or a number of milliseconds between events (e.g. --speed 500).`);
+}
+function registerRun(program, io) {
+  program.command("run").argument("<scenario.yaml>", "scenario file to execute").description("Run a scenario: advance a virtual clock, emit a coherent event sequence and deliver it over HTTP.").option("--to <url>", `target URL (default: ${DEFAULT_TARGET}, or "to" in ${CONFIG_FILE})`).option("--auth-header <value>", `value sent as the Authorization header (default: "authHeader" in ${CONFIG_FILE})`).option("--speed <instant|ms>", "wall-clock pause between events", "instant").option("--seed <seed>", "deterministic ids and timestamps").option("--dry-run", "print each envelope as JSON (one per line) instead of sending").option("--json", "print the full run result as one JSON document on stdout (human output goes to stderr)").addHelpText("after", `
+Examples:
+  $ rcc run scenarios/trial-churns.yaml
+  $ rcc run scenarios/happy-year.yaml --to http://localhost:8787/webhook --speed 250
+  $ rcc run scenarios/billing-issue-recovers.yaml --dry-run --seed 42 | jq .event.type
+  $ rcc run scenarios/happy-year.yaml --json > result.json   # CI: exit 1 on any failed expectation`).action(async (file, opts) => {
+    const d = resolveDefaults(opts, loadConfig());
+    const to = assertUrl(d.to, "--to");
+    const speed = parseSpeed(opts.speed);
+    const loaded = loadScenarioWithSource(file);
+    const human = opts.dryRun || opts.json ? io.stderr : io.stdout;
+    const desc = loaded.scenario.description ? ` \u2014 ${loaded.scenario.description}` : "";
+    println(human, `\u25B6 ${bold(loaded.scenario.name)}${dim(desc)}`);
+    const live = createRunTable(loaded.scenario);
+    println(human, live.header());
+    let index = 0;
+    const result = await runScenario(loaded.scenario, {
+      to,
+      authHeader: d.authHeader,
+      speed,
+      seed: parseSeed(opts.seed),
+      dryRun: opts.dryRun ?? false,
+      source: loaded,
+      onEvent: (r, envelope) => {
+        println(human, live.row(r, index++));
+        if (opts.dryRun && !opts.json) println(io.stdout, JSON.stringify(envelope));
+      }
+    });
+    for (const line of renderFailedExpectations(result)) println(human, line);
+    println(human, renderRunSummary(result));
+    if (opts.json) println(io.stdout, JSON.stringify(result, null, 2));
+    if (!result.ok) {
+      const failedExp = result.expectations.filter((e) => !e.ok).length;
+      throw new RccError(
+        failedExp > 0 ? `Scenario finished with ${failedExp} failed expectation${failedExp === 1 ? "" : "s"}.` : "Scenario finished with failed deliveries.",
+        { hint: "Every event must be answered with a 2xx status and every expect: block must hold. Check your handler logs, or run with --dry-run to inspect payloads." }
+      );
+    }
+  });
+}
+
+// src/commands/init.ts
+import { copyFileSync, existsSync as existsSync2, mkdirSync, readdirSync, writeFileSync } from "fs";
+import { join as join2, relative } from "path";
+function initProject(cwd, opts) {
+  const scenariosSrc = join2(packageRoot(), "scenarios");
+  const examples = readdirSync(scenariosSrc).filter((f) => f.endsWith(".yaml")).sort();
+  const targets = [CONFIG_FILE, ...examples.map((f) => join2("scenarios", f))];
+  const existing = targets.filter((t) => existsSync2(join2(cwd, t)));
+  if (existing.length > 0 && !opts.force) {
+    throw new RccError(`Refusing to overwrite existing file${existing.length === 1 ? "" : "s"}: ${existing.join(", ")}`, {
+      hint: "Run `rcc init --force` to overwrite, or delete them first."
+    });
+  }
+  const written = [];
+  const config = { to: DEFAULT_TARGET, store: "app_store", environment: "SANDBOX" };
+  writeFileSync(join2(cwd, CONFIG_FILE), JSON.stringify(config, null, 2) + "\n");
+  written.push(CONFIG_FILE);
+  mkdirSync(join2(cwd, "scenarios"), { recursive: true });
+  for (const f of examples) {
+    copyFileSync(join2(scenariosSrc, f), join2(cwd, "scenarios", f));
+    written.push(join2("scenarios", f));
+  }
+  return written;
+}
+function registerInit(program, io) {
+  program.command("init").description(`Create ${CONFIG_FILE} and a scenarios/ folder with the six example scenarios in the current directory.`).option("--force", "overwrite existing files").addHelpText("after", `
+Examples:
+  $ rcc init
+  $ rcc init --force`).action((opts) => {
+    const cwd = process.cwd();
+    const written = initProject(cwd, opts);
+    println(io.stdout, `${green("\u2714")} Created ${written.length} files in ${bold(relative(process.cwd(), cwd) || ".")}:`);
+    for (const f of written) println(io.stdout, `  ${dim("+")} ${f}`);
+    println(io.stdout, "");
+    println(io.stdout, `Next: start your webhook handler (or \`rcc listen\`), then run`);
+    println(io.stdout, `  ${bold("rcc run scenarios/trial-churns.yaml")}`);
+    println(io.stdout, dim(`Defaults (target URL, auth header, store, environment) live in ${CONFIG_FILE}.`));
+  });
+}
+
+// src/commands/tail.ts
+var SMEE_ORIGIN = "https://smee.io";
+async function* parseSseStream(source) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let cur = { data: [] };
+  const flush = () => {
+    if (cur.data.length === 0) {
+      cur = { data: [] };
+      return void 0;
+    }
+    const frame = { data: cur.data.join("\n") };
+    if (cur.id !== void 0) frame.id = cur.id;
+    if (cur.event !== void 0) frame.event = cur.event;
+    cur = { data: [] };
+    return frame;
+  };
+  for await (const chunk of source) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let nl;
+    while ((nl = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, nl).replace(/\r$/, "");
+      buffer = buffer.slice(nl + 1);
+      if (line === "") {
+        const f = flush();
+        if (f) yield f;
+        continue;
+      }
+      if (line.startsWith(":")) continue;
+      const colon = line.indexOf(":");
+      const field = colon === -1 ? line : line.slice(0, colon);
+      const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+      if (field === "data") cur.data.push(value);
+      else if (field === "id") cur.id = value;
+      else if (field === "event") cur.event = value;
+    }
+  }
+  const last = flush();
+  if (last) yield last;
+}
+async function createSmeeChannel(origin = SMEE_ORIGIN) {
+  let res;
+  try {
+    res = await fetch(`${origin}/new`, { redirect: "manual", signal: AbortSignal.timeout(15e3) });
+  } catch (cause) {
+    throw new RccError(`Could not reach ${origin} to create a channel.`, {
+      hint: "Check your connection, or pass an existing channel: rcc tail --smee https://smee.io/<channel>",
+      cause
+    });
+  }
+  const location = res.headers.get("location");
+  if (!location) throw new RccError(`${origin}/new did not return a channel URL (HTTP ${res.status}).`);
+  return new URL(location, origin).toString();
+}
+function fromInbox(data) {
+  let rec;
+  try {
+    rec = JSON.parse(data);
+  } catch {
+    return void 0;
+  }
+  if (typeof rec.body !== "string") return void 0;
+  let body = rec.body;
+  try {
+    body = JSON.parse(rec.body);
+  } catch {
+  }
+  return { headers: rec.headers ?? {}, body, raw: rec.body, timestamp: rec.receivedAt ? Date.parse(rec.receivedAt) : void 0 };
+}
+function fromSmee(data) {
+  let obj;
+  try {
+    obj = JSON.parse(data);
+  } catch {
+    return void 0;
+  }
+  if (typeof obj !== "object" || obj === null) return void 0;
+  const { body, query: _q, timestamp, ...rest } = obj;
+  const headers = {};
+  for (const [k, v] of Object.entries(rest)) if (typeof v === "string") headers[k.toLowerCase()] = v;
+  return { headers, body, timestamp: typeof timestamp === "number" ? timestamp : void 0 };
+}
+var clock2 = (ms2) => new Date(ms2 ?? Date.now()).toISOString().slice(11, 19);
+var sleep2 = (ms2, signal) => new Promise((resolve) => {
+  if (signal.aborted) return resolve();
+  const t = setTimeout(resolve, ms2);
+  signal.addEventListener("abort", () => (clearTimeout(t), resolve()), { once: true });
+});
+function startTail(opts) {
+  const { io } = opts;
+  const log = (s) => println(io.stdout, s);
+  const controller = new AbortController();
+  const backoff = opts.backoffMs ?? [1e3, 2e3, 5e3, 1e4, 3e4];
+  const src = opts.source;
+  const streamUrl = () => {
+    if (src.kind === "smee") return src.url;
+    const u = new URL("/events/stream", src.url.endsWith("/") ? src.url : src.url + "/");
+    if (src.since !== void 0) u.searchParams.set("since", String(src.since));
+    return u.toString();
+  };
+  const streamHeaders = () => src.kind === "inbox" ? { accept: "text/event-stream", authorization: `Bearer ${src.token}` } : { accept: "text/event-stream" };
+  log(`${green("\u25CF")} Tailing ${bold(opts.source.url)}`);
+  if (opts.source.kind === "smee") {
+    log(`  Paste this URL in RevenueCat \u2192 Integrations \u2192 Webhooks: ${cyan(opts.source.url)}`);
+    log(dim("  smee.io is a public relay with no persistence: events only arrive while this command is running."));
+  }
+  if (opts.forward) log(dim(`  forwarding each event to ${opts.forward}`));
+  async function handle(req) {
+    const time = dim(clock2(req.timestamp));
+    const classified = classifyEnvelope(req.body);
+    let label;
+    if (classified.kind === "invalid") {
+      const issues = classified.issues.slice(0, 3).map((i) => `${i.path}: ${i.message}`).join("; ");
+      label = `${red(bold("INVALID"))}  ${issues}`;
+    } else {
+      const ev = classified.envelope.event;
+      const productId = typeof ev["product_id"] === "string" ? ev["product_id"] : "";
+      const typeLabel = classified.kind === "known" ? cyan(bold(ev.type.padEnd(16))) : `${yellow(bold("UNSUPPORTED"))} ${yellow(ev.type)}`;
+      label = `${typeLabel} ${yellow(ev.app_user_id)}  ${productId}`;
+    }
+    let suffix = "";
+    if (opts.forward) {
+      try {
+        const headers = { "content-type": "application/json" };
+        const auth = req.headers["authorization"];
+        if (auth !== void 0) headers["authorization"] = auth;
+        const started = performance.now();
+        const res = await fetch(opts.forward, {
+          method: "POST",
+          headers,
+          body: req.raw ?? JSON.stringify(req.body),
+          signal: AbortSignal.timeout(3e4)
+        });
+        const status = res.status < 300 ? green(String(res.status)) : red(String(res.status));
+        suffix = `  \u2192 ${status} ${dim(`(${Math.round(performance.now() - started)} ms)`)}`;
+      } catch (err) {
+        suffix = `  ${red("forward failed")}: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+    log(`${time}  ${magenta("real")}  ${label}${suffix}`);
+    if (opts.verbose) log(dim(JSON.stringify(req.body, null, 2)));
+  }
+  async function loop() {
+    let attempt = 0;
+    while (!controller.signal.aborted) {
+      try {
+        const res = await fetch(streamUrl(), { headers: streamHeaders(), signal: controller.signal });
+        if (res.status === 401) {
+          throw new RccError(`The inbox at ${src.url} rejected the token (401).`, { hint: "Check --token against the inbox's --token / INBOX_TOKEN." });
+        }
+        if (!res.ok || !res.body) throw new Error(`HTTP ${res.status}`);
+        attempt = 0;
+        for await (const frame of parseSseStream(res.body)) {
+          if (frame.event === "ready" || frame.data === "{}") continue;
+          const req = src.kind === "inbox" ? fromInbox(frame.data) : fromSmee(frame.data);
+          if (req) await handle(req);
+        }
+        if (controller.signal.aborted) return;
+        throw new Error("stream ended");
+      } catch (err) {
+        if (controller.signal.aborted) return;
+        const delay = backoff[Math.min(attempt, backoff.length - 1)];
+        attempt++;
+        const reason = err instanceof RccError ? `${err.message} ${err.hint ?? ""}` : err instanceof Error ? err.message : String(err);
+        log(`${dim(clock2())}  ${yellow("reconnecting")} in ${delay} ms ${dim(`(${reason.trim()})`)}`);
+        await sleep2(delay, controller.signal);
+      }
+    }
+  }
+  const done = loop();
+  return {
+    done,
+    close: async () => {
+      controller.abort();
+      await done.catch(() => void 0);
+    }
+  };
+}
+function registerTail(program, io) {
+  program.command("tail").description("Receive real RevenueCat webhooks on your machine through a relay, print them, and optionally forward them to a local URL.").option("--smee [channel-url]", "use the public smee.io relay; creates a channel when no URL is given").option("--inbox <url>", "use a self-hosted `rcc inbox` at this URL (requires --token)").option("--token <secret>", "read token of the inbox").option("--since <seq>", "inbox only: replay stored events after this sequence number (0 = everything)").option("--all", "inbox only: replay the whole history (same as --since 0)").option("--forward <url>", "re-POST each event (body + Authorization) to this local URL").option("--verbose", "print the full JSON payload of each event").addHelpText("after", `
+Examples:
+  $ rcc tail --smee                                   # prints a URL to paste in RevenueCat \u2192 Integrations \u2192 Webhooks
+  $ rcc tail --smee https://smee.io/abc123 --forward http://localhost:3000/webhook
+  $ rcc tail --smee --verbose
+  $ rcc tail --inbox https://hooks.example.com --token s3cret --all --forward http://localhost:3000/webhook`).action(async (opts) => {
+    if (opts.smee !== void 0 && opts.inbox !== void 0) {
+      throw new RccError("Use either --smee or --inbox, not both.");
+    }
+    if (opts.smee === void 0 && opts.inbox === void 0) {
+      throw new RccError("rcc tail needs a source.", {
+        hint: "Use --smee to receive events through smee.io (zero setup), or --inbox <url> --token <t> for a self-hosted inbox."
+      });
+    }
+    if (opts.forward !== void 0) assertUrl(opts.forward, "--forward");
+    let source;
+    if (opts.inbox !== void 0) {
+      if (!opts.token) throw new RccError("--inbox requires --token.", { hint: "The token is the inbox's --token / INBOX_TOKEN." });
+      const since = opts.all ? 0 : opts.since !== void 0 ? Number(opts.since) : void 0;
+      if (since !== void 0 && (!Number.isInteger(since) || since < 0)) throw new RccError(`Invalid --since "${opts.since ?? ""}".`);
+      source = { kind: "inbox", url: assertUrl(opts.inbox, "--inbox"), token: opts.token, since };
+    } else {
+      const url = typeof opts.smee === "string" ? assertUrl(opts.smee, "--smee") : await createSmeeChannel();
+      source = { kind: "smee", url };
+    }
+    const handle = startTail({ source, forward: opts.forward, verbose: opts.verbose, io });
+    const stop = () => {
+      void handle.close().finally(() => process.exit(0));
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    await handle.done;
+  });
+}
+
+// src/commands/inbox.ts
+import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { createServer as createServer2 } from "http";
+import { join as join3 } from "path";
+var DEFAULT_INBOX_PORT = 8788;
+var EVENTS_FILE = "events.jsonl";
+var KEPT_HEADERS = ["authorization", "content-type", "user-agent", "x-revenuecat-webhook-signature"];
+var Store = class {
+  constructor(dir, maxEvents) {
+    this.dir = dir;
+    this.maxEvents = maxEvents;
+    mkdirSync2(dir, { recursive: true });
+    this.file = join3(dir, EVENTS_FILE);
+    if (existsSync3(this.file)) {
+      for (const line of readFileSync3(this.file, "utf8").split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          this.records.push(JSON.parse(line));
+        } catch {
+        }
+      }
+      this.lastSeq = this.records.at(-1)?.seq ?? 0;
+      if (this.records.length > this.maxEvents) this.compact();
+    }
+  }
+  dir;
+  maxEvents;
+  records = [];
+  lastSeq = 0;
+  file;
+  nextSeq() {
+    return ++this.lastSeq;
+  }
+  add(rec) {
+    this.records.push(rec);
+    appendFileSync(this.file, JSON.stringify(rec) + "\n");
+    if (this.records.length > this.maxEvents) this.compact();
+  }
+  compact() {
+    this.records = this.records.slice(-this.maxEvents);
+    writeFileSync2(this.file, this.records.map((r) => JSON.stringify(r)).join("\n") + "\n");
+  }
+  since(seq, limit) {
+    return this.records.filter((r) => r.seq > seq).slice(0, limit);
+  }
+  findByEventId(id) {
+    return this.records.find((r) => r.eventId === id);
+  }
+  get count() {
+    return this.records.length;
+  }
+};
+function readBody2(req) {
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    req.on("data", (c) => raw += c.toString("utf8"));
+    req.on("end", () => resolve(raw));
+    req.on("error", reject);
+  });
+}
+function json2(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+var clock3 = () => (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+async function startInbox(opts) {
+  if (!opts.token) {
+    throw new RccError("rcc inbox needs a read token.", {
+      hint: "Pass --token <secret> (or set INBOX_TOKEN). Clients read events with `rcc tail --inbox <url> --token <secret>`."
+    });
+  }
+  const { io } = opts;
+  const log = (s) => println(io.stdout, s);
+  const store = new Store(opts.dataDir, opts.maxEvents ?? 1e4);
+  const streams = /* @__PURE__ */ new Set();
+  const authorized = (req, url2) => req.headers["authorization"] === `Bearer ${opts.token}` || url2.searchParams.get("token") === opts.token;
+  const server = createServer2((req, res) => {
+    void handle(req, res);
+  });
+  async function handle(req, res) {
+    const url2 = new URL(req.url ?? "/", "http://inbox");
+    const path = url2.pathname;
+    if (req.method === "GET" && path === "/health") {
+      json2(res, 200, { ok: true, events: store.count });
+      return;
+    }
+    if (req.method === "POST" && path === "/webhook") {
+      await receive(req, res);
+      return;
+    }
+    if (req.method === "GET" && (path === "/events" || path === "/events/stream")) {
+      if (!authorized(req, url2)) {
+        json2(res, 401, { error: "Missing or invalid token. Use `Authorization: Bearer <token>` or ?token=." });
+        return;
+      }
+      const since = Number(url2.searchParams.get("since") ?? (path === "/events" ? "0" : String(store.count === 0 ? 0 : store.since(0, Infinity).at(-1).seq)));
+      if (path === "/events") {
+        const limit = Math.min(Number(url2.searchParams.get("limit") ?? "100"), 1e3);
+        const events = store.since(since, limit);
+        json2(res, 200, { events, next: events.at(-1)?.seq ?? since });
+        return;
+      }
+      res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
+      res.write(`event: ready
+data: {}
+
+`);
+      for (const rec of store.since(since, Infinity)) res.write(`id: ${rec.seq}
+event: webhook
+data: ${JSON.stringify(rec)}
+
+`);
+      streams.add(res);
+      const ping = setInterval(() => res.write(": ping\n\n"), 25e3);
+      res.on("close", () => {
+        clearInterval(ping);
+        streams.delete(res);
+      });
+      return;
+    }
+    json2(res, 404, { error: `Not found. Endpoints: POST /webhook, GET /events, GET /events/stream, GET /health.` });
+  }
+  async function receive(req, res) {
+    const raw = await readBody2(req);
+    const headers = {};
+    for (const h of KEPT_HEADERS) {
+      const v = req.headers[h];
+      if (typeof v === "string") headers[h] = v;
+    }
+    const authOk = opts.authHeader === void 0 || headers["authorization"] === opts.authHeader;
+    let parsed;
+    let isJson = true;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      isJson = false;
+    }
+    const rec = { seq: store.nextSeq(), receivedAt: (/* @__PURE__ */ new Date()).toISOString(), headers, body: raw, valid: false, authOk };
+    let status;
+    let label;
+    if (!isJson) {
+      status = 400;
+      label = `${red(bold("INVALID"))}  body is not JSON`;
+    } else {
+      const classified = classifyEnvelope(parsed);
+      if (classified.kind !== "invalid") {
+        const ev = classified.envelope.event;
+        rec.valid = true;
+        rec.eventId = ev.id;
+        rec.eventType = ev.type;
+        if (classified.kind === "unknown-type") rec.unsupportedType = true;
+        const dup = store.findByEventId(rec.eventId);
+        if (dup) rec.duplicateOf = dup.seq;
+        const typeLabel = classified.kind === "known" ? cyan(bold(ev.type.padEnd(16))) : `${yellow(bold("UNSUPPORTED"))} ${yellow(ev.type)}`;
+        label = `${typeLabel} ${yellow(ev.app_user_id)}${dup ? dim(`  (retry of #${dup.seq})`) : ""}`;
+      } else {
+        rec.issues = classified.issues;
+        label = `${red(bold("INVALID"))}  ${rec.issues.slice(0, 3).map((i) => `${i.path}: ${i.message}`).join("; ")}`;
+      }
+      status = authOk ? 200 : 401;
+    }
+    if (!authOk) label = `${red(bold("AUTH MISMATCH"))}  ${label}`;
+    store.add(rec);
+    for (const s of streams) s.write(`id: ${rec.seq}
+event: webhook
+data: ${JSON.stringify(rec)}
+
+`);
+    log(`${dim(clock3())}  #${rec.seq}  ${label}  \u2192 ${status < 300 ? green(String(status)) : red(String(status))}`);
+    json2(res, status, status === 400 ? { error: "Body is not valid JSON" } : status === 401 ? { error: "Authorization header mismatch" } : { ok: true, seq: rec.seq });
+  }
+  await new Promise((resolve, reject) => {
+    server.once("error", (err) => {
+      reject(
+        err.code === "EADDRINUSE" ? new RccError(`Port ${opts.port} is already in use.`, { hint: `Pick another one: rcc inbox --port ${opts.port + 1}` }) : new RccError(`Could not start the inbox: ${err.message}`, { cause: err })
+      );
+    });
+    server.listen(opts.port, () => resolve());
+  });
+  const port = server.address().port;
+  const url = `http://localhost:${port}`;
+  log(`${green("\u25CF")} Inbox listening on ${bold(url)} \u2014 ${store.count} stored event${store.count === 1 ? "" : "s"} in ${opts.dataDir}`);
+  log(dim(`  RevenueCat \u2192 POST ${url}/webhook${opts.authHeader === void 0 ? "  (no --auth-header: accepting any Authorization)" : ""}`));
+  log(dim(`  you       \u2192 rcc tail --inbox <public-url> --token <token>`));
+  return {
+    url,
+    port,
+    get subscribers() {
+      return streams.size;
+    },
+    close: () => new Promise((resolve, reject) => {
+      for (const s of streams) s.destroy();
+      server.closeAllConnections();
+      server.close((err) => err ? reject(err) : resolve());
+    })
+  };
+}
+function registerInbox(program, io) {
+  program.command("inbox").description("Run a self-hosted webhook inbox: stores every delivery (JSONL) and streams it to `rcc tail --inbox`. Put HTTPS in front.").option("--port <n>", "port to listen on (env PORT)", process.env["PORT"] ?? String(DEFAULT_INBOX_PORT)).option("--token <secret>", "bearer token clients need to read events (env INBOX_TOKEN)", process.env["INBOX_TOKEN"]).option("--auth-header <value>", "Authorization value RevenueCat must send; mismatches stored and answered 401 (env RC_WEBHOOK_AUTH)", process.env["RC_WEBHOOK_AUTH"]).option("--data-dir <dir>", "where events.jsonl lives (env INBOX_DATA_DIR)", process.env["INBOX_DATA_DIR"] ?? "./inbox-data").option("--max-events <n>", "keep only the newest N events", "10000").addHelpText("after", `
+Examples:
+  $ rcc inbox --token s3cret --auth-header "Bearer from-dashboard"
+  $ INBOX_TOKEN=s3cret PORT=8080 rcc inbox --data-dir /data`).action(async (opts) => {
+    if (!/^\d{1,5}$/.test(opts.port) || Number(opts.port) > 65535) {
+      throw new RccError(`Invalid --port "${opts.port}".`, { hint: "Use an integer between 1 and 65535." });
+    }
+    const maxEvents = Number(opts.maxEvents);
+    if (!Number.isInteger(maxEvents) || maxEvents < 1) throw new RccError(`Invalid --max-events "${opts.maxEvents}".`);
+    const box = await startInbox({ port: Number(opts.port), token: opts.token ?? "", authHeader: opts.authHeader, dataDir: opts.dataDir, maxEvents, io });
+    const stop = () => {
+      void box.close().finally(() => process.exit(0));
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    await new Promise(() => {
+    });
+  });
+}
+
+// src/program.ts
+var USAGE_EXIT_CODE = 2;
+function buildProgram(io = defaultIo) {
+  const program = new Command();
+  program.name("rcc").description(
+    "Simulate RevenueCat subscription lifecycles and test webhooks locally and in CI.\nUnofficial project \u2014 not affiliated with RevenueCat, Inc."
+  ).version(package_default.version, "-v, --version", "print the version").exitOverride((err) => {
+    if (err.exitCode !== 0) err.exitCode = USAGE_EXIT_CODE;
+    throw err;
+  });
+  registerSend(program, io);
+  registerListen(program, io);
+  registerRun(program, io);
+  registerInit(program, io);
+  registerTail(program, io);
+  registerInbox(program, io);
+  for (const cmd of [program, ...program.commands]) {
+    const label = cmd === program ? "rcc" : `rcc ${cmd.name()}`;
+    cmd.configureOutput({
+      writeOut: (s) => io.stdout.write(s),
+      writeErr: (s) => io.stderr.write(s),
+      outputError: (str, write) => {
+        const message = str.trim().replace(/^error:\s*/i, "");
+        write(formatError(new RccError(message, { hint: `Run \`${label} --help\` for usage.`, exitCode: USAGE_EXIT_CODE })) + "\n");
+      }
+    });
+  }
+  return program;
+}
+
+// src/cli.ts
+buildProgram().parseAsync(process.argv).catch((err) => {
+  if (err instanceof CommanderError) {
+    process.exitCode = err.exitCode;
+    return;
+  }
+  process.stderr.write(formatError(err) + "\n");
+  process.exitCode = exitCodeFor(err);
+});
+//# sourceMappingURL=cli.js.map