gatefit 0.0.0-stage → 0.4.0

package/src/cli.ts

@@ -0,0 +1,163 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { loadAdapter } from "./access-adapter.ts";
+import { listGoldens, loadGolden, requireReset, runGolden } from "./fixture-driver.ts";
+import { LIVE_SCENARIO_IDS, runLiveLane, type LiveScenarioId } from "./live-scenarios.ts";
+import { ensureProLicense } from "./license.ts";
+import { getProPack, isProPack } from "./packs.ts";
+import { goldenDir, packageRoot, readPackageVersion, resolveUserOrPackage, userCwd } from "./paths.ts";
+import {
+  createStripeClockClient,
+  requireLiveClockEnabled,
+  requireTestModeSecret,
+} from "./stripe-clock.ts";
+
+const S1 = () => path.join(goldenDir(), "paid_grants_access.yaml");
+const NAIVE = () => path.join(packageRoot(), "src/adapters/naive.ts");
+const HARDENED = () => path.join(packageRoot(), "src/adapters/hardened.ts");
+
+function usage(): string {
+  return [
+    "Usage:",
+    "  gatefit run --suite <dir|file|id> --adapter <path>",
+    "  gatefit adapter-check",
+    "  gatefit live --adapter <path> [--scenario <id>]",
+    "  gatefit --version",
+  ].join("\n");
+}
+
+function resolveSuiteFiles(suite: string): string[] {
+  const candidates = [
+    path.resolve(userCwd(), suite),
+    path.resolve(packageRoot(), suite),
+    path.join(goldenDir(), `${suite}.yaml`),
+  ];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    const files = listGoldens(candidate);
+    if (files.length > 0) return files;
+  }
+  throw new Error(`suite not found: ${suite}`);
+}
+
+async function cmdRun(suite: string, adapterPath: string): Promise<number> {
+  if (isProPack(suite)) {
+    const gate = await ensureProLicense();
+    if (!gate.ok) {
+      console.error(gate.message);
+      return 1;
+    }
+    if (gate.warning) console.error(gate.warning);
+    const pack = getProPack(suite);
+    if (pack?.run) return pack.run({ adapterPath });
+    console.error(`gatefit: PASS ${suite}`);
+    return 0;
+  }
+  const adapter = await loadAdapter(resolveUserOrPackage(adapterPath));
+  const files = resolveSuiteFiles(suite);
+  if (files.length === 0) {
+    throw new Error(`suite not found: ${suite}`);
+  }
+  requireReset(adapter, files.length);
+  let failed = 0;
+  for (const file of files) {
+    const golden = loadGolden(file);
+    const result = await runGolden(adapter, golden);
+    if (result.ok) {
+      console.error(`gatefit: PASS ${golden.id}`);
+    } else {
+      failed += 1;
+      console.error(`gatefit: FAIL ${golden.id}`);
+      for (const step of result.results.filter((s) => !s.ok)) {
+        console.error(`  step ${step.stepIndex}: ${step.mismatches.join("; ")}`);
+      }
+    }
+  }
+  return failed === 0 ? 0 : 1;
+}
+
+async function cmdAdapterCheck(): Promise<number> {
+  const suite = loadGolden(S1());
+  const naive = await runGolden(await loadAdapter(NAIVE()), suite);
+  const hardened = await runGolden(await loadAdapter(HARDENED()), suite);
+  const naiveFailed = !naive.ok;
+  const hardenedPassed = hardened.ok;
+  if (naiveFailed) console.error("gatefit adapter-check: naive failed S1 (expected)");
+  else console.error("gatefit adapter-check: naive unexpectedly passed S1");
+  if (hardenedPassed) console.error("gatefit adapter-check: hardened passed S1 (expected)");
+  else console.error("gatefit adapter-check: hardened failed S1");
+  return naiveFailed && hardenedPassed ? 0 : 1;
+}
+
+function isVersionFlag(arg: string | undefined): boolean {
+  return arg === "--version" || arg === "-v";
+}
+
+async function main(argv: string[]): Promise<number> {
+  if (isVersionFlag(argv[0])) {
+    console.log(`gatefit ${readPackageVersion()}`);
+    return 0;
+  }
+  const command = argv[0];
+  if (command === "adapter-check") {
+    return cmdAdapterCheck();
+  }
+  if (command === "run") {
+    const { values } = parseArgs({
+      args: argv.slice(1),
+      options: {
+        suite: { type: "string" },
+        adapter: { type: "string" },
+      },
+    });
+    if (!values.suite || !values.adapter) {
+      console.error(usage());
+      return 1;
+    }
+    return cmdRun(values.suite, values.adapter);
+  }
+  if (command === "live") {
+    const { values } = parseArgs({
+      args: argv.slice(1),
+      options: {
+        adapter: { type: "string" },
+        scenario: { type: "string" },
+      },
+    });
+    if (!values.adapter) {
+      console.error(usage());
+      return 1;
+    }
+    requireLiveClockEnabled();
+    const secret = requireTestModeSecret();
+    const adapter = await loadAdapter(resolveUserOrPackage(values.adapter));
+    const client = createStripeClockClient({ secret });
+    let scenarios: LiveScenarioId[] | undefined;
+    if (values.scenario) {
+      if (!(LIVE_SCENARIO_IDS as readonly string[]).includes(values.scenario)) {
+        throw new Error(`unknown live scenario: ${values.scenario}`);
+      }
+      scenarios = [values.scenario as LiveScenarioId];
+    }
+    const result = await runLiveLane(adapter, client, { scenarios });
+    for (const row of result.results) {
+      if (row.ok) console.error(`gatefit live: PASS ${row.id}`);
+      else {
+        console.error(`gatefit live: FAIL ${row.id}`);
+        for (const mismatch of row.mismatches) console.error(`  ${mismatch}`);
+      }
+    }
+    return result.ok ? 0 : 1;
+  }
+  console.error(usage());
+  return 1;
+}
+
+try {
+  const code = await main(process.argv.slice(2));
+  process.exit(code);
+} catch (err) {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+}

