@omg-dev/server 0.4.24

package/dist/trigger-scan.mjs

@@ -0,0 +1,95 @@
+import path from "node:path";
+import fs from "node:fs";
+//#region src/trigger-scan.ts
+/** scanTriggers walks `<root>/functions/` and returns every detected trigger. */
+async function scanTriggers(root) {
+	const fnDir = path.join(root, "functions");
+	if (!fs.existsSync(fnDir)) return [];
+	const out = [];
+	walk(fnDir, out);
+	const apiDir = path.join(fnDir, "api");
+	if (fs.existsSync(apiDir) && fs.statSync(apiDir).isDirectory()) walk(apiDir, out);
+	return out;
+}
+function walk(dir, out) {
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		if (entry.isDirectory()) continue;
+		if (!entry.name.endsWith(".ts") || entry.name.endsWith(".d.ts")) continue;
+		const filePath = path.join(dir, entry.name);
+		const source = fs.readFileSync(filePath, "utf-8");
+		const basename = path.basename(entry.name, ".ts");
+		out.push(...extractTriggers(source, filePath, basename));
+	}
+}
+const EXPORT_TRIGGER_RE = /^export\s+const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(cron|on)\s*\(\s*(.+?)\s*,/gm;
+const EXPORT_STORAGE_HOOK_RE = /^export\s+const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*storage\.(onUpload|onDelete)\s*\(/gm;
+var TriggerScanError = class extends Error {
+	constructor(file, detail) {
+		super(`[vibes:triggers] ${file}: ${detail}`);
+		this.file = file;
+		this.detail = detail;
+		this.name = "TriggerScanError";
+	}
+};
+function extractTriggers(source, filePath, basename) {
+	const out = [];
+	const stripped = source.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+	let m;
+	EXPORT_TRIGGER_RE.lastIndex = 0;
+	while ((m = EXPORT_TRIGGER_RE.exec(stripped)) !== null) {
+		const [, exportName, kind, firstArg] = m;
+		const lit = parseStringLiteral(firstArg);
+		if (lit === null) throw new TriggerScanError(filePath, `${kind}() first arg must be a string literal — got: ${firstArg.slice(0, 60)}`);
+		out.push({
+			handler: `${basename}.${exportName}`,
+			kind,
+			key: lit,
+			module: filePath,
+			exportName
+		});
+	}
+	EXPORT_STORAGE_HOOK_RE.lastIndex = 0;
+	while ((m = EXPORT_STORAGE_HOOK_RE.exec(stripped)) !== null) {
+		const [, exportName, hookName] = m;
+		out.push({
+			handler: `${basename}.${exportName}`,
+			kind: hookName === "onUpload" ? "storage:upload" : "storage:delete",
+			key: "",
+			module: filePath,
+			exportName
+		});
+	}
+	return out;
+}
+/**
+* Parse a single-line first-arg into a string literal. Returns null when the
+* input isn't a plain "..." or '...' literal (e.g. it's a template literal, a
+* variable reference, or a runtime expression).
+*/
+function parseStringLiteral(raw) {
+	const trimmed = raw.trim();
+	if (trimmed.length < 2) return null;
+	const first = trimmed[0];
+	if ((first === "\"" || first === "'") && trimmed.endsWith(first)) {
+		const inner = trimmed.slice(1, -1);
+		if (inner.includes("${")) return null;
+		return inner.replace(/\\(.)/g, "$1");
+	}
+	return null;
+}
+/**
+* Scan `<root>/functions/` and write the result to `<root>/.vibes/triggers.json`
+* — the file `createVibesServer` loads at boot when no bundled `triggers`
+* array is passed. For hosts without a vite build (control-plane container,
+* self-host bundles): call this before `createVibesServer` so cron()/on()
+* declarations in functions/*.ts actually register.
+*/
+async function writeTriggersManifest(root) {
+	const triggers = await scanTriggers(root);
+	const vibesDir = path.join(root, ".vibes");
+	fs.mkdirSync(vibesDir, { recursive: true });
+	fs.writeFileSync(path.join(vibesDir, "triggers.json"), JSON.stringify(triggers, null, 2), "utf-8");
+	return triggers;
+}
+//#endregion
+export { TriggerScanError, extractTriggers, scanTriggers, writeTriggersManifest };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@omg-dev/server",
+  "version": "0.4.24",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./trigger-scan": {
+      "types": "./src/trigger-scan.ts",
+      "default": "./dist/trigger-scan.mjs"
+    }
+  },
+  "dependencies": {
+    "@restatedev/restate-sdk": "1.14.5",
+    "@omg-dev/auth": "0.4.24",
+    "@omg-dev/schema": "0.4.24",
+    "@omg-dev/stream": "0.4.24",
+    "web-push": "^3.6.7"
+  },
+  "scripts": {
+    "build": "vp pack src/index.ts src/trigger-scan.ts",
+    "test": "vp test run"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BennyKok/vibes.git"
+  },
+  "homepage": "https://docs.omg.dev",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/auto-crud.ts

