@somewhatintelligent/stripe 0.0.1-beta.1783705886.297c5be

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@somewhatintelligent/stripe",
+  "version": "0.0.1-beta.1783705886.297c5be",
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apostolos-geyer/platform.git",
+    "directory": "packages/stripe"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./cli": "./src/cli.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "stripe": "^20.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "typescript": "5.9.2",
+    "vitest": "^4.1.10"
+  }
+}

package/src/catalog.ts

@@ -0,0 +1,97 @@
+/**
+ * The billing catalog: the consumer's declaration of every Stripe product
+ * and price the platform manages — the source of truth the engine
+ * (./engine.ts) reconciles a real Stripe account against, and the source
+ * the generated id module (./render.ts) is derived from.
+ *
+ * Identity model: every managed resource carries two metadata fields —
+ * `managed_by` (the catalog's `managedBy` value, so list() calls can
+ * filter to "ours" without touching unrelated resources on the account)
+ * and `config_key` (the OBJECT KEY from `products`/`prices`, never the
+ * display name). The key is the stable identity fetch/sync/validate match
+ * on, so renaming a product's `name` updates the existing Stripe resource
+ * instead of orphaning it.
+ *
+ * Prices are immutable in Stripe once created: changing `amount` or
+ * `interval` for an existing key does not update the live price — the
+ * engine reports it as drift. Bump a price by adding a new key (e.g.
+ * `member_monthly_v2`) and switching consumers to it; retire a key by
+ * moving it to `archived`, never by deleting it (see ./engine.ts).
+ */
+
+export const MANAGED_BY_KEY = "managed_by" as const;
+export const CONFIG_KEY = "config_key" as const;
+
+export type BillingInterval = "month" | "year";
+
+export interface ProductConfig {
+  name: string;
+  description: string;
+}
+
+export interface PriceConfig<PK extends string = string> {
+  /** Key of the product this price belongs to. */
+  product: PK;
+  /** Unit amount in the currency's minor unit (cents). */
+  amount: number;
+  interval: BillingInterval;
+}
+
+export interface BillingCatalog<
+  P extends Record<string, ProductConfig> = Record<string, ProductConfig>,
+  R extends Record<string, PriceConfig<Extract<keyof P, string>>> = Record<
+    string,
+    PriceConfig<Extract<keyof P, string>>
+  >,
+> {
+  /**
+   * `metadata.managed_by` marker for every resource this catalog owns
+   * (e.g. `"acme"`). Scopes the engine to this catalog's resources; two
+   * catalogs with different markers can share one Stripe account.
+   */
+  managedBy: string;
+  /** ISO currency code for every price (e.g. `"usd"`, `"cad"`). */
+  currency: string;
+  products: P;
+  prices: R;
+  /**
+   * Managed resources that intentionally remain live in Stripe after
+   * leaving the active config (immutable prices, historic products needed
+   * for invoices). The explicit escape hatch for validate's otherwise
+   * FATAL orphan detection.
+   */
+  archived?: {
+    products?: readonly string[];
+    prices?: readonly string[];
+  };
+}
+
+/**
+ * Identity helper for declaring a catalog with full key inference:
+ * price→product references are checked at the type level AND at runtime
+ * (the runtime check covers dynamically built catalogs).
+ */
+export function defineBillingCatalog<
+  const P extends Record<string, ProductConfig>,
+  const R extends Record<string, PriceConfig<Extract<keyof P, string>>>,
+>(catalog: BillingCatalog<P, R>): BillingCatalog<P, R> {
+  if (!catalog.managedBy) {
+    throw new Error("defineBillingCatalog: managedBy must be a non-empty marker string");
+  }
+  if (!catalog.currency) {
+    throw new Error("defineBillingCatalog: currency is required");
+  }
+  for (const [key, price] of Object.entries(catalog.prices)) {
+    if (!(price.product in catalog.products)) {
+      throw new Error(
+        `defineBillingCatalog: price "${key}" references unknown product "${price.product}"`,
+      );
+    }
+    if (!Number.isInteger(price.amount) || price.amount <= 0) {
+      throw new Error(
+        `defineBillingCatalog: price "${key}" amount must be a positive integer (minor units)`,
+      );
+    }
+  }
+  return catalog;
+}

