@cross-deck/buckets 0.1.0 → 0.1.2

package/README.md

@@ -399,9 +399,13 @@ That's the line between the open primitive and the product built on it.
 ## FAQ
 
 **Is this really free, or is there a catch?**
-Genuinely free, MIT, forever. The collector and the schema are the open primitive.
-We make money on the *interpretation* layer (Crossdeck), not on locking up your
-own cost data. Your rollups are yours, in your datastore, readable by anything.
+No catch — and that includes Crossdeck itself. The collector and the schema are
+MIT, free forever; **and seeing your numbers on Crossdeck is free too**, on a
+genuinely generous free tier. We never charge you to watch your own read costs —
+there's no trial clock, no paywall, no "upgrade to see your data." This isn't a
+funnel dressed up as open source. Your rollups are yours — in your datastore,
+readable by anything, with or without us. Crossdeck earns its keep on the broader
+platform you can grow into, never on locking up the cost data you already own.
 
 **Won't patching the SDK slow down my reads?**
 No. The overhead is one in-memory map increment per read. No I/O is added to the

package/dist/index.d.mts

@@ -0,0 +1,179 @@
+/**
+ * sink — where the meter sends a coalesced rollup, and the wire shape it sends.
+ *
+ * Abstracting the sink is what makes Buckets storage-agnostic: the meter never
+ * knows where counts go. The DEFAULT sink (`ReportSink`) reports up to Crossdeck's
+ * ingest endpoint so the numbers surface on your Crossdeck dashboard. A team that
+ * wants to self-host can implement `Sink` against anything (Postgres, a file, your
+ * own API) without touching the meter.
+ */
+interface OpCounts {
+    read?: number;
+    write?: number;
+    delete?: number;
+}
+/**
+ * One coalesced report — the wire contract (see docs/ROLLUP_SCHEMA.md). The meter
+ * produces one of these per UTC day in a flush window (usually exactly one).
+ */
+interface BucketsReport {
+    /** UTC day "YYYY-MM-DD". */
+    date: string;
+    /** bucket name → counts. The heart of the report. */
+    byLabel: Record<string, OpCounts>;
+    /** UTC hour "HH" → counts, for the hourly "did my fix land this hour?" view. */
+    byHour?: Record<string, OpCounts>;
+}
+/**
+ * A destination for coalesced rollups. `flush` MAY throw on failure — the meter
+ * catches it, drops that one window, and never lets it reach your app.
+ */
+interface Sink {
+    flush(report: BucketsReport): Promise<void>;
+}
+interface ReportSinkConfig {
+    /** The project's `cd_sk_` secret key. Server-to-server only. */
+    apiKey: string;
+    /** Defaults to https://api.cross-deck.com/v1/buckets/report */
+    endpoint?: string;
+    /** Request timeout (ms); a slow Crossdeck must never stall your flush. */
+    timeoutMs?: number;
+}
+/**
+ * The default sink: POST one coalesced rollup to Crossdeck's ingest endpoint.
+ * The ingest folds it into the day's maintained doc with `increment`, so many
+ * reports a minute coalesce safely. This path does ZERO database reads — it sends
+ * a summary, it does not read. Throws on a non-202 so the meter can log/drop the
+ * window; the meter guarantees it never reaches your app.
+ */
+declare class ReportSink implements Sink {
+    private readonly endpoint;
+    private readonly apiKey;
+    private readonly timeoutMs;
+    constructor(config: ReportSinkConfig);
+    flush(report: BucketsReport): Promise<void>;
+}
+
+type OpType = "read" | "write" | "delete";
+/** Optional read-site hint — the collection touched, derived at the trap from the
+ *  path. Lets an UNtagged read cascade to `col:<collection>` instead of vanishing. */
+interface CostHint {
+    collection?: string;
+    projectId?: string;
+}
+interface MeterConfig {
+    sink: Sink;
+    flushIntervalMs?: number;
+    onError?: (e: unknown) => void;
+}
+/** Firestore bills a minimum of one read even for an empty result, so 0 counts as 1. */
+declare function recordReads(n: number, hint?: CostHint): void;
+declare function recordWrites(n?: number): void;
+declare function recordDeletes(n?: number): void;
+/**
+ * Coalesce the buffer into one report per UTC day and hand each to the Sink.
+ * Snapshots + clears up front so concurrent records land in the next window.
+ * Never throws; a sink failure drops that window (surfaced via `onError`).
+ */
+declare function flush(): Promise<void>;
+
+type AnyFn = (...args: any[]) => any;
+/**
+ * The firebase-admin Firestore classes to patch. Pass the module namespace from
+ * `firebase-admin/firestore` — only the prototypes present are patched.
+ */
+interface FirestoreClasses {
+    Query?: {
+        prototype: {
+            get?: AnyFn;
+        };
+    };
+    DocumentReference?: {
+        prototype: {
+            get?: AnyFn;
+        };
+    };
+    Transaction?: {
+        prototype: {
+            get?: AnyFn;
+            getAll?: AnyFn;
+        };
+    };
+    Firestore?: {
+        prototype: {
+            getAll?: AnyFn;
+        };
+    };
+}
+/**
+ * Install the universal read meter on the firebase-admin Firestore classes. Call
+ * ONCE at process start, before any reads. Pass the namespace from
+ * `firebase-admin/firestore` so the exact prototypes the SDK uses are patched:
+ *
+ *   import * as Firestore from "firebase-admin/firestore";
+ *   installFirestoreMeter(Firestore);
+ */
+declare function installFirestoreMeter(classes: FirestoreClasses): void;
+
+interface CostTag {
+    /** Optional coarse grouping (a caller-defined surface name). */
+    feature?: string;
+    /** The bucket name — what `bucket()` sets. Drives the report's `byLabel`. */
+    label?: string;
+}
+/** Run `fn` with `tag` bound for its entire async subtree. */
+declare function runWithCostTag<T>(tag: CostTag, fn: () => T): T;
+/** Bind a tag for the remainder of the current async context (no closure to wrap). */
+declare function enterCostTag(tag: CostTag): void;
+/** Refine the live tag in place (e.g. stamp a feature after the boundary). */
+declare function refineCostTag(patch: Partial<CostTag>): void;
+/** The current tag, or a safe empty default outside any bound context. */
+declare function currentCostTag(): CostTag;
+/**
+ * `bucket(name, fn)` — the headline verb, the `track()` of cost. Run `fn` with
+ * every operation inside it attributed to the bucket `name`; the attribution
+ * rides the async subtree automatically. The one verb most developers ever touch:
+ *
+ *   await bucket("nightly-export", async () => {
+ *     const rows = await db.collection("events").where(...).get(); // → "nightly-export"
+ *   });
+ */
+declare function bucket<T>(name: string, fn: () => T): T;
+
+/**
+ * @cross-deck/buckets — know exactly what every database read costs you, and who
+ * caused it. A tiny, never-throws collector for Firestore.
+ *
+ * The whole footprint a consumer sees:
+ *   1. init({ apiKey, firestore })  — configure once, install the trap once
+ *   2. bucket(name, fn)             — name the read paths that matter
+ *   3. (the dashboard shows the rest — and names the ones you haven't yet)
+ */
+
+interface InitOptions {
+    /** The project's `cd_sk_` SECRET key. Server-to-server only — never a browser key. */
+    apiKey: string;
+    /**
+     * Pass the namespace from `firebase-admin/firestore` to auto-install the read
+     * trap (recommended — this is what makes every read count with no per-call work).
+     * Omit it if you'd rather call `installFirestoreMeter()` yourself, or you only
+     * use the manual `recordReads()` recorders.
+     */
+    firestore?: FirestoreClasses;
+    /** Override the report endpoint (defaults to Crossdeck's ingest). */
+    endpoint?: string;
+    /** How often to flush coalesced counts (ms). Default 60_000. */
+    flushIntervalMs?: number;
+    /** Bring your own sink (self-host the rollups). Defaults to reporting up to Crossdeck. */
+    sink?: Sink;
+    /** Notified when a flush fails, so a dropped window is never silent. Best-effort. */
+    onError?: MeterConfig["onError"];
+}
+/**
+ * Configure Buckets once, at process start. Points the meter at a sink (Crossdeck's
+ * ingest by default) and — if you pass `firestore` — installs the universal read
+ * trap so every read counts automatically.
+ */
+declare function init(options: InitOptions): void;
+
+export { type BucketsReport, type CostHint, type CostTag, type FirestoreClasses, type InitOptions, type MeterConfig, type OpCounts, type OpType, ReportSink, type ReportSinkConfig, type Sink, bucket, currentCostTag, enterCostTag, flush, init, init as initBuckets, installFirestoreMeter, recordDeletes, recordReads, recordWrites, refineCostTag, runWithCostTag };