package/src/clock-driver.ts

@@ -0,0 +1,52 @@
+import {
+  assertAdvanceWithinTwoIntervals,
+  MONTH_SECONDS,
+  type StripeClockClient,
+  type TestClock,
+} from "./stripe-clock.ts";
+
+export type ClockWaitOpts = {
+  sleep?: (ms: number) => Promise<void>;
+  timeoutMs?: number;
+  intervalMs?: number;
+};
+
+export async function withTestClock<T>(
+  client: StripeClockClient,
+  input: { frozenTime: number; name?: string },
+  fn: (clock: TestClock) => Promise<T>,
+): Promise<T> {
+  const clock = await client.createClock(input);
+  try {
+    return await fn(clock);
+  } finally {
+    const deleted = await client.deleteClock(clock.id);
+    if (!deleted?.deleted) {
+      throw new Error(`clock leak: failed to delete ${clock.id}`);
+    }
+  }
+}
+
+export async function advanceUntilReady(
+  client: StripeClockClient,
+  clockId: string,
+  frozenTime: number,
+  opts: ClockWaitOpts = {},
+): Promise<TestClock> {
+  const current = await client.retrieveClock(clockId);
+  assertAdvanceWithinTwoIntervals(current.frozen_time, frozenTime, MONTH_SECONDS);
+  await client.advanceClock(clockId, frozenTime);
+  const sleep = opts.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+  const timeoutMs = opts.timeoutMs ?? 120_000;
+  const intervalMs = opts.intervalMs ?? 500;
+  const deadline = Date.now() + timeoutMs;
+  let clock = await client.retrieveClock(clockId);
+  while (clock.status !== "ready") {
+    if (Date.now() > deadline) {
+      throw new Error(`clock ${clockId} did not become ready before timeout`);
+    }
+    await sleep(intervalMs);
+    clock = await client.retrieveClock(clockId);
+  }
+  return clock;
+}