package/src/cli.ts

@@ -0,0 +1,138 @@
+/**
+ * Consumer-wired billing CLI. Lives on its own subpath
+ * (`@somewhatintelligent/stripe/cli`) because it touches `node:fs` and the Stripe
+ * SDK — worker bundles import only the package root. The consumer's
+ * script is the whole integration:
+ *
+ * ```ts
+ * #!/usr/bin/env bun
+ * import { runBillingCli } from "@somewhatintelligent/stripe/cli";
+ * import { catalog } from "../src/billing.catalog";
+ * process.exit(await runBillingCli(catalog, { generatedPath: "src/billing.gen.ts" }));
+ * ```
+ *
+ * Commands:
+ * - `fetch`     read-only id lookup → writes the generated module. WITHOUT
+ *               `STRIPE_SECRET_KEY` it writes a typed stub (empty ids) and
+ *               exits 0 — the offline/agent/CI path; `--strict` makes
+ *               missing resources (or a missing key) fatal instead.
+ * - `sync`      idempotent create/update, then writes the generated module.
+ *               Requires the key. `--dry-run` reports without mutating.
+ * - `validate`  read-only drift/orphan check. Requires the key. Orphans
+ *               (live managed resources absent from the catalog) are FATAL
+ *               unless listed in `catalog.archived` — this is the CD guard.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import type { BillingCatalog } from "./catalog";
+import {
+  fetchCatalog,
+  syncCatalog,
+  validateCatalog,
+  type StripeCatalogClient,
+} from "./engine";
+import { renderCatalogModule } from "./render";
+
+export interface RunBillingCliOptions {
+  /** Where the generated id module is written, relative to cwd. */
+  generatedPath: string;
+  /** Defaults to `process.argv.slice(2)`. */
+  argv?: string[];
+  /** Defaults to `process.env.STRIPE_SECRET_KEY`. */
+  secretKey?: string;
+  /** Injectable for tests; defaults to constructing the real SDK client. */
+  client?: StripeCatalogClient;
+  /** Defaults to console. */
+  log?: (line: string) => void;
+}
+
+export async function runBillingCli(
+  catalog: BillingCatalog,
+  opts: RunBillingCliOptions,
+): Promise<number> {
+  const argv = opts.argv ?? process.argv.slice(2);
+  const log = opts.log ?? ((line: string) => console.log(line));
+  // The command is REQUIRED: defaulting would let a dropped positional
+  // (e.g. `billing.ts --dry-run` in a CD lane) silently downgrade an
+  // intended sync/validate into a read-only fetch that exits 0.
+  const command = argv.find((a) => !a.startsWith("--"));
+  if (!command) {
+    log("missing command — expected fetch | sync | validate");
+    return 1;
+  }
+  const strict = argv.includes("--strict");
+  const dryRun = argv.includes("--dry-run");
+  const secretKey = opts.secretKey ?? process.env.STRIPE_SECRET_KEY;
+  const generatedPath = path.resolve(opts.generatedPath);
+
+  const write = (content: string) => {
+    fs.mkdirSync(path.dirname(generatedPath), { recursive: true });
+    fs.writeFileSync(generatedPath, content);
+    log(`wrote ${opts.generatedPath}`);
+  };
+
+  if (!secretKey) {
+    if (command === "fetch" && !strict) {
+      // Offline mode: a keyless clone still typechecks — the module has
+      // the right key set with empty ids, and never imports the SDK.
+      log("STRIPE_SECRET_KEY not set — writing offline stub (empty ids)");
+      write(renderCatalogModule(catalog, { note: "offline stub — no STRIPE_SECRET_KEY" }));
+      return 0;
+    }
+    log(`STRIPE_SECRET_KEY is required for ${strict ? "strict " : ""}${command}`);
+    return 1;
+  }
+
+  const client =
+    opts.client ??
+    // Lazy import: the SDK loads only on the keyed path.
+    (new (await import("stripe")).default(secretKey) as unknown as StripeCatalogClient);
+
+  const liveMode = secretKey.startsWith("sk_live_");
+  if (liveMode) log("WARNING: running against a LIVE Stripe account");
+
+  switch (command) {
+    case "fetch": {
+      const { ids, missing } = await fetchCatalog(client, catalog);
+      for (const m of missing) log(`missing: ${m} (run sync to create)`);
+      if (missing.length > 0 && strict) {
+        log("strict fetch failed — resources missing");
+        return 1;
+      }
+      write(
+        renderCatalogModule(catalog, {
+          ids,
+          note: `${liveMode ? "LIVE" : "test"} mode${missing.length ? " — SOME IDS MISSING, run sync" : ""}`,
+        }),
+      );
+      return 0;
+    }
+    case "sync": {
+      const report = await syncCatalog(client, catalog, { dryRun });
+      for (const a of report.actions) {
+        log(`${a.kind}: ${a.key}${a.id ? ` (${a.id})` : ""}${a.detail ? ` — ${a.detail}` : ""}`);
+      }
+      if (dryRun) {
+        log("dry run — no writes");
+        return 0;
+      }
+      write(renderCatalogModule(catalog, { ids: report.ids, note: `${liveMode ? "LIVE" : "test"} mode` }));
+      // Drift is a warning on sync (validate is the gate) — but surface it.
+      if (report.drift.length > 0) log(`NOTE: ${report.drift.length} price(s) drifted — see validate`);
+      return 0;
+    }
+    case "validate": {
+      const report = await validateCatalog(client, catalog);
+      for (const issue of report.issues) {
+        log(`${issue.kind}: ${issue.resource} ${issue.key} — ${issue.detail}`);
+      }
+      for (const seen of report.archivedSeen) log(`archived (ok): ${seen}`);
+      log(report.ok ? "validate: ok" : `validate: FAILED (${report.issues.length} issue(s))`);
+      return report.ok ? 0 : 1;
+    }
+    default: {
+      log(`unknown command "${command}" — expected fetch | sync | validate`);
+      return 1;
+    }
+  }
+}

