@moblog/browser 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,84 @@
-# Temporary Holding Version
+# @moblog/browser
 
-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.
+Send logs and errors from web pages to [moblog](https://moblog.dev). About 3.3 KB gzipped, no dependencies.
+
+```sh
+npm install @moblog/browser
+```
+
+```ts
+import * as moblog from "@moblog/browser";
+
+moblog.init({
+  key: "mob_ingest_...", // an ingest key that allows this site
+  release: "2.4.1", // or a git SHA
+  environment: "production",
+});
+
+moblog.info("checkout opened", { cart: { items: 3 } });
+moblog.setUser("user-48213"); // undefined when they sign out
+
+try {
+  await pay();
+} catch (err) {
+  moblog.captureError(err, { provider: "stripe" });
+}
+```
+
+## The key
+
+Use an **ingest key** (`mob_ingest_...`): it can only send events, so it is safe in a page, which makes it public. Allow your sites on it, in the web app's Keys page or with `moblog keys update <id> --add-site https://app.example.com`: requests from other sites are refused. A secret key (`mob_secret_...`) is never sent: the SDK refuses it.
+
+If your site sets a Content Security Policy, allow the ingest host in `connect-src`.
+
+## What it sends
+
+- Your events, with the level, the page's path (the server drops query strings and masks IDs: `/orders/:id`), a session ID and the event's place in the session.
+- Uncaught errors and unhandled promise rejections, with their stacks (`captureErrors: false` turns this off). The same error repeated within 5 seconds is sent once, and at most 30 errors a minute.
+- A "page view" event when the path changes, in single-page apps too (`trackPages: false`).
+- The browser, system and kind of device, which the server reads from the user agent (and doesn't store). An anonymous random device ID, kept in `localStorage`. The language and time zone.
+
+No cookies. With `persist: false`, nothing is written to `localStorage` or `sessionStorage`: the device ID and unsent events last as long as the page.
+
+## Options
+
+| Option | Default | |
+|---|---|---|
+| `key` | required | an ingest key |
+| `endpoint` | `https://ingest.moblog.dev` | the ingest URL (beta: `https://ingest.beta.moblog.dev`) |
+| `app` | the page's host | the app's ID |
+| `release`, `environment` | | the deployed version and its environment |
+| `level` | `"info"` | the least severe level sent |
+| `beforeSend` | | `(event) => event \| null`: change an event or drop it, before it is queued. A filter that throws drops the event. |
+| `captureErrors` | `true` | uncaught errors and unhandled rejections |
+| `captureConsole` | `false` | `true` for `console.warn` and `console.error`, or a list of levels |
+| `trackPages` | `true` | a page view when the path changes |
+| `persist` | `true` | keep the device ID and unsent events in storage |
+| `flushInterval` | `5000` | ms between sends |
+| `sessionTimeout` | `30` | minutes without events that end a session |
+
+## Delivery
+
+Events are queued and sent every few seconds, or at 100 events. Failed sends are retried with backoff (`Retry-After` is respected), keeping the batch's ID, so a retried batch is stored once. Up to 1,000 unsent events are kept, the newest. When the page is hidden or closed, what is queued goes through `navigator.sendBeacon`; what the browser won't take is kept in `localStorage` and sent on the next visit. When the organization is over its monthly quota, only errors are sent until it resets.
+
+`await moblog.flush()` sends what is queued now; `client.shutdown()` stops capturing and sends what is left. Calling `init` on the server (a server render) does nothing.
+
+## More than one client
+
+```ts
+import { Client } from "@moblog/browser";
+const other = new Client({ key: "mob_ingest_...", trackPages: false, captureErrors: false });
+other.log("warn", "from a widget");
+```
+
+## Developing
+
+`pnpm test` (unit tests, jsdom), `pnpm build`, `pnpm size` (fails above 5 KB gzipped), `pnpm e2e` (Chromium: a page on one origin, an ingest stand-in on another).
+
+## Publishing
+
+Published by hand, from an up-to-date `main`, by a member of the npm organization `moblog`:
+
+1. Set the version in `package.json` and `VERSION` in `src/client.ts` (a test checks they match), add it to `CHANGELOG.md`, and merge that.
+2. `npm login` (once), then from `packages/browser`: `npm publish`. It runs the type check, the tests, the build and the size check first (`prepublishOnly`); `npm publish --dry-run` shows what would be sent.
+3. Tag the commit: `git tag browser-v0.1.1 && git push origin browser-v0.1.1`.

package/dist/client.d.ts

@@ -0,0 +1,54 @@
+import type { Attributes, Level, Options } from "./types";
+export declare const VERSION = "0.1.1";
+/** A moblog client: queues events, sends them in batches, and keeps them until they are stored. */
+export declare class Client {
+    private readonly o;
+    private readonly url;
+    private readonly local;
+    private readonly tab;
+    private readonly device;
+    private readonly on;
+    private queue;
+    private batches;
+    private inflight?;
+    private retryAt;
+    private backoff;
+    private quotaUntil;
+    private sess?;
+    private user?;
+    private attrs;
+    private page;
+    private errors;
+    private lastError;
+    private inConsole;
+    private readonly warned;
+    private readonly undo;
+    private readonly say;
+    constructor(options: Options);
+    /** Queues an event. */
+    log(level: Level, message: unknown, attributes?: Attributes): void;
+    /** Queues an error event with its stack. */
+    captureError(error: unknown, attributes?: Attributes): void;
+    /** The signed-in user's ID for the next events; undefined when they sign out. */
+    setUser(id: string | undefined): void;
+    /** Attributes added to every next event. */
+    setAttributes(attributes: Attributes): void;
+    /** Sends what is queued; resolves when there is nothing left to send now. */
+    flush(): Promise<void>;
+    /** Stops capturing and sends what is left. */
+    shutdown(): Promise<void>;
+    private capture;
+    private pageView;
+    private wrapConsole;
+    private listen;
+    private session;
+    private trim;
+    private batchUp;
+    private save;
+    private body;
+    /** Sends a batch: true when it is done with (stored or refused for good), false to retry later. */
+    private send;
+    private later;
+    /** The page is going away: hand what is queued to the browser, which sends it after the page is gone. */
+    private beacon;
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { Client } from "./client";
+import type { Attributes, Level, Options } from "./types";
+export { Client, VERSION } from "./client";
+export type { Attributes, Level, MoblogEvent, Options } from "./types";
+/** Starts sending: call once, as early as the page can. A second call replaces the first client. */
+export declare function init(options: Options): Client;
+export declare const log: (level: Level, message: unknown, attributes?: Attributes) => void | undefined;
+export declare const debug: (message: unknown, attributes?: Attributes) => void | undefined;
+export declare const info: (message: unknown, attributes?: Attributes) => void | undefined;
+export declare const warn: (message: unknown, attributes?: Attributes) => void | undefined;
+export declare const error: (message: unknown, attributes?: Attributes) => void | undefined;
+export declare const captureError: (err: unknown, attributes?: Attributes) => void | undefined;
+export declare const setUser: (id: string | undefined) => void | undefined;
+export declare const setAttributes: (attributes: Attributes) => void | undefined;
+export declare const flush: () => Promise<void>;

package/dist/index.js

@@ -0,0 +1,383 @@
+//#region src/util.ts
+/** A random UUID; crypto.randomUUID needs a secure context, getRandomValues doesn't. */
+function uuid() {
+	if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	return format(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16)), 64);
+}
+/** A UUIDv7: the time in Unix milliseconds, then random bits, so IDs sort by when they were made. */
+function uuid7(ms) {
+	const b = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+	const t = Number.isFinite(ms) && ms > 0 ? Math.floor(ms) : 0;
+	for (let i = 0; i < 6; i++) b[i] = Math.floor(t / 2 ** (40 - 8 * i)) % 256;
+	return format(b, 112);
+}
+/** 16 bytes as a UUID of a version (0x40, 0x70), with RFC 9562's variant. */
+function format(b, version) {
+	b[6] = b[6] & 15 | version;
+	b[8] = b[8] & 63 | 128;
+	const h = Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+	return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+/** Storage that may be missing (privacy modes, sandboxed frames) or full: failures are ignored. */
+function store(kind, on) {
+	let s;
+	try {
+		s = on ? window[kind] : void 0;
+	} catch {}
+	const mem = /* @__PURE__ */ new Map();
+	return {
+		get(k) {
+			try {
+				return s ? s.getItem(k) : mem.get(k) ?? null;
+			} catch {
+				return null;
+			}
+		},
+		set(k, v) {
+			try {
+				if (s) s.setItem(k, v);
+				else mem.set(k, v);
+			} catch {
+				try {
+					s?.removeItem(k);
+				} catch {}
+			}
+		}
+	};
+}
+/** JSON.parse that answers undefined instead of throwing. */
+function parse(s) {
+	try {
+		return s ? JSON.parse(s) : void 0;
+	} catch {
+		return;
+	}
+}
+/** A value as text for a message: strings as they are, errors by name and message, the rest as JSON. */
+function text(v) {
+	if (typeof v === "string") return v;
+	if (v instanceof Error) return `${v.name}: ${v.message}`;
+	try {
+		return JSON.stringify(v) ?? String(v);
+	} catch {
+		return String(v);
+	}
+}
+//#endregion
+//#region src/client.ts
+var VERSION = "0.1.1";
+var LEVELS = [
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal"
+];
+var MAX_QUEUE = 1e3;
+var MAX_BATCH = 100;
+var MAX_BODY = 6e4;
+var MAX_TEXT = 8e3;
+var ERRORS_PER_MINUTE = 30;
+var rank = (l) => LEVELS.indexOf(l);
+/** Whether a body fits keepalive and beacon requests (counted in UTF-8 bytes). */
+var small = (body) => body.length * 3 < MAX_BODY || new TextEncoder().encode(body).length < MAX_BODY;
+/** A moblog client: queues events, sends them in batches, and keeps them until they are stored. */
+var Client = class {
+	constructor(options) {
+		this.queue = [];
+		this.batches = [];
+		this.retryAt = 0;
+		this.backoff = 0;
+		this.quotaUntil = 0;
+		this.attrs = {};
+		this.page = "";
+		this.errors = [];
+		this.lastError = /* @__PURE__ */ new Map();
+		this.inConsole = false;
+		this.warned = /* @__PURE__ */ new Set();
+		this.undo = [];
+		this.say = typeof console === "undefined" ? () => {} : console.warn.bind(console);
+		this.o = options;
+		this.url = `${(options.endpoint ?? "https://ingest.moblog.dev").replace(/\/+$/, "")}/v1/ingest`;
+		const persist = options.persist !== false;
+		this.local = store("localStorage", persist);
+		this.tab = store("sessionStorage", persist);
+		this.device = this.local.get("moblog.device") ?? uuid();
+		this.local.set("moblog.device", this.device);
+		this.on = typeof window !== "undefined" && /^mob_ingest_/.test(options.key);
+		if (!this.on) {
+			if (typeof window !== "undefined") this.say("moblog: use an ingest key (mob_ingest_...); nothing is sent");
+			return;
+		}
+		this.batches = parse(this.local.get("moblog.queue")) ?? [];
+		const every = setInterval(() => void this.flush(), options.flushInterval ?? 5e3);
+		this.undo.push(() => clearInterval(every));
+		const hidden = () => document.visibilityState === "hidden" && this.beacon();
+		this.listen(document, "visibilitychange", hidden);
+		this.listen(window, "pagehide", () => this.beacon());
+		if (options.captureErrors !== false) {
+			this.listen(window, "error", (e) => {
+				const ev = e;
+				this.capture(ev.error ?? ev.message, ev.filename ? { "error.source": `${ev.filename}:${ev.lineno}:${ev.colno}` } : {});
+			});
+			this.listen(window, "unhandledrejection", (e) => this.capture(e.reason, {}, "Unhandled rejection: "));
+		}
+		const c = options.captureConsole;
+		for (const lv of c === true ? ["warn", "error"] : c || []) this.wrapConsole(lv);
+		if (options.trackPages !== false) {
+			const track = () => this.pageView();
+			for (const m of ["pushState", "replaceState"]) {
+				const orig = history[m];
+				history[m] = function(...args) {
+					orig.apply(this, args);
+					track();
+				};
+				this.undo.push(() => {
+					history[m] = orig;
+				});
+			}
+			this.listen(window, "popstate", track);
+			track();
+		}
+		if (this.batches.length) this.flush();
+	}
+	/** Queues an event. */
+	log(level, message, attributes) {
+		if (!this.on || rank(level) < rank(this.o.level ?? "info")) return;
+		if (Date.now() < this.quotaUntil && rank(level) < rank("error")) return;
+		const s = this.session();
+		const attrs = {
+			...this.attrs,
+			...attributes
+		};
+		let e = {
+			timestamp: Date.now(),
+			level,
+			message: text(message).slice(0, MAX_TEXT),
+			session_id: s.id,
+			seq: s.seq++,
+			page: location.pathname,
+			user_id: this.user,
+			attributes: Object.keys(attrs).length ? attrs : void 0
+		};
+		this.tab.set("moblog.session", JSON.stringify(s));
+		if (this.o.beforeSend) try {
+			e = this.o.beforeSend(e);
+		} catch {
+			e = null;
+		}
+		if (!e) return;
+		if (!e.event_id) e.event_id = uuid7(e.timestamp);
+		try {
+			JSON.stringify(e);
+		} catch {
+			e.attributes = { "moblog.error": "attributes are not JSON" };
+		}
+		this.queue.push(e);
+		this.trim();
+		if (this.queue.length >= MAX_BATCH) this.flush();
+	}
+	/** Queues an error event with its stack. */
+	captureError(error, attributes) {
+		this.capture(error, attributes ?? {});
+	}
+	/** The signed-in user's ID for the next events; undefined when they sign out. */
+	setUser(id) {
+		this.user = id;
+	}
+	/** Attributes added to every next event. */
+	setAttributes(attributes) {
+		this.attrs = {
+			...this.attrs,
+			...attributes
+		};
+	}
+	/** Sends what is queued; resolves when there is nothing left to send now. */
+	async flush() {
+		if (!this.on) return;
+		this.batchUp();
+		if (this.inflight || Date.now() < this.retryAt) return;
+		try {
+			for (let b = this.batches[0]; b; b = this.batches[0]) {
+				this.inflight = b;
+				if (!await this.send(b)) break;
+				this.batches = this.batches.filter((x) => x !== b);
+			}
+		} finally {
+			this.inflight = void 0;
+			this.save();
+		}
+	}
+	/** Stops capturing and sends what is left. */
+	shutdown() {
+		for (const f of this.undo.splice(0)) f();
+		return this.flush();
+	}
+	capture(error, attributes, prefix = "") {
+		const now = Date.now();
+		const message = prefix + text(error);
+		if (now - (this.lastError.get(message) ?? 0) < 5e3) return;
+		this.errors = this.errors.filter((t) => now - t < 6e4);
+		if (this.errors.length >= ERRORS_PER_MINUTE) return;
+		this.errors.push(now);
+		if (this.lastError.size > 100) this.lastError.clear();
+		this.lastError.set(message, now);
+		const err = error instanceof Error ? error : void 0;
+		this.log("error", message, {
+			"error.type": err?.name,
+			"error.stack": err?.stack?.slice(0, MAX_TEXT),
+			...attributes
+		});
+	}
+	pageView() {
+		const path = location.pathname;
+		if (path === this.page) return;
+		const from = this.page;
+		this.page = path;
+		this.log("info", "page view", from ? { "page.from": from } : void 0);
+	}
+	wrapConsole(lv) {
+		const orig = console[lv];
+		console[lv] = (...args) => {
+			orig.apply(console, args);
+			if (this.inConsole) return;
+			this.inConsole = true;
+			try {
+				this.log(lv, args.map(text).join(" "), { source: "console" });
+			} finally {
+				this.inConsole = false;
+			}
+		};
+		this.undo.push(() => {
+			console[lv] = orig;
+		});
+	}
+	listen(target, type, fn) {
+		target.addEventListener(type, fn);
+		this.undo.push(() => target.removeEventListener(type, fn));
+	}
+	session() {
+		const now = Date.now();
+		let s = this.sess ?? parse(this.tab.get("moblog.session"));
+		if (!s || now - s.last > (this.o.sessionTimeout ?? 30) * 6e4) s = {
+			id: uuid(),
+			last: now,
+			seq: 0
+		};
+		s.last = now;
+		this.sess = s;
+		return s;
+	}
+	trim() {
+		let over = this.queue.length + this.batches.reduce((n, b) => n + b.events.length, 0) - MAX_QUEUE;
+		for (const b of this.batches) {
+			if (over <= 0 || b === this.inflight) continue;
+			const n = Math.min(over, b.events.length);
+			b.events.splice(0, n);
+			over -= n;
+		}
+		this.batches = this.batches.filter((b) => b.events.length);
+		if (over > 0) this.queue.splice(0, over);
+	}
+	batchUp() {
+		while (this.queue.length) this.batches.push({
+			id: uuid(),
+			events: this.queue.splice(0, MAX_BATCH)
+		});
+	}
+	save() {
+		this.local.set("moblog.queue", JSON.stringify(this.batches));
+	}
+	body(b) {
+		return JSON.stringify({
+			batch_id: b.id,
+			sent_at: Date.now(),
+			resource: {
+				app: {
+					id: this.o.app ?? location.host,
+					version: this.o.release,
+					environment: this.o.environment
+				},
+				device: {
+					id: this.device,
+					platform: "web",
+					locale: navigator.language,
+					timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+				},
+				sdk: {
+					name: "moblog-browser",
+					version: VERSION
+				}
+			},
+			events: b.events
+		});
+	}
+	/** Sends a batch: true when it is done with (stored or refused for good), false to retry later. */
+	async send(b) {
+		const body = this.body(b);
+		let res;
+		try {
+			res = await fetch(this.url, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${this.o.key}`,
+					"Content-Type": "application/json"
+				},
+				body,
+				keepalive: small(body),
+				credentials: "omit"
+			});
+		} catch {
+			return this.later(0);
+		}
+		const reset = res.headers.get("Moblog-Quota-Reset");
+		this.quotaUntil = res.headers.get("Moblog-Quota") === "exceeded" && reset ? Date.parse(reset) || 0 : 0;
+		if (res.ok) {
+			this.backoff = 0;
+			return true;
+		}
+		if (res.status === 408 || res.status === 429 || res.status >= 500) return this.later(Number(res.headers.get("Retry-After")) * 1e3 || 0);
+		if (!this.warned.has(String(res.status))) {
+			this.warned.add(String(res.status));
+			this.say(`moblog: events refused (${res.status}): ${await res.text().catch(() => "")}`);
+		}
+		return true;
+	}
+	later(ms) {
+		this.backoff = Math.min(Math.max(this.backoff * 2, 1e3), 3e5);
+		this.retryAt = Date.now() + Math.max(ms, this.backoff);
+		return false;
+	}
+	/** The page is going away: hand what is queued to the browser, which sends it after the page is gone. */
+	beacon() {
+		this.batchUp();
+		const url = `${this.url}?key=${encodeURIComponent(this.o.key)}`;
+		this.batches = this.batches.filter((b) => {
+			if (b === this.inflight) return true;
+			const body = this.body(b);
+			return !(small(body) && navigator.sendBeacon?.(url, body));
+		});
+		this.save();
+	}
+};
+//#endregion
+//#region src/index.ts
+var client;
+/** Starts sending: call once, as early as the page can. A second call replaces the first client. */
+function init(options) {
+	client?.shutdown();
+	client = new Client(options);
+	return client;
+}
+var log = (level, message, attributes) => client?.log(level, message, attributes);
+var debug = (message, attributes) => log("debug", message, attributes);
+var info = (message, attributes) => log("info", message, attributes);
+var warn = (message, attributes) => log("warn", message, attributes);
+var error = (message, attributes) => log("error", message, attributes);
+var captureError = (err, attributes) => client?.captureError(err, attributes);
+var setUser = (id) => client?.setUser(id);
+var setAttributes = (attributes) => client?.setAttributes(attributes);
+var flush = () => client?.flush() ?? Promise.resolve();
+//#endregion
+export { Client, VERSION, captureError, debug, error, flush, info, init, log, setAttributes, setUser, warn };

package/dist/types.d.ts

@@ -0,0 +1,49 @@
+export type Level = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+/** Attribute values: nested objects become dotted keys (cart.items) on the server. */
+export type Attributes = Record<string, unknown>;
+/** An event as it is sent; beforeSend may change it. */
+export interface MoblogEvent {
+    /** Unix milliseconds. */
+    timestamp: number;
+    /** A UUID the SDK gives the event after beforeSend (unless it set one): ingest stores an event once by it. */
+    event_id?: string;
+    level: Level;
+    message: string;
+    session_id: string;
+    /** Position in the session: orders events even when the clock is wrong. */
+    seq: number;
+    /** The page's path; the server drops query strings and masks IDs. */
+    page?: string;
+    user_id?: string;
+    attributes?: Attributes;
+}
+export interface Options {
+    /** An ingest key (mob_ingest_...) that allows this site. */
+    key: string;
+    /** The ingest URL. Default: https://ingest.moblog.dev */
+    endpoint?: string;
+    /** The app's ID, e.g. "shop-web". Default: the page's host. */
+    app?: string;
+    /** The deployed version, e.g. a git SHA or "2.4.1". */
+    release?: string;
+    environment?: string;
+    /** Change or drop (return null) each event before it is queued: remove personal data here. */
+    beforeSend?: (event: MoblogEvent) => MoblogEvent | null | undefined | false;
+    /** Least severe level sent. Default: "info". */
+    level?: Level;
+    /** Uncaught errors and unhandled promise rejections. Default: true. */
+    captureErrors?: boolean;
+    /** Also send console calls of these levels. Default: none. */
+    captureConsole?: boolean | Array<"debug" | "info" | "warn" | "error">;
+    /** An event when the page (path) changes, in single-page apps too. Default: true. */
+    trackPages?: boolean;
+    /**
+     * Keep an anonymous device ID and unsent events in localStorage, so they
+     * survive closing the tab. Default: true; false keeps them in memory only.
+     */
+    persist?: boolean;
+    /** How often queued events are sent, in milliseconds. Default: 5000. */
+    flushInterval?: number;
+    /** A session ends after this many minutes without events. Default: 30. */
+    sessionTimeout?: number;
+}

package/dist/util.d.ts

@@ -0,0 +1,14 @@
+/** A random UUID; crypto.randomUUID needs a secure context, getRandomValues doesn't. */
+export declare function uuid(): string;
+/** A UUIDv7: the time in Unix milliseconds, then random bits, so IDs sort by when they were made. */
+export declare function uuid7(ms: number): string;
+/** Storage that may be missing (privacy modes, sandboxed frames) or full: failures are ignored. */
+export declare function store(kind: "localStorage" | "sessionStorage", on: boolean): {
+    get(k: string): string | null;
+    set(k: string, v: string): void;
+};
+export type Store = ReturnType<typeof store>;
+/** JSON.parse that answers undefined instead of throwing. */
+export declare function parse<T>(s: string | null): T | undefined;
+/** A value as text for a message: strings as they are, errors by name and message, the rest as JSON. */
+export declare function text(v: unknown): string;

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@moblog/browser",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Send logs and errors from web pages to moblog.",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thiagodmont/moblog.git",
+    "directory": "packages/browser"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && vite build && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "size": "node scripts/size.mjs",
+    "e2e": "playwright test",
+    "prepublishOnly": "pnpm typecheck && pnpm test && pnpm build && pnpm size"
+  },
+  "devDependencies": {
+    "@playwright/test": "1.63.0",
+    "jsdom": "30.1.1",
+    "typescript": "7.0.2",
+    "vite": "8.3.4",
+    "vitest": "5.0.4"
+  }
+}