@@ -0,0 +1,244 @@
+// auto-crud — schema-derived REST routes mounted at /api/<collection>.
+//
+// Generates the five conventional verbs (list/get/create/update/remove) for
+// every collection in the Schema so SDK callers like `useCollection` work
+// out-of-the-box without a `functions/<collection>.ts` file.
+//
+// User-scoped collections (`scope: "user"`) get row-level filtering by the
+// `_owner` column, sourced from ctxStore. We treat "row not found" and "row
+// owned by someone else" the same (404) to avoid leaking row existence.
+
+import type { Schema, FieldType, CollectionConfig } from "@omg-dev/schema"
+import { getDbInstance } from "./db.ts"
+import { invalidate } from "./broker.ts"
+import { notifyRowChange } from "./subscriptions.ts"
+import { ctxStore } from "./ctx.ts"
+import type { Route } from "./dispatcher.ts"
+import { encodeValue, decodeRow, decodeRows } from "./codec.ts"
+
+type InlineHandler = (req: Request, params: Record<string, string>) => Promise<Response>
+
+// ── Body parsing ──────────────────────────────────────────────────────────────
+
+async function readJsonBody(req: Request): Promise<Record<string, unknown>> {
+  const ct = req.headers.get("content-type") ?? ""
+  if (!ct.includes("application/json")) return {}
+  const text = await req.text()
+  if (!text.trim()) return {}
+  try {
+    const parsed = JSON.parse(text)
+    return (parsed && typeof parsed === "object") ? parsed as Record<string, unknown> : {}
+  } catch {
+    throw new Error("Invalid JSON body")
+  }
+}
+
+function jsonError(status: number, message: string): Response {
+  return Response.json({ error: message }, { status })
+}
+
+// ── Handlers ──────────────────────────────────────────────────────────────────
+
+function getUserId(): string | null {
+  return ctxStore.getStore()?.userId ?? null
+}
+
+function makeListHandler(
+  name: string,
+  fields: Record<string, { type: FieldType }>,
+  scoped: boolean,
+): InlineHandler {
+  return async () => {
+    const db = getDbInstance()
+    if (!db) return jsonError(500, "db not initialized")
+
+    if (scoped) {
+      const userId = getUserId()
+      if (!userId) return jsonError(401, "Authentication required")
+      const rows = db.raw()
+        .prepare(`SELECT * FROM ${name} WHERE _owner = ? ORDER BY created_at DESC`)
+        .all(userId) as Record<string, unknown>[]
+      return Response.json(decodeRows(rows, fields))
+    }
+
+    const rows = db.raw()
+      .prepare(`SELECT * FROM ${name} ORDER BY created_at DESC`)
+      .all() as Record<string, unknown>[]
+    return Response.json(decodeRows(rows, fields))
+  }
+}
+
+function makeGetHandler(
+  name: string,
+  fields: Record<string, { type: FieldType }>,
+  scoped: boolean,
+): InlineHandler {
+  return async (_req, params) => {
+    const db = getDbInstance()
+    if (!db) return jsonError(500, "db not initialized")
+
+    if (scoped) {
+      const userId = getUserId()
+      if (!userId) return jsonError(401, "Authentication required")
+      // Treat "no row" and "wrong owner" identically — leaking 404 vs 403
+      // would let an attacker enumerate other users' ids.
+      const row = db.raw()
+        .prepare(`SELECT * FROM ${name} WHERE id = ? AND _owner = ? LIMIT 1`)
+        .get(params.id, userId) as Record<string, unknown> | null
+      if (!row) return jsonError(404, "Not found")
+      return Response.json(decodeRow(row, fields))
+    }
+
+    const row = db.raw().prepare(`SELECT * FROM ${name} WHERE id = ? LIMIT 1`).get(params.id) as
+      | Record<string, unknown>
+      | null
+    if (!row) return jsonError(404, "Not found")
+    return Response.json(decodeRow(row, fields))
+  }
+}
+
+function makeCreateHandler(
+  name: string,
+  fields: Record<string, { type: FieldType }>,
+  scoped: boolean,
+): InlineHandler {
+  return async (req) => {
+    const db = getDbInstance()
+    if (!db) return jsonError(500, "db not initialized")
+
+    let userId: string | null = null
+    if (scoped) {
+      userId = getUserId()
+      if (!userId) return jsonError(401, "Authentication required")
+    }
+
+    let body: Record<string, unknown>
+    try { body = await readJsonBody(req) } catch (e) {
+      return jsonError(400, (e as Error).message)
+    }
+
+    const id = crypto.randomUUID()
+    const ts = new Date().toISOString()
+    const record: Record<string, unknown> = { id, created_at: ts, updated_at: ts }
+    if (scoped) record._owner = userId
+    for (const [k, def] of Object.entries(fields)) {
+      if (k in body) record[k] = encodeValue(def.type, body[k])
+    }
+
+    const cols = Object.keys(record)
+    const placeholders = cols.map(() => "?").join(", ")
+    const values = Object.values(record)
+    db.raw().prepare(`INSERT INTO ${name} (${cols.join(", ")}) VALUES (${placeholders})`).run(...values)
+
+    invalidate(name)
+    void notifyRowChange(name, "insert", null, record)
+    return Response.json(decodeRow(record, fields))
+  }
+}
+
+function makeUpdateHandler(
+  name: string,
+  fields: Record<string, { type: FieldType }>,
+  scoped: boolean,
+): InlineHandler {
+  return async (req, params) => {
+    const db = getDbInstance()
+    if (!db) return jsonError(500, "db not initialized")
+
+    let userId: string | null = null
+    if (scoped) {
+      userId = getUserId()
+      if (!userId) return jsonError(401, "Authentication required")
+    }
+
+    let body: Record<string, unknown>
+    try { body = await readJsonBody(req) } catch (e) {
+      return jsonError(400, (e as Error).message)
+    }
+
+    const existing = db.raw().prepare(`SELECT * FROM ${name} WHERE id = ? LIMIT 1`).get(params.id) as
+      | Record<string, unknown>
+      | null
+    if (!existing) return jsonError(404, "Not found")
+    if (scoped && existing._owner !== userId) return jsonError(404, "Not found")
+
+    const updates: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(body)) {
+      if (k === "id" || k === "created_at" || k === "updated_at" || k === "_owner") continue
+      if (!(k in fields)) return jsonError(400, `Unknown column: ${k}`)
+      updates[k] = encodeValue(fields[k].type, v)
+    }
+    updates.updated_at = new Date().toISOString()
+
+    const setClauses = Object.keys(updates).map(k => `${k} = ?`).join(", ")
+    const values = [...Object.values(updates), params.id]
+    db.raw().prepare(`UPDATE ${name} SET ${setClauses} WHERE id = ?`).run(...values)
+
+    const merged = { ...existing, ...updates }
+    invalidate(name)
+    void notifyRowChange(name, "update", existing, merged)
+    return Response.json(decodeRow(merged, fields))
+  }
+}
+
+function makeRemoveHandler(name: string, scoped: boolean): InlineHandler {
+  return async (_req, params) => {
+    const db = getDbInstance()
+    if (!db) return jsonError(500, "db not initialized")
+
+    // Always SELECT the full row first — even for global tables. Delta
+    // subscribers running a predicate need the pre-delete row to decide
+    // whether the delete affects their read set (was-in vs was-out
+    // matters even when no scope check is needed).
+    const existing = db.raw()
+      .prepare(`SELECT * FROM ${name} WHERE id = ? LIMIT 1`)
+      .get(params.id) as Record<string, unknown> | null
+    if (!existing) return jsonError(404, "Not found")
+    if (scoped) {
+      const userId = getUserId()
+      if (!userId) return jsonError(401, "Authentication required")
+      if (existing._owner !== userId) return jsonError(404, "Not found")
+    }
+
+    db.raw().prepare(`DELETE FROM ${name} WHERE id = ?`).run(params.id)
+    invalidate(name)
+    void notifyRowChange(name, "delete", existing, null)
+    return new Response(null, { status: 204 })
+  }
+}
+
+// ── buildAutoCrudRoutes ───────────────────────────────────────────────────────
+
+export function buildAutoCrudRoutes(schema: Schema): Route[] {
+  const routes: Route[] = []
+  for (const [name, col] of Object.entries(schema.collections)) {
+    const fields = col.fields
+    const scoped = (col as CollectionConfig).scope === "user"
+    routes.push({
+      method: "GET", path: `/api/${name}`,
+      module: "<auto-crud>", handler: "list",
+      inlineHandler: makeListHandler(name, fields, scoped),
+    })
+    routes.push({
+      method: "GET", path: `/api/${name}/:id`,
+      module: "<auto-crud>", handler: "get",
+      inlineHandler: makeGetHandler(name, fields, scoped),
+    })
+    routes.push({
+      method: "POST", path: `/api/${name}`,
+      module: "<auto-crud>", handler: "create",
+      inlineHandler: makeCreateHandler(name, fields, scoped),
+    })
+    routes.push({
+      method: "PATCH", path: `/api/${name}/:id`,
+      module: "<auto-crud>", handler: "update",
+      inlineHandler: makeUpdateHandler(name, fields, scoped),
+    })
+    routes.push({
+      method: "DELETE", path: `/api/${name}/:id`,
+      module: "<auto-crud>", handler: "remove",
+      inlineHandler: makeRemoveHandler(name, scoped),
+    })
+  }
+  return routes
+}