package/src/fixture-driver.ts

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import {
+  type AccessAdapter,
+  type AccessSnapshot,
+  type BillingEvent,
+  compareAccess,
+} from "./access-adapter.ts";
+
+export type GoldenStep = {
+  event: BillingEvent;
+  expect: AccessSnapshot;
+};
+
+export type GoldenSuite = {
+  id: string;
+  subject: string;
+  steps: GoldenStep[];
+};
+
+export type StepResult = {
+  stepIndex: number;
+  ok: boolean;
+  expected: AccessSnapshot;
+  actual: AccessSnapshot;
+  mismatches: string[];
+};
+
+export function loadGolden(filePath: string): GoldenSuite {
+  const raw = fs.readFileSync(filePath, "utf8");
+  const data = parseYaml(raw) as GoldenSuite;
+  if (!data?.id || !data.subject || !Array.isArray(data.steps) || data.steps.length === 0) {
+    throw new Error(`invalid golden: ${filePath} (id, subject, and non-empty steps required)`);
+  }
+  return data;
+}
+
+export function requireReset(adapter: AccessAdapter, suiteCount: number): void {
+  if (suiteCount > 1 && typeof adapter.reset !== "function") {
+    throw new Error("adapter.reset is required when running more than one golden");
+  }
+}
+
+export function listGoldens(suitePath: string): string[] {
+  const resolved = path.resolve(suitePath);
+  const stat = fs.statSync(resolved);
+  if (stat.isDirectory()) {
+    return fs
+      .readdirSync(resolved)
+      .filter((name) => name.endsWith(".yaml") || name.endsWith(".yml"))
+      .map((name) => path.join(resolved, name))
+      .sort();
+  }
+  return [resolved];
+}
+
+export async function runGolden(
+  adapter: AccessAdapter,
+  suite: GoldenSuite,
+): Promise<{
+  ok: boolean;
+  results: StepResult[];
+}> {
+  if (process.env.GATEFIT_LIVE_CLOCK) {
+    throw new Error("fixture-first driver refuses GATEFIT_LIVE_CLOCK; use YAML step order only");
+  }
+  if (adapter.reset) await adapter.reset();
+  const results: StepResult[] = [];
+  for (let i = 0; i < suite.steps.length; i += 1) {
+    const step = suite.steps[i]!;
+    await adapter.apply(step.event);
+    const actual = await adapter.snapshot(step.event.customerId ?? suite.subject);
+    const cmp = compareAccess(actual, step.expect);
+    results.push({
+      stepIndex: i,
+      ok: cmp.ok,
+      expected: step.expect,
+      actual,
+      mismatches: cmp.mismatches,
+    });
+  }
+  return { ok: results.every((r) => r.ok), results };
+}

package/src/license.ts