package/dist/index.d.ts

@@ -1,3 +1,145 @@
+/**
+ * sink — where the meter sends a coalesced rollup, and the wire shape it sends.
+ *
+ * Abstracting the sink is what makes Buckets storage-agnostic: the meter never
+ * knows where counts go. The DEFAULT sink (`ReportSink`) reports up to Crossdeck's
+ * ingest endpoint so the numbers surface on your Crossdeck dashboard. A team that
+ * wants to self-host can implement `Sink` against anything (Postgres, a file, your
+ * own API) without touching the meter.
+ */
+interface OpCounts {
+    read?: number;
+    write?: number;
+    delete?: number;
+}
+/**
+ * One coalesced report — the wire contract (see docs/ROLLUP_SCHEMA.md). The meter
+ * produces one of these per UTC day in a flush window (usually exactly one).
+ */
+interface BucketsReport {
+    /** UTC day "YYYY-MM-DD". */
+    date: string;
+    /** bucket name → counts. The heart of the report. */
+    byLabel: Record<string, OpCounts>;
+    /** UTC hour "HH" → counts, for the hourly "did my fix land this hour?" view. */
+    byHour?: Record<string, OpCounts>;
+}
+/**
+ * A destination for coalesced rollups. `flush` MAY throw on failure — the meter
+ * catches it, drops that one window, and never lets it reach your app.
+ */
+interface Sink {
+    flush(report: BucketsReport): Promise<void>;
+}
+interface ReportSinkConfig {
+    /** The project's `cd_sk_` secret key. Server-to-server only. */
+    apiKey: string;
+    /** Defaults to https://api.cross-deck.com/v1/buckets/report */
+    endpoint?: string;
+    /** Request timeout (ms); a slow Crossdeck must never stall your flush. */
+    timeoutMs?: number;
+}
+/**
+ * The default sink: POST one coalesced rollup to Crossdeck's ingest endpoint.
+ * The ingest folds it into the day's maintained doc with `increment`, so many
+ * reports a minute coalesce safely. This path does ZERO database reads — it sends
+ * a summary, it does not read. Throws on a non-202 so the meter can log/drop the
+ * window; the meter guarantees it never reaches your app.
+ */
+declare class ReportSink implements Sink {
+    private readonly endpoint;
+    private readonly apiKey;
+    private readonly timeoutMs;
+    constructor(config: ReportSinkConfig);
+    flush(report: BucketsReport): Promise<void>;
+}
+
+type OpType = "read" | "write" | "delete";
+/** Optional read-site hint — the collection touched, derived at the trap from the
+ *  path. Lets an UNtagged read cascade to `col:<collection>` instead of vanishing. */
+interface CostHint {
+    collection?: string;
+    projectId?: string;
+}
+interface MeterConfig {
+    sink: Sink;
+    flushIntervalMs?: number;
+    onError?: (e: unknown) => void;
+}
+/** Firestore bills a minimum of one read even for an empty result, so 0 counts as 1. */
+declare function recordReads(n: number, hint?: CostHint): void;
+declare function recordWrites(n?: number): void;
+declare function recordDeletes(n?: number): void;
+/**
+ * Coalesce the buffer into one report per UTC day and hand each to the Sink.
+ * Snapshots + clears up front so concurrent records land in the next window.
+ * Never throws; a sink failure drops that window (surfaced via `onError`).
+ */
+declare function flush(): Promise<void>;
+
+type AnyFn = (...args: any[]) => any;
+/**
+ * The firebase-admin Firestore classes to patch. Pass the module namespace from
+ * `firebase-admin/firestore` — only the prototypes present are patched.
+ */
+interface FirestoreClasses {
+    Query?: {
+        prototype: {
+            get?: AnyFn;
+        };
+    };
+    DocumentReference?: {
+        prototype: {
+            get?: AnyFn;
+        };
+    };
+    Transaction?: {
+        prototype: {
+            get?: AnyFn;
+            getAll?: AnyFn;
+        };
+    };
+    Firestore?: {
+        prototype: {
+            getAll?: AnyFn;
+        };
+    };
+}
+/**
+ * Install the universal read meter on the firebase-admin Firestore classes. Call
+ * ONCE at process start, before any reads. Pass the namespace from
+ * `firebase-admin/firestore` so the exact prototypes the SDK uses are patched:
+ *
+ *   import * as Firestore from "firebase-admin/firestore";
+ *   installFirestoreMeter(Firestore);
+ */
+declare function installFirestoreMeter(classes: FirestoreClasses): void;
+
+interface CostTag {
+    /** Optional coarse grouping (a caller-defined surface name). */
+    feature?: string;
+    /** The bucket name — what `bucket()` sets. Drives the report's `byLabel`. */
+    label?: string;
+}
+/** Run `fn` with `tag` bound for its entire async subtree. */
+declare function runWithCostTag<T>(tag: CostTag, fn: () => T): T;
+/** Bind a tag for the remainder of the current async context (no closure to wrap). */
+declare function enterCostTag(tag: CostTag): void;
+/** Refine the live tag in place (e.g. stamp a feature after the boundary). */
+declare function refineCostTag(patch: Partial<CostTag>): void;
+/** The current tag, or a safe empty default outside any bound context. */
+declare function currentCostTag(): CostTag;
+/**
+ * `bucket(name, fn)` — the headline verb, the `track()` of cost. Run `fn` with
+ * every operation inside it attributed to the bucket `name`; the attribution
+ * rides the async subtree automatically. The one verb most developers ever touch:
+ *
+ *   await bucket("nightly-export", async () => {
+ *     const rows = await db.collection("events").where(...).get(); // → "nightly-export"
+ *   });
+ */
+declare function bucket<T>(name: string, fn: () => T): T;
+
 /**
  * @cross-deck/buckets — know exactly what every database read costs you, and who
  * caused it. A tiny, never-throws collector for Firestore.
@@ -7,10 +149,8 @@
  *   2. bucket(name, fn)             — name the read paths that matter
  *   3. (the dashboard shows the rest — and names the ones you haven't yet)
  */
