@columenlabs/lumen-ops 0.0.0-stage → 0.1.35

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Columen Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,12 @@
+Lumen
+Copyright (c) 2026 Columen Labs. Licensed under the MIT License (see LICENSE).
+
+Lumen draws price and market charts with TradingView Lightweight Charts™
+(https://github.com/tradingview/lightweight-charts), Copyright (c) 2025
+TradingView, Inc., licensed under the Apache License 2.0. Lumen turns off the
+chart's own logo, so per that library's NOTICE, an app that shows these charts
+should link to https://www.tradingview.com/ somewhere a user can find it (an
+About page or footer is enough).
+
+The components under packages/ui/src/ui are based on shadcn/ui
+(https://ui.shadcn.com), MIT License, Copyright (c) 2023 shadcn.

package/README.md

@@ -1,3 +1,98 @@
-# Temporary Holding Version
+# @columenlabs/lumen-ops
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Lumen's ops meters for Cloudflare Workers: every data query your app runs becomes one Analytics Engine point, so you can find slow and heavy queries and fix them. The meter wraps your bindings once, so new code is metered without opting in. It writes only each query's shape, never a value.
+
+- Docs: https://lumen.columenlabs.com/docs/
+- For agents: https://lumen.columenlabs.com/llms.txt
+- Source: https://github.com/columenlabs/lumen (`packages/ops`). MIT.
+
+## Install
+
+```bash
+bun add @columenlabs/lumen-ops
+```
+
+Pin it to the same exact version as your other Lumen packages. It uses `AsyncLocalStorage`, so the Worker needs the `nodejs_compat` flag.
+
+## Set up
+
+Bind an Analytics Engine dataset in `wrangler.jsonc`:
+
+```jsonc
+"analytics_engine_datasets": [{ "binding": "QUERIES", "dataset": "myapp_queries" }]
+```
+
+Wrap the bindings once at start, and hand the wrapped ones to your app:
+
+```ts
+import { foldRoute, meteredClickHouse, meteredD1, setQueryCallerOf, setQuerySink } from '@columenlabs/lumen-ops';
+
+setQuerySink(env.QUERIES);
+// Name the request in scope: the app (or part of it), the route, and the tool when an MCP call runs.
+setQueryCallerOf(() => {
+  const req = currentRequest(); // your own request scope
+  return req && { app: 'myapp', kind: 'fetch', route: foldRoute(new URL(req.url).pathname) };
+});
+const db = meteredD1(env.DB);
+const clickhouse = meteredClickHouse(env.CLICKHOUSE); // any ClickHouse HTTP service binding
+```
+
+In a Durable Object, meter its SQLite:
+
+```ts
+import { meteredSql } from '@columenlabs/lumen-ops';
+
+const sql = meteredSql(state.storage.sql, { app: 'myapp', kind: 'do', route: 'Person' });
+```
+
+A cron run, queue batch or alarm names itself, so its queries are charged to it:
+
+```ts
+import { withQueryCaller } from '@columenlabs/lumen-ops';
+
+await withQueryCaller({ app: 'myapp', kind: 'cron', route: 'nightly-rollup' }, () => rollup(env));
+```
+
+Another engine (R2 SQL, an HTTP database) calls `meterQuery({ engine, sql, method, ok, ms, ... })` from its one client.
+
+## What a point holds
+
+One point per statement (a D1 batch writes one per statement in it). The column order is the contract for reading the dataset back:
+
+| Column | Holds |
+|---|---|
+| `index1` | Engine: `d1`, `clickhouse`, `do_sqlite`, `r2_sql` or your own |
+| `blob1` … `blob5` | Engine, app, kind (`fetch`, `cron`, `queue`, `alarm`, `do`), route (ids folded to `:id`), tool |
+| `blob6` … `blob8` | Op (`select`, `insert`, `update`, `delete`, `ddl`, `pragma`, `other`), fingerprint, the query's shape (up to 1 KB) |
+| `blob9`, `blob10` | `ok` or `error`, method (`all`, `first`, `run`, `raw`, `batch`, `query`, `insert`, `exec`) |
+| `double1` … `double8` | Wall ms, the engine's own ms, rows read, bytes read, rows returned, rows written, response bytes, HTTP status |
+
+The shape has every string and number literal as `?`, `IN` lists folded to `(?...)`, comments and ClickHouse's `FORMAT` dropped, and an insert's rows cut off. The fingerprint is a hash of the shape, one per kind of query.
+
+Read it back with the Analytics Engine SQL API, for example the slowest shapes of the last day:
+
+```sql
+SELECT blob7 AS fingerprint, any(blob8) AS shape, sum(_sample_interval) AS calls,
+       quantileWeighted(0.95)(double1, _sample_interval) AS p95_ms
+FROM myapp_queries
+WHERE timestamp > NOW() - INTERVAL '1' DAY
+GROUP BY fingerprint ORDER BY p95_ms DESC LIMIT 20
+```
+
+## Exports
+
+| Export | What it does |
+|---|---|
+| `setQuerySink(binding)` | The dataset every point goes to; nothing is written until it is set |
+| `setQueryCallerOf(fn)` | Names the request in scope when no job is |
+| `withQueryCaller(caller, fn)` | Charges every query inside `fn` to `caller` |
+| `meteredD1(db)` | D1, metered: `prepare` and `batch`, with D1's own rows read and written and duration |
+| `meteredClickHouse(binding)` | A ClickHouse HTTP service binding, metered when the answer has been read: wall time to the last byte, ClickHouse's own statistics |
+| `meteredSql(sql, caller)` | A Durable Object's `storage.sql`, metered |
+| `meterQuery(point)` | One point by hand, for any other engine |
+| `queryShape(sql)` | The shape, fingerprint and op of a query |
+| `foldRoute(path)` | A path with id-like segments as `:id` |
+
+## Versions
+
+0.x: any minor may break things until 1.0. Every merge to Lumen's `main` publishes the next patch of every Lumen package; see the [releases](https://github.com/columenlabs/lumen/releases).

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './points.js';
+export * from './queries.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './points.js';
+export * from './queries.js';

package/dist/points.d.ts

@@ -0,0 +1,8 @@
+/** An Analytics Engine dataset binding: what every Lumen meter writes its points to. */
+export interface PointSink {
+    writeDataPoint(p: {
+        indexes?: string[];
+        blobs?: string[];
+        doubles?: number[];
+    }): void;
+}

package/dist/points.js

@@ -0,0 +1 @@
+export {};

package/dist/queries.d.ts

@@ -0,0 +1,75 @@
+import type { PointSink } from './points.js';
+export type QueryEngine = 'clickhouse' | 'd1' | 'do_sqlite' | 'r2_sql' | (string & {});
+export interface QueryCaller {
+    /** The app, or the part of it, the query ran for. */
+    app: string;
+    /** fetch, cron, queue, alarm, ws or do. */
+    kind: string;
+    /** A route (folded path), or the job's name. */
+    route: string;
+    tool?: string;
+}
+export interface QueryPoint {
+    engine: QueryEngine;
+    /** The SQL as sent; only its normalized shape is written. */
+    sql: string;
+    /** How it was called: query, insert (ClickHouse); all, first, run, raw, batch (D1); exec. */
+    method: string;
+    ok: boolean;
+    /** Wall time in the Worker, ms (request to last byte). */
+    ms: number;
+    /** The engine's own time, ms, where it says. */
+    engineMs?: number;
+    rowsRead?: number;
+    bytesRead?: number;
+    /** Rows the query returned. */
+    rowsOut?: number;
+    rowsWritten?: number;
+    /** Response bytes (ClickHouse). */
+    bytesOut?: number;
+    /** HTTP status (ClickHouse). */
+    status?: number;
+    /** Defaults to the request or job in scope. */
+    caller?: QueryCaller;
+}
+/** The entry point sets the dataset once per isolate. */
+export declare function setQuerySink(s: PointSink | undefined): void;
+/** How to name the request in scope when no job is (the app's request telemetry). */
+export declare function setQueryCallerOf(f: (() => QueryCaller | undefined) | undefined): void;
+/** Runs `fn` with `caller` as the caller of every query inside (cron runs, queue batches, alarms). */
+export declare function withQueryCaller<T>(caller: QueryCaller, fn: () => T): T;
+/** Id-like path segments become `:id`, so a route never carries an id. */
+export declare const foldRoute: (path: string) => string;
+export interface QueryShape {
+    /** The SQL with every literal as `?`, lists folded, comments and the output format dropped. */
+    text: string;
+    /** A hash of `text`: one per query shape. */
+    fingerprint: string;
+    /** select, insert, update, delete, ddl, pragma or other. */
+    op: string;
+}
+/** The query's shape: no literal survives, so no value or person's data is ever written. */
+export declare function queryShape(sql: string): QueryShape;
+/**
+ * Column order is the contract with whoever reads the dataset back: index1 engine; blobs
+ * engine, app, kind, route, tool, op, fingerprint, sql shape, outcome, method; doubles wall ms,
+ * engine ms, rows read, bytes read, rows out, rows written, bytes out, status.
+ */
+export declare function meterQuery(p: QueryPoint): void;
+/** The D1 binding, metered: one point per statement, a batch's each with its own meta. */
+export declare function meteredD1<T>(db: T | undefined): T | undefined;
+type Fetch = (input: Request | string | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * The ClickHouse VPC binding, metered. The point is written when the caller has read the whole
+ * answer: wall time to the last byte, and the `statistics` ClickHouse puts at the end of a JSON
+ * answer (rows and bytes read, its own time), else the summary header.
+ */
+export declare function meteredClickHouse<T extends {
+    fetch: Fetch;
+}>(binding: T | undefined): T | undefined;
+/**
+ * A Durable Object's `storage.sql`, metered for `caller`. Each statement is read to the end at
+ * `exec`, so its rows read and written are known; callers read rows only through `toArray`.
+ */
+export declare function meteredSql<T>(sql: T, caller: QueryCaller): T;
+export {};

package/dist/queries.js

@@ -0,0 +1,412 @@
+/**
+ * The query meter: every data query an app runs is one Analytics Engine point, with the engine it
+ * ran on, the query's shape and what it cost, so slow and heavy queries can be found and fixed.
+ *
+ * It sits on the bindings, not the call sites: wrap D1 with `meteredD1`, a ClickHouse HTTP service
+ * with `meteredClickHouse` and a Durable Object's SQLite with `meteredSql` once at start, and every
+ * query through them is metered without opting in. Another engine calls `meterQuery` from its one
+ * client.
+ *
+ * A point holds the query's shape only: string and number literals become `?` and `IN` lists fold,
+ * so no value, id or person's data is ever written. The caller is the app, route and tool of the
+ * request (or the cron job, queue batch or alarm) it ran in: `withQueryCaller` names a job, and
+ * `setQueryCallerOf` tells the meter how to name the request in scope.
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+let sink;
+let callerOf;
+const scope = new AsyncLocalStorage();
+/** The entry point sets the dataset once per isolate. */
+export function setQuerySink(s) {
+    sink = s;
+}
+/** How to name the request in scope when no job is (the app's request telemetry). */
+export function setQueryCallerOf(f) {
+    callerOf = f;
+}
+/** Runs `fn` with `caller` as the caller of every query inside (cron runs, queue batches, alarms). */
+export function withQueryCaller(caller, fn) {
+    return scope.run(caller, fn);
+}
+function currentCaller() {
+    const job = scope.getStore();
+    if (job)
+        return job;
+    try {
+        const c = callerOf?.();
+        if (c)
+            return c;
+    }
+    catch { }
+    return { app: 'other', kind: 'other', route: '' };
+}
+/** Id-like path segments become `:id`, so a route never carries an id. */
+export const foldRoute = (path) => path
+    .replace(/^\/api\/v1(?=\/|$)/, '/api')
+    .split('/')
+    .map((seg) => /^[a-z]{1,3}_[A-Za-z0-9]+$/.test(seg) ||
+    seg.length >= 20 ||
+    (seg.length >= 8 && /\d/.test(seg))
+    ? ':id'
+    : seg)
+    .join('/');
+const SQL_CAP = 1024;
+const shapes = new Map();
+const fnv = (s, seed) => {
+    let h = seed >>> 0;
+    for (let i = 0; i < s.length; i++)
+        h = Math.imul(h ^ s.charCodeAt(i), 16777619) >>> 0;
+    return h.toString(16).padStart(8, '0');
+};
+/** The query's shape: no literal survives, so no value or person's data is ever written. */
+export function queryShape(sql) {
+    const known = shapes.get(sql);
+    if (known)
+        return known;
+    let s = sql;
+    // An insert's rows ride after its FORMAT line; only the statement is kept.
+    const insert = /^\s*INSERT\b/i.test(s);
+    if (insert)
+        s = s.split('\n', 1)[0] ?? '';
+    s = s
+        .replace(/--[^\n]*/g, ' ')
+        .replace(/\/\*[\s\S]*?\*\//g, ' ')
+        .replace(/'(?:[^'\\]|\\.|'')*'/g, '?')
+        .replace(/(?<![\w$.])\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/gi, '?')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!insert)
+        s = s.replace(/\s+FORMAT\s+\w+\s*$/i, '');
+    s = s
+        .replace(/\(\s*\?(?:\s*,\s*\?)+\s*\)/g, '(?...)')
+        .replace(/\[\s*\?(?:\s*,\s*\?)+\s*\]/g, '[?...]')
+        .replace(/\(\?\.\.\.\)(?:\s*,\s*\(\?\.\.\.\))+/g, '(?...),...');
+    const head = (s.match(/^\(?\s*(\w+)/)?.[1] ?? '').toUpperCase();
+    const op = head === 'SELECT' || head === 'WITH'
+        ? 'select'
+        : head === 'INSERT' || head === 'REPLACE'
+            ? 'insert'
+            : head === 'UPDATE'
+                ? 'update'
+                : head === 'DELETE'
+                    ? 'delete'
+                    : head === 'CREATE' || head === 'ALTER' || head === 'DROP'
+                        ? 'ddl'
+                        : head === 'PRAGMA'
+                            ? 'pragma'
+                            : 'other';
+    const shape = {
+        text: s.slice(0, SQL_CAP),
+        fingerprint: fnv(s, 2166136261) + fnv(s, 0x9e3779b9),
+        op,
+    };
+    if (shapes.size >= 1000)
+        shapes.clear();
+    shapes.set(sql, shape);
+    return shape;
+}
+const cap = (s, n = 96) => (s.length > n ? s.slice(0, n) : s);
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : Number(v) || 0);
+/**
+ * Column order is the contract with whoever reads the dataset back: index1 engine; blobs
+ * engine, app, kind, route, tool, op, fingerprint, sql shape, outcome, method; doubles wall ms,
+ * engine ms, rows read, bytes read, rows out, rows written, bytes out, status.
+ */
+export function meterQuery(p) {
+    if (!sink)
+        return;
+    try {
+        const shape = queryShape(p.sql);
+        const c = p.caller ?? currentCaller();
+        sink.writeDataPoint({
+            indexes: [p.engine],
+            blobs: [
+                p.engine,
+                cap(c.app),
+                cap(c.kind),
+                cap(c.route),
+                cap(c.tool ?? ''),
+                shape.op,
+                shape.fingerprint,
+                shape.text,
+                p.ok ? 'ok' : 'error',
+                p.method,
+            ],
+            doubles: [
+                p.ms,
+                num(p.engineMs),
+                num(p.rowsRead),
+                num(p.bytesRead),
+                num(p.rowsOut),
+                num(p.rowsWritten),
+                num(p.bytesOut),
+                num(p.status),
+            ],
+        });
+    }
+    catch (err) {
+        console.error('meterQuery', err);
+    }
+}
+const d1Point = (sql, method, ms, r) => meterQuery({
+    engine: 'd1',
+    sql,
+    method,
+    ok: Boolean(r),
+    ms,
+    engineMs: r?.meta?.duration,
+    rowsRead: r?.meta?.rows_read,
+    rowsWritten: r?.meta?.rows_written,
+    rowsOut: r?.results?.length,
+});
+class MeteredStatement {
+    native;
+    sql;
+    constructor(native, sql) {
+        this.native = native;
+        this.sql = sql;
+    }
+    bind(...values) {
+        return new MeteredStatement(this.native.bind(...values), this.sql);
+    }
+    async timed(method, run) {
+        const t0 = performance.now();
+        try {
+            const r = await run();
+            d1Point(this.sql, method, performance.now() - t0, r);
+            return r;
+        }
+        catch (err) {
+            d1Point(this.sql, method, performance.now() - t0);
+            throw err;
+        }
+    }
+    all() {
+        return this.timed('all', () => this.native.all());
+    }
+    run() {
+        return this.timed('run', () => this.native.run());
+    }
+    /** D1's own `first` is `all` and its first row; through `all` it carries rows read. */
+    async first(column) {
+        const r = await this.timed('first', () => this.native.all());
+        const row = (r.results?.[0] ?? null);
+        if (!row || column === undefined)
+            return row;
+        if (!(column in row))
+            throw new Error(`D1_COLUMN_NOTFOUND: Column not found (${column})`);
+        return row[column];
+    }
+    async raw(opts) {
+        const t0 = performance.now();
+        let ok = false;
+        try {
+            const rows = await this.native.raw(opts);
+            ok = true;
+            return rows;
+        }
+        finally {
+            meterQuery({ engine: 'd1', sql: this.sql, method: 'raw', ok, ms: performance.now() - t0 });
+        }
+    }
+}
+/** The D1 binding, metered: one point per statement, a batch's each with its own meta. */
+export function meteredD1(db) {
+    if (!db)
+        return db;
+    const native = db;
+    return new Proxy(native, {
+        get(target, prop, receiver) {
+            if (prop === 'prepare')
+                return (sql) => new MeteredStatement(target.prepare(sql), sql);
+            if (prop === 'batch')
+                return async (stmts) => {
+                    const t0 = performance.now();
+                    const unwrap = stmts.map((s) => (s instanceof MeteredStatement ? s.native : s));
+                    const sqls = stmts.map((s) => (s instanceof MeteredStatement ? s.sql : ''));
+                    try {
+                        const rs = await target.batch(unwrap);
+                        const each = (performance.now() - t0) / Math.max(1, rs.length);
+                        rs.forEach((r, i) => d1Point(sqls[i] ?? '', 'batch', each, r));
+                        return rs;
+                    }
+                    catch (err) {
+                        const each = (performance.now() - t0) / Math.max(1, sqls.length);
+                        for (const sql of sqls)
+                            d1Point(sql, 'batch', each);
+                        throw err;
+                    }
+                };
+            const v = Reflect.get(target, prop, receiver);
+            return typeof v === 'function' ? v.bind(target) : v;
+        },
+    });
+}
+const STATS_RE = /"statistics"\s*:\s*\{\s*"elapsed"\s*:\s*([\d.e+-]+)\s*,\s*"rows_read"\s*:\s*(\d+)\s*,\s*"bytes_read"\s*:\s*(\d+)/;
+const ROWS_RE = /"rows"\s*:\s*(\d+)\s*,/g;
+/** `X-ClickHouse-Summary`: what the server knew when it sent the headers. */
+function summaryOf(res) {
+    try {
+        const s = JSON.parse(res.headers.get('x-clickhouse-summary') ?? '{}');
+        return {
+            rowsRead: num(s.read_rows),
+            bytesRead: num(s.read_bytes),
+            rowsWritten: num(s.written_rows),
+            rowsOut: s.result_rows === undefined ? undefined : num(s.result_rows),
+            engineMs: s.elapsed_ns === undefined ? undefined : num(s.elapsed_ns) / 1e6,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+const sqlOf = (input, init) => {
+    if (typeof init?.body === 'string')
+        return init.body;
+    try {
+        return new URL(input instanceof Request ? input.url : String(input)).searchParams.get('query');
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * The ClickHouse VPC binding, metered. The point is written when the caller has read the whole
+ * answer: wall time to the last byte, and the `statistics` ClickHouse puts at the end of a JSON
+ * answer (rows and bytes read, its own time), else the summary header.
+ */
+export function meteredClickHouse(binding) {
+    if (!binding)
+        return binding;
+    const fetchMetered = async (input, init) => {
+        const sql = sqlOf(input, init);
+        if (!sql)
+            return binding.fetch(input, init);
+        const method = /^\s*INSERT\b/i.test(sql) ? 'insert' : 'query';
+        const t0 = performance.now();
+        const caller = currentCaller();
+        let res;
+        try {
+            res = await binding.fetch(input, init);
+        }
+        catch (err) {
+            meterQuery({
+                engine: 'clickhouse',
+                sql,
+                method,
+                ok: false,
+                ms: performance.now() - t0,
+                caller,
+            });
+            throw err;
+        }
+        const head = summaryOf(res);
+        if (!res.ok || !res.body) {
+            meterQuery({
+                engine: 'clickhouse',
+                sql,
+                method,
+                ok: res.ok,
+                ms: performance.now() - t0,
+                status: res.status,
+                caller,
+                ...head,
+            });
+            return res;
+        }
+        let bytes = 0;
+        let tail = new Uint8Array(0);
+        const counted = res.body.pipeThrough(new TransformStream({
+            transform(chunk, ctl) {
+                bytes += chunk.byteLength;
+                // Keep the last 1 KB: the answer's `rows` and `statistics` close it.
+                const joined = new Uint8Array(tail.byteLength + chunk.byteLength);
+                joined.set(tail, 0);
+                joined.set(chunk, tail.byteLength);
+                tail = joined.subarray(Math.max(0, joined.byteLength - 1024));
+                ctl.enqueue(chunk);
+            },
+            flush() {
+                const text = new TextDecoder().decode(tail);
+                const st = text.match(STATS_RE);
+                const rows = [...text.matchAll(ROWS_RE)].pop();
+                meterQuery({
+                    engine: 'clickhouse',
+                    sql,
+                    method,
+                    ok: true,
+                    ms: performance.now() - t0,
+                    status: res.status,
+                    bytesOut: bytes,
+                    caller,
+                    ...head,
+                    ...(rows ? { rowsOut: num(rows[1]) } : {}),
+                    ...(st
+                        ? { engineMs: num(st[1]) * 1000, rowsRead: num(st[2]), bytesRead: num(st[3]) }
+                        : {}),
+                });
+            },
+        }));
+        return new Response(counted, {
+            status: res.status,
+            statusText: res.statusText,
+            headers: res.headers,
+        });
+    };
+    return new Proxy(binding, {
+        get(target, prop, receiver) {
+            if (prop === 'fetch')
+                return fetchMetered;
+            const v = Reflect.get(target, prop, receiver);
+            return typeof v === 'function' ? v.bind(target) : v;
+        },
+    });
+}
+/**
+ * A Durable Object's `storage.sql`, metered for `caller`. Each statement is read to the end at
+ * `exec`, so its rows read and written are known; callers read rows only through `toArray`.
+ */
+export function meteredSql(sql, caller) {
+    const native = sql;
+    return new Proxy(native, {
+        get(target, prop, receiver) {
+            if (prop === 'exec')
+                return (query, ...bindings) => {
+                    const t0 = performance.now();
+                    try {
+                        const cursor = target.exec(query, ...bindings);
+                        const rows = cursor.toArray();
+                        meterQuery({
+                            engine: 'do_sqlite',
+                            sql: query,
+                            method: 'exec',
+                            ok: true,
+                            ms: performance.now() - t0,
+                            rowsRead: cursor.rowsRead,
+                            rowsWritten: cursor.rowsWritten,
+                            rowsOut: rows.length,
+                            caller,
+                        });
+                        return {
+                            toArray: () => rows,
+                            rowsRead: cursor.rowsRead,
+                            rowsWritten: cursor.rowsWritten,
+                        };
+                    }
+                    catch (err) {
+                        meterQuery({
+                            engine: 'do_sqlite',
+                            sql: query,
+                            method: 'exec',
+                            ok: false,
+                            ms: performance.now() - t0,
+                            caller,
+                        });
+                        throw err;
+                    }
+                };
+            const v = Reflect.get(target, prop, receiver);
+            return typeof v === 'function' ? v.bind(target) : v;
+        },
+    });
+}

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@columenlabs/lumen-ops",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.35",
+  "description": "Lumen's ops meters: every data query an app runs as one Analytics Engine point, by its shape only.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./points": {
+      "types": "./dist/points.d.ts",
+      "default": "./dist/points.js"
+    },
+    "./queries": {
+      "types": "./dist/queries.d.ts",
+      "default": "./dist/queries.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "homepage": "https://github.com/columenlabs/lumen",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/columenlabs/lumen.git",
+    "directory": "packages/ops"
+  },
+  "bugs": "https://github.com/columenlabs/lumen/issues",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {}
+}