@@ -0,0 +1,160 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/** Public Polar customer-portal validate endpoint. No API token. */
+export const POLAR_LICENSE_VALIDATE_URL =
+  "https://api.polar.sh/v1/customer-portal/license-keys/validate";
+
+/** Gatefit organization id from the public Indie License checkout. */
+export const POLAR_ORGANIZATION_ID = "68556619-45ab-4a88-8ad8-08606c2b820e";
+
+/** Indie License benefit id. Scopes validation to that benefit. */
+export const POLAR_BENEFIT_ID = "4e8e6528-a979-4060-b675-7686c752a4a2";
+
+export const LICENSE_BUY_URL = "https://gatefit.io/#pricing";
+
+/** Fresh cache entries skip the network. Older entries still count when Polar is down. */
+export const LICENSE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+
+const KEY_PREFIX = "GATEFIT-";
+
+export type LicenseDecision =
+  | { ok: true; warning?: string }
+  | { ok: false; message: string };
+
+type CacheEntry = { granted: true; cachedAt: number };
+type CacheFile = { v: 1; entries: Record<string, CacheEntry> };
+
+function buy(reason: string): string {
+  return `gatefit: ${reason} Buy the Indie License: ${LICENSE_BUY_URL}`;
+}
+
+function cachePath(env: NodeJS.ProcessEnv): string {
+  return env.GATEFIT_LICENSE_CACHE ?? path.join(os.homedir(), ".gatefit", "license-cache.json");
+}
+
+function hashKey(key: string): string {
+  return createHash("sha256").update(key).digest("hex");
+}
+
+function emptyCache(): CacheFile {
+  return { v: 1, entries: {} };
+}
+
+function readCache(file: string): CacheFile {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8")) as CacheFile;
+    if (parsed?.v !== 1 || !parsed.entries || typeof parsed.entries !== "object") return emptyCache();
+    return parsed;
+  } catch {
+    return emptyCache();
+  }
+}
+
+function writeCache(file: string, cache: CacheFile): void {
+  const dir = path.dirname(file);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const tmp = path.join(dir, `.license-cache-${process.pid}.tmp`);
+  fs.writeFileSync(tmp, JSON.stringify(cache), { mode: 0o600 });
+  fs.renameSync(tmp, file);
+  fs.chmodSync(file, 0o600);
+}
+
+function remember(file: string, key: string): void {
+  const cache = readCache(file);
+  cache.entries[hashKey(key)] = { granted: true, cachedAt: Date.now() };
+  writeCache(file, cache);
+}
+
+function forget(file: string, key: string): void {
+  const cache = readCache(file);
+  delete cache.entries[hashKey(key)];
+  try {
+    writeCache(file, cache);
+  } catch {
+    /* a failed delete must not print the key */
+  }
+}
+
+function cachedGrant(file: string, key: string): CacheEntry | undefined {
+  const entry = readCache(file).entries[hashKey(key)];
+  if (!entry || entry.granted !== true || typeof entry.cachedAt !== "number") return undefined;
+  return entry;
+}
+
+function validateUrl(env: NodeJS.ProcessEnv): string {
+  return env.GATEFIT_LICENSE_VALIDATE_URL || POLAR_LICENSE_VALIDATE_URL;
+}
+
+type PolarVerdict = "granted" | "revoked" | "invalid" | "unreachable";
+
+async function askPolar(key: string, env: NodeJS.ProcessEnv): Promise<PolarVerdict> {
+  try {
+    const response = await fetch(validateUrl(env), {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json" },
+      body: JSON.stringify({
+        key,
+        organization_id: POLAR_ORGANIZATION_ID,
+        benefit_id: POLAR_BENEFIT_ID,
+      }),
+      signal: AbortSignal.timeout(4000),
+    });
+    const text = await response.text();
+    let payload: { status?: unknown; error?: unknown; detail?: unknown } = {};
+    try {
+      payload = JSON.parse(text) as typeof payload;
+    } catch {
+      return response.status >= 500 ? "unreachable" : "invalid";
+    }
+    const status = typeof payload.status === "string" ? payload.status : "";
+    const detail = `${payload.error ?? ""} ${payload.detail ?? ""}`;
+    if (response.status >= 500) return "unreachable";
+    if (status === "granted" && response.ok) return "granted";
+    if (status === "revoked" || /revok/i.test(detail)) return "revoked";
+    if (response.status === 404) return "invalid";
+    return "invalid";
+  } catch {
+    return "unreachable";
+  }
+}
+
+export async function ensureProLicense(env: NodeJS.ProcessEnv = process.env): Promise<LicenseDecision> {
+  const key = env.GATEFIT_LICENSE_KEY?.trim() ?? "";
+  if (!key) {
+    return { ok: false, message: buy("Pro pack requires GATEFIT_LICENSE_KEY.") };
+  }
+  if (!key.startsWith(KEY_PREFIX)) {
+    return { ok: false, message: buy("GATEFIT_LICENSE_KEY is not valid.") };
+  }
+
+  const file = cachePath(env);
+  const cached = cachedGrant(file, key);
+  if (cached && Date.now() - cached.cachedAt < LICENSE_CACHE_TTL_MS) {
+    return { ok: true };
+  }
+
+  const verdict = await askPolar(key, env);
+  if (verdict === "granted") {
+    try {
+      remember(file, key);
+    } catch {
+      /* running does not depend on writing the cache */
+    }
+    return { ok: true };
+  }
+  if (verdict === "revoked") {
+    forget(file, key);
+    return { ok: false, message: buy("GATEFIT_LICENSE_KEY is revoked.") };
+  }
+  if (verdict === "invalid") {
+    forget(file, key);
+    return { ok: false, message: buy("GATEFIT_LICENSE_KEY is not valid.") };
+  }
+  if (cached) {
+    return { ok: true, warning: "gatefit: Polar license check unreachable; using cached valid result" };
+  }
+  return { ok: true, warning: "gatefit: Polar license check unreachable; running without a cached license" };
+}