-import { type MeterConfig } from "./cost-meter.js";
-import { type Sink } from "./sink.js";
-import { type FirestoreClasses } from "./adapters/firestore.js";
-export interface InitOptions {
+
+interface InitOptions {
     /** The project's `cd_sk_` SECRET key. Server-to-server only — never a browser key. */
     apiKey: string;
     /**
@@ -34,11 +174,6 @@ export interface InitOptions {
  * ingest by default) and — if you pass `firestore` — installs the universal read
  * trap so every read counts automatically.
  */
-export declare function init(options: InitOptions): void;
-/** Alias — reads well next to `bucket()` at a call site. */
-export { init as initBuckets };
-export { bucket, runWithCostTag, enterCostTag, refineCostTag, currentCostTag, type CostTag, } from "./cost-context.js";
-export { recordReads, recordWrites, recordDeletes, flush, type CostHint, type OpType, type MeterConfig, } from "./cost-meter.js";
-export { installFirestoreMeter, type FirestoreClasses } from "./adapters/firestore.js";
-export { ReportSink, type Sink, type BucketsReport, type OpCounts, type ReportSinkConfig } from "./sink.js";
-//# sourceMappingURL=index.d.ts.map
+declare function init(options: InitOptions): void;
+
+export { type BucketsReport, type CostHint, type CostTag, type FirestoreClasses, type InitOptions, type MeterConfig, type OpCounts, type OpType, ReportSink, type ReportSinkConfig, type Sink, bucket, currentCostTag, enterCostTag, flush, init, init as initBuckets, installFirestoreMeter, recordDeletes, recordReads, recordWrites, refineCostTag, runWithCostTag };

package/dist/index.js

@@ -1,34 +1,250 @@
-/**
- * @cross-deck/buckets — know exactly what every database read costs you, and who
- * caused it. A tiny, never-throws collector for Firestore.
- *
- * The whole footprint a consumer sees:
- *   1. init({ apiKey, firestore })  — configure once, install the trap once
- *   2. bucket(name, fn)             — name the read paths that matter
- *   3. (the dashboard shows the rest — and names the ones you haven't yet)
- */
-import { configureMeter } from "./cost-meter.js";
-import { ReportSink } from "./sink.js";
-import { installFirestoreMeter } from "./adapters/firestore.js";
-/**
- * Configure Buckets once, at process start. Points the meter at a sink (Crossdeck's
- * ingest by default) and — if you pass `firestore` — installs the universal read
- * trap so every read counts automatically.
- */
-export function init(options) {
-    const sink = options.sink ?? new ReportSink({ apiKey: options.apiKey, endpoint: options.endpoint });
-    configureMeter({ sink, flushIntervalMs: options.flushIntervalMs, onError: options.onError });
-    if (options.firestore)
-        installFirestoreMeter(options.firestore);
-}
-/** Alias — reads well next to `bucket()` at a call site. */
-export { init as initBuckets };
-// The headline verb + the lower-level tag controls it is sugar over.
-export { bucket, runWithCostTag, enterCostTag, refineCostTag, currentCostTag, } from "./cost-context.js";
-// Manual recorders (for non-Firestore ops, or when you don't install the trap).
-export { recordReads, recordWrites, recordDeletes, flush, } from "./cost-meter.js";
-// The trap (the only datastore adapter today) + its class shape.
-export { installFirestoreMeter } from "./adapters/firestore.js";
-// The sink seam — for self-hosting rollups instead of reporting to Crossdeck.
-export { ReportSink } from "./sink.js";
+'use strict';
+
+var async_hooks = require('async_hooks');
+
+// src/cost-context.ts
+var DEFAULT_TAG = {};
+var store = new async_hooks.AsyncLocalStorage();
+function runWithCostTag(tag, fn) {
+  return store.run({ ...tag }, fn);
+}
+function enterCostTag(tag) {
+  store.enterWith({ ...tag });
+}
+function refineCostTag(patch) {
+  const cur = store.getStore();
+  if (cur) Object.assign(cur, patch);
+}
+function currentCostTag() {
+  return store.getStore() ?? DEFAULT_TAG;
+}
+function bucket(name, fn) {
+  return runWithCostTag({ ...currentCostTag(), label: name }, fn);
+}
+
+// src/cost-meter.ts
+var SEP = "";
+var labelBuffer = /* @__PURE__ */ new Map();
+var hourBuffer = /* @__PURE__ */ new Map();
+var sink = null;
+var flushIntervalMs = 6e4;
+var onError = null;
+var timer = null;
+var flushing = false;
+var MAX_BUFFER_KEYS = 5e3;
+function configureMeter(config) {
+  sink = config.sink;
+  if (config.flushIntervalMs && config.flushIntervalMs > 0) flushIntervalMs = config.flushIntervalMs;
+  onError = config.onError ?? null;
+}
+var utcDate = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+var utcHour = () => (/* @__PURE__ */ new Date()).toISOString().slice(11, 13);
+function ensureFlushLoop() {
+  if (timer) return;
+  timer = setInterval(() => void flush(), flushIntervalMs);
+  timer.unref?.();
+  process.once?.("SIGTERM", () => void flush());
+  process.once?.("beforeExit", () => void flush());
+}
+function recordFirestore(op, n, hint) {
+  try {
+    if (!Number.isFinite(n) || n <= 0) return;
+    const t = currentCostTag();
+    const date = utcDate();
+    const label = t.label || (hint?.collection ? `col:${hint.collection}` : "uncategorized");
+    const lk = date + SEP + op + SEP + label;
+    labelBuffer.set(lk, (labelBuffer.get(lk) ?? 0) + n);
+    const hk = date + SEP + op + SEP + utcHour();
+    hourBuffer.set(hk, (hourBuffer.get(hk) ?? 0) + n);
+    ensureFlushLoop();
+    if (labelBuffer.size + hourBuffer.size > MAX_BUFFER_KEYS) void flush();
+  } catch {
+  }
+}
+function recordReads(n, hint) {
+  recordFirestore("read", Math.max(n, 1), hint);
+}
+function recordWrites(n = 1) {
+  recordFirestore("write", n);
+}
+function recordDeletes(n = 1) {
+  recordFirestore("delete", n);
+}
+function add(target, key, op, n) {
+  const bag = target[key] ??= {};
+  bag[op] = (bag[op] ?? 0) + n;
+}
+async function flush() {
+  if (flushing) return;
+  if (!sink) {
+    labelBuffer.clear();
+    hourBuffer.clear();
+    return;
+  }
+  if (labelBuffer.size === 0 && hourBuffer.size === 0) return;
+  flushing = true;
+  const labels = new Map(labelBuffer);
+  const hours = new Map(hourBuffer);
+  labelBuffer.clear();
+  hourBuffer.clear();
+  try {
+    const byDate = /* @__PURE__ */ new Map();
+    const reportFor = (date) => {
+      let r = byDate.get(date);
+      if (!r) {
+        r = { date, byLabel: {}, byHour: {} };
+        byDate.set(date, r);
+      }
+      return r;
+    };
+    for (const [k, n] of labels) {
+      const [date, op, label] = k.split(SEP);
+      add(reportFor(date).byLabel, label, op, n);
+    }
+    for (const [k, n] of hours) {
+      const [date, op, hour] = k.split(SEP);
+      add(reportFor(date).byHour, hour, op, n);
+    }
+    for (const report of byDate.values()) {
+      await sink.flush(report);
+    }
+  } catch (e) {
+    onError?.(e);
+  } finally {
+    flushing = false;
+  }
+}
+
+// src/sink.ts
+var DEFAULT_ENDPOINT = "https://api.cross-deck.com/v1/buckets/report";
+var ReportSink = class {
+  endpoint;
+  apiKey;
+  timeoutMs;
+  constructor(config) {
+    this.endpoint = config.endpoint ?? DEFAULT_ENDPOINT;
+    this.apiKey = config.apiKey;
+    this.timeoutMs = config.timeoutMs ?? 5e3;
+  }
+  async flush(report) {
+    const res = await fetch(this.endpoint, {
+      method: "POST",
+      signal: AbortSignal.timeout(this.timeoutMs),
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(report)
+    });
+    if (res.status !== 202) {
+      throw new Error(`Buckets report rejected: HTTP ${res.status}`);
+    }
+  }
+};
+
+// src/adapters/firestore.ts
+var installed = false;
+function projectFromPath(path) {
+  const parts = path.split("/");
+  const i = parts.indexOf("projects");
+  return i >= 0 && parts[i + 1] ? parts[i + 1] : void 0;
+}
+function hintFrom(target) {
+  try {
+    const p = typeof target?.path === "string" ? target.path : "";
+    if (p) {
+      const parts = p.split("/").filter(Boolean);
+      const collection = parts.length % 2 === 0 ? parts[parts.length - 2] : parts[parts.length - 1];
+      return { collection, projectId: projectFromPath(p) };
+    }
+    const qo = target?._queryOptions;
+    if (qo) {
+      const collection = typeof qo.collectionId === "string" ? qo.collectionId : void 0;
+      const parent = typeof qo.parentPath?.relativeName === "string" ? qo.parentPath.relativeName : typeof qo.parentPath?.toString === "function" ? String(qo.parentPath.toString()) : "";
+      return { collection, projectId: parent ? projectFromPath(parent) : void 0 };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function meterSnap(snap, hint) {
+  try {
+    const size = snap?.size;
+    recordReads(typeof size === "number" ? size : 1, hint);
+  } catch {
+  }
+}
+function meterCount(n, hint) {
+  try {
+    recordReads(n, hint);
+  } catch {
+  }
+}
+function installFirestoreMeter(classes) {
+  if (installed) return;
+  installed = true;
+  const { Query, DocumentReference, Transaction, Firestore } = classes;
+  const qGet = Query?.prototype?.get;
+  if (qGet) {
+    Query.prototype.get = async function(...args) {
+      const snap = await qGet.apply(this, args);
+      meterSnap(snap, hintFrom(this));
+      return snap;
+    };
+  }
+  const dGet = DocumentReference?.prototype?.get;
+  if (dGet) {
+    DocumentReference.prototype.get = async function(...args) {
+      const snap = await dGet.apply(this, args);
+      meterCount(1, hintFrom(this));
+      return snap;
+    };
+  }
+  const tGet = Transaction?.prototype?.get;
+  if (tGet) {
+    Transaction.prototype.get = async function(...args) {
+      const res = await tGet.apply(this, args);
+      meterSnap(res, hintFrom(args[0]));
+      return res;
+    };
+  }
+  const tGetAll = Transaction?.prototype?.getAll;
+  if (tGetAll) {
+    Transaction.prototype.getAll = async function(...args) {
+      const res = await tGetAll.apply(this, args);
+      meterCount(Array.isArray(res) ? res.length : args.length || 1, hintFrom(args[0]));
+      return res;
+    };
+  }
+  const fGetAll = Firestore?.prototype?.getAll;
+  if (fGetAll) {
+    Firestore.prototype.getAll = async function(...args) {
+      const res = await fGetAll.apply(this, args);
+      meterCount(Array.isArray(res) ? res.length : args.length || 1, hintFrom(args[0]));
+      return res;
+    };
+  }
+}
+
+// src/index.ts
+function init(options) {
+  const sink2 = options.sink ?? new ReportSink({ apiKey: options.apiKey, endpoint: options.endpoint });
+  configureMeter({ sink: sink2, flushIntervalMs: options.flushIntervalMs, onError: options.onError });
+  if (options.firestore) installFirestoreMeter(options.firestore);
+}
+
+exports.ReportSink = ReportSink;
+exports.bucket = bucket;
+exports.currentCostTag = currentCostTag;
+exports.enterCostTag = enterCostTag;
+exports.flush = flush;
+exports.init = init;
+exports.initBuckets = init;
+exports.installFirestoreMeter = installFirestoreMeter;
+exports.recordDeletes = recordDeletes;
+exports.recordReads = recordReads;
+exports.recordWrites = recordWrites;
+exports.refineCostTag = refineCostTag;
+exports.runWithCostTag = runWithCostTag;
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map