package/src/billing.ts

@@ -0,0 +1,297 @@
+// @omg-dev/server — per-app billing runtime client.
+//
+// A deployed user app imports `billing` to meter + gate entitlements for its
+// OWN end-users (the app's customers, keyed by an app-chosen `externalRef`).
+// This is distinct from omg's tenant-zero billing of the app owner.
+//
+// Transport mirrors emit()/storage: every call POSTs (or GETs) the in-VM
+// agent at http://localhost:8080/_billing/*. The agent forwards to the Go
+// billing engine (infra), scoped to this app's `app_id`. The app never talks
+// to infra directly — the agent injects identity, so the runtime client only
+// carries the business-level fields.
+//
+// Money is integer MICRO-UNITS of the app's credit unit (matching the Go
+// engine + @omg-dev/billing): usd(1) === 1_000_000. Never pass a float balance.
+//
+// ── Usage: gate a feature in a route ─────────────────────────────────────────
+//
+//   import { billing, usd, type Route } from "@omg-dev/server"
+//
+//   // On signup: create the customer (idempotent on userId).
+//   export const onSignup: Route = async (ctx) => {
+//     await billing.ensureCustomer(ctx.user.id, "free")
+//     return Response.json({ ok: true })
+//   }
+//
+//   // Before serving a metered feature: check entitlement, then track usage.
+//   export const generate: Route = async (ctx) => {
+//     const gate = await billing.check("ai_generation", ctx.user.id)
+//     if (!gate.allow) {
+//       return Response.json({ error: gate.reason ?? "out of credits" }, { status: 402 })
+//     }
+//     const result = await doExpensiveWork()
+//     await billing.track("ai_generation", ctx.user.id, usd(0.01), ctx.requestId)
+//     return Response.json(result)
+//   }
+
+const AGENT_BASE = "http://localhost:8080"
+const MICROS_PER_UNIT = 1_000_000
+
+/**
+ * Dollars (or whole credit units) → integer micro-units, for the amount
+ * arguments of `track`/`grant`. `usd(5)` → 5_000_000. Re-exported from the
+ * same definition @omg-dev/billing uses so app authors can write `usd(5)`.
+ */
+export function usd(amount: number): number {
+  return Math.round(amount * MICROS_PER_UNIT)
+}
+
+// ── Contract types (mirror the agent /_billing/* endpoints) ──────────────────
+
+export interface EnsureCustomerResult {
+  customerId: string
+  plan: string | null
+  created: boolean
+}
+
+export interface CheckResult {
+  allow: boolean
+  balanceMicros: number
+  plan: string | null
+  reason?: string
+}
+
+export interface TrackResult {
+  balanceMicros: number
+}
+
+export interface GrantResult {
+  balanceMicros: number
+}
+
+export interface BalanceResult {
+  exists: boolean
+  plan: string | null
+  balanceMicros: number
+}
+
+/** A single subscription record for an end-user (newest by update time). */
+export interface SubscriptionRecord {
+  status: string
+  planVersion: number
+  currentPeriodStart: number
+  currentPeriodEnd: number
+  providerSubscriptionId: string
+}
+
+/**
+ * The end-user's current entitlement: the plan they're on plus their newest
+ * subscription row (null when they have none / never subscribed). Drive
+ * <PricingTable currentPlan={plan} /> and "You're on Pro" gates from this.
+ */
+export interface SubscriptionResult {
+  plan: string | null
+  subscription: SubscriptionRecord | null
+}
+
+/** A hosted-checkout the app's end-user is redirected to in order to pay. */
+export interface CheckoutResult {
+  /** Provider-hosted checkout URL — redirect the end-user here. */
+  checkoutUrl: string
+  /** Provider checkout id (for correlation / status lookups). */
+  checkoutId: string
+}
+
+export interface CheckoutOptions {
+  /**
+   * The plan key (from your @omg-dev/billing catalog) the end-user is buying.
+   * The owner's Polar product + the charge amount are resolved SERVER-SIDE
+   * from the active plan-version for this key — the client never supplies the
+   * price, so a tampered client can't change what it's charged.
+   */
+  plan: string
+  /** The app's end-user id — the billing customer credited on payment. */
+  externalRef: string
+  /**
+   * Optional override for the post-payment redirect. Defaults to the omg
+   * checkout-complete page.
+   */
+  successUrl?: string
+  /**
+   * Optional feature/credit bucket + amount override for a one-time top-up
+   * style checkout. For a known PLAN these are derived server-side from the
+   * plan-version (price) + catalog (feature) and any client value is ignored;
+   * supply them only for ad-hoc credit purchases. Amount is in micro-units.
+   */
+  feature?: string
+  amountMicros?: number
+}
+
+export interface GrantOptions {
+  idempotencyKey: string
+  grantKey?: string
+  source?: string
+  reason?: string
+}
+
+// ── Transport ────────────────────────────────────────────────────────────────
+//
+// Shared POST helper, same shape as storage.ts's prod calls: JSON in, JSON
+// out, throw on non-2xx with a truncated body for diagnosability.
+
+async function agentPost<T>(path: string, body: unknown, label: string): Promise<T> {
+  const res = await fetch(`${AGENT_BASE}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  })
+  if (!res.ok) {
+    const text = await res.text().catch(() => "")
+    throw new Error(`billing.${label} agent ${res.status}: ${text.slice(0, 200)}`)
+  }
+  return (await res.json()) as T
+}
+
+async function agentGet<T>(path: string, label: string): Promise<T> {
+  const res = await fetch(`${AGENT_BASE}${path}`, {
+    method: "GET",
+    headers: { Accept: "application/json" },
+  })
+  if (!res.ok) {
+    const text = await res.text().catch(() => "")
+    throw new Error(`billing.${label} agent ${res.status}: ${text.slice(0, 200)}`)
+  }
+  return (await res.json()) as T
+}
+
+// ── Public client ────────────────────────────────────────────────────────────
+
+export const billing = {
+  /**
+   * Create (or fetch) the billing customer for one of this app's end-users.
+   * Idempotent on `externalRef` within the app — call it on signup. `plan`
+   * optionally pins the customer onto a declared plan at creation.
+   */
+  async ensureCustomer(externalRef: string, plan?: string): Promise<EnsureCustomerResult> {
+    return agentPost<EnsureCustomerResult>(
+      "/_billing/customers",
+      { externalRef, plan },
+      "ensureCustomer",
+    )
+  },
+
+  /**
+   * Check whether `externalRef` is entitled to use `feature` right now. Read
+   * the `allow` flag before serving the feature; `reason` explains a denial.
+   */
+  async check(feature: string, externalRef: string): Promise<CheckResult> {
+    return agentPost<CheckResult>(
+      "/_billing/check",
+      { feature, externalRef },
+      "check",
+    )
+  },
+
+  /**
+   * Record `amountMicros` of `feature` usage against `externalRef` after the
+   * feature was served. `idempotencyKey` dedupes retries — reuse the same key
+   * for the same logical unit of work. Returns the new balance.
+   */
+  async track(
+    feature: string,
+    externalRef: string,
+    amountMicros: number,
+    idempotencyKey: string,
+    reason?: string,
+  ): Promise<TrackResult> {
+    return agentPost<TrackResult>(
+      "/_billing/track",
+      { feature, externalRef, amountMicros, idempotencyKey, reason },
+      "track",
+    )
+  },
+
+  /**
+   * Add `amountMicros` of `feature` credit to `externalRef` (a top-up, refund,
+   * or promo grant). `opts.idempotencyKey` dedupes retries; `opts.grantKey`
+   * dedupes a one-time grant (e.g. a signup bonus) across the customer's
+   * lifetime. Returns the new balance.
+   */
+  async grant(
+    externalRef: string,
+    feature: string,
+    amountMicros: number,
+    opts: GrantOptions,
+  ): Promise<GrantResult> {
+    return agentPost<GrantResult>(
+      "/_billing/grant",
+      {
+        externalRef,
+        feature,
+        amountMicros,
+        idempotencyKey: opts.idempotencyKey,
+        grantKey: opts.grantKey,
+        source: opts.source,
+        reason: opts.reason,
+      },
+      "grant",
+    )
+  },
+
+  /**
+   * Read the current `feature` balance for `externalRef` without mutating it.
+   * `exists` is false if the customer was never created.
+   */
+  async balance(externalRef: string, feature: string): Promise<BalanceResult> {
+    const qs = new URLSearchParams({ externalRef, feature })
+    return agentGet<BalanceResult>(
+      `/_billing/balance?${qs.toString()}`,
+      "balance",
+    )
+  },
+
+  /**
+   * Read `externalRef`'s current plan + newest subscription record without
+   * mutating anything. Use it to render entitlement UI — pass `plan` to
+   * <PricingTable currentPlan> or gate paid features. An end-user who never
+   * subscribed reads back the catalog default plan with `subscription: null`.
+   */
+  async subscription(externalRef: string): Promise<SubscriptionResult> {
+    const qs = new URLSearchParams({ externalRef })
+    return agentGet<SubscriptionResult>(
+      `/_billing/subscription?${qs.toString()}`,
+      "subscription",
+    )
+  },
+
+  /**
+   * Mint a hosted checkout for one of this app's end-users to buy `plan`, in
+   * the APP OWNER's connected Polar org. Returns the checkout URL to redirect
+   * to. The amount + product are resolved server-side from the active
+   * plan-version (the client cannot set the price). On successful payment the
+   * Polar webhook credits/upgrades `externalRef` automatically.
+   *
+   *   export const buyPro: Route = async (ctx) => {
+   *     const { checkoutUrl } = await billing.checkout({
+   *       plan: "pro",
+   *       externalRef: ctx.user.id,
+   *     })
+   *     return Response.redirect(checkoutUrl, 303)
+   *   }
+   */
+  async checkout(opts: CheckoutOptions): Promise<CheckoutResult> {
+    return agentPost<CheckoutResult>(
+      "/_billing/checkout",
+      {
+        plan: opts.plan,
+        externalRef: opts.externalRef,
+        successUrl: opts.successUrl,
+        feature: opts.feature,
+        amountMicros: opts.amountMicros,
+      },
+      "checkout",
+    )
+  },
+}
+
+export type Billing = typeof billing