package/src/live-scenarios.ts

@@ -0,0 +1,191 @@
+import type { AccessAdapter, AccessSnapshot, BillingEvent } from "./access-adapter.ts";
+import { compareAccess } from "./access-adapter.ts";
+import { advanceUntilReady, withTestClock, type ClockWaitOpts } from "./clock-driver.ts";
+import {
+  MAX_CUSTOMERS_PER_CLOCK,
+  MAX_SUBSCRIPTIONS_PER_CLOCK,
+  type StripeClockClient,
+  type StripeInvoice,
+  type StripeSubscription,
+} from "./stripe-clock.ts";
+
+export const LIVE_SCENARIO_IDS = [
+  "paid_grants_access",
+  "cancel_revokes_access",
+  "trial_to_paid_grants",
+] as const;
+
+export type LiveScenarioId = (typeof LIVE_SCENARIO_IDS)[number];
+
+export type LiveScenarioResult = {
+  id: LiveScenarioId;
+  ok: boolean;
+  mismatches: string[];
+  customerId?: string;
+};
+
+export function billingEventsFromStripe(input: {
+  customerId: string;
+  plan: string;
+  subscription: StripeSubscription;
+  invoices: StripeInvoice[];
+  stripeHttpStatus?: number;
+  now?: number;
+}): BillingEvent[] {
+  void input.stripeHttpStatus;
+  const events: BillingEvent[] = [];
+  const quantity = input.subscription.items?.data?.[0]?.quantity;
+  if (input.subscription.status === "trialing") {
+    events.push({
+      id: `${input.subscription.id}:trialing`,
+      type: "customer.subscription.updated",
+      customerId: input.customerId,
+      status: "trialing",
+      plan: input.plan,
+    });
+    return events;
+  }
+  for (const invoice of input.invoices) {
+    if (invoice.paid === true || invoice.status === "paid") {
+      events.push({
+        id: invoice.id,
+        type: "invoice.paid",
+        customerId: input.customerId,
+        plan: input.plan,
+        paid: true,
+        ...(quantity !== undefined ? { seats: quantity } : {}),
+      });
+    }
+  }
+  if (input.subscription.status === "canceled" || input.subscription.status === "incomplete_expired") {
+    events.push({
+      id: `${input.subscription.id}:canceled`,
+      type: "customer.subscription.deleted",
+      customerId: input.customerId,
+      canceled: true,
+    });
+    return events;
+  }
+  if (input.subscription.cancel_at_period_end === true) {
+    events.push({
+      id: `${input.subscription.id}:cape`,
+      type: "customer.subscription.updated",
+      customerId: input.customerId,
+      plan: input.plan,
+      cancel_at_period_end: true,
+      period_end: input.subscription.current_period_end,
+      now: input.now,
+      ...(quantity !== undefined ? { seats: quantity } : {}),
+    });
+  }
+  return events;
+}
+
+export function expectedAccess(_id: LiveScenarioId, phase: "trial" | "paid" | "canceled"): AccessSnapshot {
+  if (phase === "paid") return { locked: false, plan: "pro" };
+  return { locked: true };
+}
+
+export async function runLiveLane(
+  adapter: AccessAdapter,
+  client: StripeClockClient,
+  opts: {
+    scenarios?: LiveScenarioId[];
+    now?: () => number;
+    wait?: ClockWaitOpts;
+  } = {},
+): Promise<{ ok: boolean; results: LiveScenarioResult[] }> {
+  const ids = opts.scenarios ?? [...LIVE_SCENARIO_IDS];
+  const results: LiveScenarioResult[] = [];
+  for (const id of ids) {
+    results.push(await runLiveScenario(adapter, client, id, { now: opts.now, wait: opts.wait }));
+  }
+  return { ok: results.every((row) => row.ok), results };
+}
+
+export async function runLiveScenario(
+  adapter: AccessAdapter,
+  client: StripeClockClient,
+  id: LiveScenarioId,
+  opts: { now?: () => number; wait?: ClockWaitOpts } = {},
+): Promise<LiveScenarioResult> {
+  if (!LIVE_SCENARIO_IDS.includes(id)) {
+    throw new Error(`unknown live scenario: ${id}`);
+  }
+  const frozenTime = opts.now?.() ?? Math.floor(Date.now() / 1000);
+  return withTestClock(client, { frozenTime, name: `gatefit-${id}` }, async (clock) => {
+    let customers = 0;
+    let subscriptions = 0;
+    const customer = await client.createCustomer({ testClock: clock.id });
+    customers += 1;
+    if (customers > MAX_CUSTOMERS_PER_CLOCK) {
+      throw new Error("too many customers on this clock");
+    }
+
+    if (id === "trial_to_paid_grants") {
+      const sub = await client.createSubscription({ customer: customer.id, trialPeriodDays: 14 });
+      subscriptions += 1;
+      assertSubCap(subscriptions);
+      await applyAndCheck(adapter, client, customer.id, sub, expectedAccess(id, "trial"), {
+        now: clock.frozen_time,
+      });
+      const ready = await advanceUntilReady(client, clock.id, frozenTime + 15 * 24 * 60 * 60, opts.wait);
+      const after = await client.retrieveSubscription(sub.id);
+      return applyAndCheck(adapter, client, customer.id, after, expectedAccess(id, "paid"), {
+        id,
+        now: ready.frozen_time,
+      });
+    }
+
+    const sub = await client.createSubscription({ customer: customer.id });
+    subscriptions += 1;
+    assertSubCap(subscriptions);
+    if (id === "paid_grants_access") {
+      return applyAndCheck(adapter, client, customer.id, sub, expectedAccess(id, "paid"), {
+        id,
+        now: clock.frozen_time,
+      });
+    }
+    await applyAndCheck(adapter, client, customer.id, sub, expectedAccess(id, "paid"), {
+      now: clock.frozen_time,
+    });
+    const canceled = await client.cancelSubscription(sub.id);
+    return applyAndCheck(adapter, client, customer.id, canceled, expectedAccess(id, "canceled"), {
+      id,
+      now: clock.frozen_time,
+    });
+  });
+}
+
+function assertSubCap(subscriptions: number): void {
+  if (subscriptions > MAX_SUBSCRIPTIONS_PER_CLOCK) {
+    throw new Error("too many subscriptions on this clock");
+  }
+}
+
+async function applyAndCheck(
+  adapter: AccessAdapter,
+  client: StripeClockClient,
+  customerId: string,
+  subscription: StripeSubscription,
+  expect: AccessSnapshot,
+  meta: { id?: LiveScenarioId; now?: number } = {},
+): Promise<LiveScenarioResult> {
+  if (adapter.reset) await adapter.reset();
+  const invoices = await client.listInvoices(customerId);
+  const events = billingEventsFromStripe({
+    customerId,
+    plan: "pro",
+    subscription,
+    invoices,
+    now: meta.now,
+  });
+  for (const event of events) await adapter.apply(event);
+  const actual = await adapter.snapshot(customerId);
+  const cmp = compareAccess(actual, expect);
+  if (!meta.id) {
+    if (!cmp.ok) throw new Error(cmp.mismatches.join("; "));
+    return { id: "paid_grants_access", ok: true, mismatches: [], customerId };
+  }
+  return { id: meta.id, ok: cmp.ok, mismatches: cmp.mismatches, customerId };
+}

package/src/packs.ts

@@ -0,0 +1,27 @@
+/**
+ * Pro pack registry. H17 plugs chaos mode in by calling `registerProPack`
+ * with a `run` function. The stub has no runner and is not a user-facing feature.
+ */
+export type ProPack = {
+  id: string;
+  run?: (ctx: { adapterPath: string }) => Promise<number>;
+};
+
+const proPacks = new Map<string, ProPack>();
+
+export function registerProPack(pack: ProPack): void {
+  if (!pack.id || proPacks.has(pack.id)) {
+    throw new Error(`pro pack id is missing or already registered: ${pack.id}`);
+  }
+  proPacks.set(pack.id, pack);
+}
+
+export function getProPack(id: string): ProPack | undefined {
+  return proPacks.get(id);
+}
+
+export function isProPack(id: string): boolean {
+  return proPacks.has(id);
+}
+
+registerProPack({ id: "pro-stub" });