package/src/engine.ts

@@ -0,0 +1,300 @@
+/**
+ * Catalog reconciliation engine — pure functions over an injected Stripe
+ * client, so the whole engine tests offline against a fake and the CLI
+ * (./cli.ts) is a thin argv wrapper. Matching is by
+ * `metadata.config_key` within `metadata.managed_by === catalog.managedBy`
+ * (see ./catalog.ts for the identity model).
+ */
+import { CONFIG_KEY, MANAGED_BY_KEY, type BillingCatalog } from "./catalog";
+
+/**
+ * The slice of the Stripe SDK the engine touches. Structural so tests
+ * inject a fake; `new Stripe(key)` satisfies it.
+ */
+export interface StripeCatalogClient {
+  products: {
+    list(params: { limit: number }): Promise<{ data: StripeProductRecord[] }>;
+    create(params: {
+      name: string;
+      description: string;
+      metadata: Record<string, string>;
+    }): Promise<{ id: string }>;
+    update(id: string, params: { name: string; description: string }): Promise<unknown>;
+  };
+  prices: {
+    list(params: { limit: number }): Promise<{ data: StripePriceRecord[] }>;
+    create(params: {
+      product: string;
+      unit_amount: number;
+      currency: string;
+      recurring: { interval: "month" | "year" };
+      metadata: Record<string, string>;
+    }): Promise<{ id: string }>;
+  };
+}
+
+export interface StripeProductRecord {
+  id: string;
+  name: string;
+  description: string | null;
+  metadata: Record<string, string>;
+}
+
+export interface StripePriceRecord {
+  id: string;
+  unit_amount: number | null;
+  recurring: { interval: string } | null;
+  metadata: Record<string, string>;
+}
+
+export interface CatalogIds {
+  products: Record<string, string>;
+  prices: Record<string, string>;
+}
+
+// list() caps at 100 per page; a subscription catalog past that is a smell
+// long before it is a pagination problem, so one page is deliberate.
+const LIST_LIMIT = 100;
+
+async function listManaged(client: StripeCatalogClient, managedBy: string) {
+  const [products, prices] = await Promise.all([
+    client.products.list({ limit: LIST_LIMIT }),
+    client.prices.list({ limit: LIST_LIMIT }),
+  ]);
+  return {
+    products: products.data.filter((p) => p.metadata[MANAGED_BY_KEY] === managedBy),
+    prices: prices.data.filter((p) => p.metadata[MANAGED_BY_KEY] === managedBy),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// fetch — read-only id lookup
+// ---------------------------------------------------------------------------
+
+export interface FetchResult {
+  ids: CatalogIds;
+  /** Catalog keys with no live resource ("products.member", "prices.member_monthly"). */
+  missing: string[];
+}
+
+export async function fetchCatalog(
+  client: StripeCatalogClient,
+  catalog: BillingCatalog,
+): Promise<FetchResult> {
+  const live = await listManaged(client, catalog.managedBy);
+  const ids: CatalogIds = { products: {}, prices: {} };
+  const missing: string[] = [];
+
+  for (const key of Object.keys(catalog.products)) {
+    const found = live.products.find((p) => p.metadata[CONFIG_KEY] === key);
+    if (found) ids.products[key] = found.id;
+    else missing.push(`products.${key}`);
+  }
+  for (const key of Object.keys(catalog.prices)) {
+    const found = live.prices.find((p) => p.metadata[CONFIG_KEY] === key);
+    if (found) ids.prices[key] = found.id;
+    else missing.push(`prices.${key}`);
+  }
+  return { ids, missing };
+}
+
+// ---------------------------------------------------------------------------
+// sync — idempotent create/update
+// ---------------------------------------------------------------------------
+
+export interface SyncAction {
+  kind:
+    | "product-exists"
+    | "product-created"
+    | "product-updated"
+    | "price-exists"
+    | "price-created"
+    | "price-drift";
+  key: string;
+  id?: string;
+  detail?: string;
+}
+
+export interface SyncReport {
+  ids: CatalogIds;
+  actions: SyncAction[];
+  /** The `price-drift` subset — immutable live prices diverging from config. */
+  drift: SyncAction[];
+}
+
+export async function syncCatalog(
+  client: StripeCatalogClient,
+  catalog: BillingCatalog,
+  opts: { dryRun?: boolean } = {},
+): Promise<SyncReport> {
+  const live = await listManaged(client, catalog.managedBy);
+  const ids: CatalogIds = { products: {}, prices: {} };
+  const actions: SyncAction[] = [];
+
+  for (const [key, config] of Object.entries(catalog.products)) {
+    const existing = live.products.find((p) => p.metadata[CONFIG_KEY] === key);
+    if (existing) {
+      ids.products[key] = existing.id;
+      const stale = existing.name !== config.name || existing.description !== config.description;
+      if (stale && !opts.dryRun) {
+        await client.products.update(existing.id, {
+          name: config.name,
+          description: config.description,
+        });
+      }
+      actions.push({
+        kind: stale ? "product-updated" : "product-exists",
+        key,
+        id: existing.id,
+      });
+    } else if (opts.dryRun) {
+      actions.push({ kind: "product-created", key, detail: "dry-run" });
+    } else {
+      const created = await client.products.create({
+        name: config.name,
+        description: config.description,
+        metadata: { [MANAGED_BY_KEY]: catalog.managedBy, [CONFIG_KEY]: key },
+      });
+      ids.products[key] = created.id;
+      actions.push({ kind: "product-created", key, id: created.id });
+    }
+  }
+
+  for (const [key, config] of Object.entries(catalog.prices)) {
+    const existing = live.prices.find((p) => p.metadata[CONFIG_KEY] === key);
+    if (existing) {
+      ids.prices[key] = existing.id;
+      const matches =
+        existing.unit_amount === config.amount && existing.recurring?.interval === config.interval;
+      actions.push(
+        matches
+          ? { kind: "price-exists", key, id: existing.id }
+          : {
+              kind: "price-drift",
+              key,
+              id: existing.id,
+              detail: `config ${config.amount}/${config.interval}, live ${existing.unit_amount}/${existing.recurring?.interval}`,
+            },
+      );
+      continue;
+    }
+    if (opts.dryRun) {
+      actions.push({ kind: "price-created", key, detail: "dry-run" });
+      continue;
+    }
+    const productId = ids.products[config.product];
+    if (!productId) {
+      // Outside dry-run every product was resolved or created above, so a
+      // missing id is an invariant violation (e.g. a hand-built catalog
+      // that bypassed defineBillingCatalog) — fail, don't mislabel.
+      throw new Error(`syncCatalog: no product id for "${config.product}" (price "${key}")`);
+    }
+    const created = await client.prices.create({
+      product: productId,
+      unit_amount: config.amount,
+      currency: catalog.currency,
+      recurring: { interval: config.interval },
+      metadata: { [MANAGED_BY_KEY]: catalog.managedBy, [CONFIG_KEY]: key },
+    });
+    ids.prices[key] = created.id;
+    actions.push({ kind: "price-created", key, id: created.id });
+  }
+
+  return { ids, actions, drift: actions.filter((a) => a.kind === "price-drift") };
+}
+
+// ---------------------------------------------------------------------------
+// validate — read-only drift + orphan check (orphans are FATAL)
+// ---------------------------------------------------------------------------
+
+export interface ValidateIssue {
+  kind: "missing" | "drift" | "orphan";
+  resource: "product" | "price";
+  key: string;
+  detail: string;
+}
+
+export interface ValidateReport {
+  /** False when ANY issue exists — a CD guard that cannot fail guards nothing. */
+  ok: boolean;
+  issues: ValidateIssue[];
+  /** Archived keys seen live (informational, never an issue). */
+  archivedSeen: string[];
+}
+
+export async function validateCatalog(
+  client: StripeCatalogClient,
+  catalog: BillingCatalog,
+): Promise<ValidateReport> {
+  const live = await listManaged(client, catalog.managedBy);
+  const issues: ValidateIssue[] = [];
+  const archivedSeen: string[] = [];
+  const archivedProducts = new Set(catalog.archived?.products ?? []);
+  const archivedPrices = new Set(catalog.archived?.prices ?? []);
+
+  for (const [key, config] of Object.entries(catalog.products)) {
+    const existing = live.products.find((p) => p.metadata[CONFIG_KEY] === key);
+    if (!existing) {
+      issues.push({ kind: "missing", resource: "product", key, detail: "not found in Stripe" });
+    } else if (existing.name !== config.name || existing.description !== config.description) {
+      issues.push({
+        kind: "drift",
+        resource: "product",
+        key,
+        detail: `live name/description differ (run sync to update)`,
+      });
+    }
+  }
+
+  for (const [key, config] of Object.entries(catalog.prices)) {
+    const existing = live.prices.find((p) => p.metadata[CONFIG_KEY] === key);
+    if (!existing) {
+      issues.push({ kind: "missing", resource: "price", key, detail: "not found in Stripe" });
+    } else if (
+      existing.unit_amount !== config.amount ||
+      existing.recurring?.interval !== config.interval
+    ) {
+      issues.push({
+        kind: "drift",
+        resource: "price",
+        key,
+        detail: `config ${config.amount}/${config.interval}, live ${existing.unit_amount}/${existing.recurring?.interval} (prices are immutable — add a new key)`,
+      });
+    }
+  }
+
+  // Orphans: live managed resources whose key left the config. Fatal unless
+  // archived — Stripe resources are permanent, so a silently dropped key is
+  // an operator mistake, not cleanup.
+  // Object.hasOwn, not `in`: config_key comes from Stripe metadata, and a
+  // key like "constructor" would match Object.prototype via `in`, silently
+  // skipping the orphan check.
+  for (const p of live.products) {
+    const key = p.metadata[CONFIG_KEY];
+    if (!key || Object.hasOwn(catalog.products, key)) continue;
+    if (archivedProducts.has(key)) archivedSeen.push(`products.${key}`);
+    else {
+      issues.push({
+        kind: "orphan",
+        resource: "product",
+        key,
+        detail: `live in Stripe (${p.id}) but absent from the catalog — archive the key, don't delete it`,
+      });
+    }
+  }
+  for (const p of live.prices) {
+    const key = p.metadata[CONFIG_KEY];
+    if (!key || Object.hasOwn(catalog.prices, key)) continue;
+    if (archivedPrices.has(key)) archivedSeen.push(`prices.${key}`);
+    else {
+      issues.push({
+        kind: "orphan",
+        resource: "price",
+        key,
+        detail: `live in Stripe (${p.id}) but absent from the catalog — archive the key, don't delete it`,
+      });
+    }
+  }
+
+  return { ok: issues.length === 0, issues, archivedSeen };
+}

package/src/gate.ts

@@ -0,0 +1,14 @@
+/**
+ * The single "is Stripe wired up" predicate: both the secret key and the
+ * webhook signing secret must be present for any Stripe surface to turn
+ * on. `@somewhatintelligent/auth`'s createPlatformAuth applies the same both-present
+ * gate inline (that module carries no workspace runtime deps by design);
+ * this export is for every OTHER consumer surface (checkout server fns,
+ * webhook routes, UI flags) so the boolean is never re-derived ad hoc.
+ */
+export function stripeConfigured(
+  secretKey: string | undefined,
+  webhookSecret: string | undefined,
+): boolean {
+  return Boolean(secretKey && webhookSecret);
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+export { defineBillingCatalog, MANAGED_BY_KEY, CONFIG_KEY } from "./catalog";
+export type { BillingCatalog, BillingInterval, PriceConfig, ProductConfig } from "./catalog";
+
+export { fetchCatalog, syncCatalog, validateCatalog } from "./engine";
+export type {
+  CatalogIds,
+  FetchResult,
+  StripeCatalogClient,
+  StripePriceRecord,
+  StripeProductRecord,
+  SyncAction,
+  SyncReport,
+  ValidateIssue,
+  ValidateReport,
+} from "./engine";
+
+export { renderCatalogModule } from "./render";
+export type { RenderOptions } from "./render";
+
+export { stripeConfigured } from "./gate";

package/src/render.ts

@@ -0,0 +1,43 @@
+/**
+ * Renders the consumer's generated id module (`billing.gen.ts`) from a
+ * catalog + resolved ids. With no ids (offline / pre-sync) every id is an
+ * empty string: the module still typechecks with the right key set, and
+ * any code that actually CALLS Stripe with a stub id fails loudly at
+ * runtime instead of silently doing the wrong thing.
+ */
+import type { BillingCatalog } from "./catalog";
+import type { CatalogIds } from "./engine";
+
+export interface RenderOptions {
+  /** Resolved ids from fetch/sync; omit for the offline stub. */
+  ids?: CatalogIds;
+  /** Free-text provenance line ("test mode", "offline stub", …). */
+  note?: string;
+}
+
+export function renderCatalogModule(catalog: BillingCatalog, opts: RenderOptions = {}): string {
+  // Keys are emitted QUOTED: catalog keys are arbitrary strings (kebab-case
+  // is natural), and an unquoted non-identifier key would render a module
+  // that fails to parse.
+  const productLines = Object.keys(catalog.products)
+    .map((key) => `  ${JSON.stringify(key)}: "${opts.ids?.products[key] ?? ""}",`)
+    .join("\n");
+  const priceLines = Object.keys(catalog.prices)
+    .map((key) => `  ${JSON.stringify(key)}: "${opts.ids?.prices[key] ?? ""}",`)
+    .join("\n");
+
+  return `// AUTO-GENERATED from the billing catalog - DO NOT EDIT
+// Regenerate: run your billing script's \`fetch\` (or \`sync\`) command.
+${opts.note ? `// ${opts.note}\n` : ""}
+export const stripeProducts = {
+${productLines}
+} as const;
+
+export const stripePrices = {
+${priceLines}
+} as const;
+
+export type StripeProductId = (typeof stripeProducts)[keyof typeof stripeProducts];
+export type StripePriceId = (typeof stripePrices)[keyof typeof stripePrices];
+`;
+}

package/src/version.gen.ts

@@ -0,0 +1,7 @@
+// AUTO-STAMPED by scripts/stamp-versions.ts at release — the checked-in
+// values are dev placeholders, identical to the runtime fallbacks.
+export const PKG = {
+  name: "@somewhatintelligent/stripe",
+  version: "0.0.1-beta.1783705886.297c5be",
+  commit: "297c5be7d3af822a7f5da906acf27a076332609c",
+} as const;