@rig-ts/presence 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,47 @@
+import { a as Person, c as PresenceTarget, d as sameTarget, i as createPresence, l as onTarget, n as PresenceHandle, o as PresenceActivity, r as PresenceSource, s as PresenceRow, t as PresenceArgs, u as personOfRow } from "./presence-B6KIBpNr.mjs";
+
+//#region src/session-key.d.ts
+/**
+ * This tab's name for itself, for as long as it is open.
+ *
+ * A module constant, and **not** `sessionStorage`, which is the answer that looks
+ * right. Storage would survive a reload — and there is nothing to survive for,
+ * because a reload sends its leave on the way out — while a duplicated tab in
+ * Chrome inherits a *copy* of `sessionStorage`. Two tabs would hold one key,
+ * write to one row, and overwrite each other's target on every beat, so one
+ * person would appear to teleport between the two things they were doing.
+ *
+ * In memory, every tab is a different tab, which is exactly what the server's
+ * unique key means by one.
+ */
+declare const SESSION_KEY: string;
+//#endregion
+//#region src/clock.d.ts
+/**
+ * Whether a row still means somebody is here.
+ *
+ * # The clock is the interesting part
+ *
+ * A browser cannot compare `seenAt` against `Date.now()`. Those are two different
+ * clocks, and a laptop five minutes fast shows an empty room while a slow one
+ * shows people who left. Deriving an offset from a response header would work and
+ * needs a seam the generated client does not have.
+ *
+ * It does not need one. **The freshest `seenAt` in the collection is itself a
+ * reading of the server's clock**, taken at most one heartbeat ago by whichever
+ * tab beat most recently — so comparing every row against the newest one instead
+ * of against the wall clock cancels the skew entirely. No offset, no header, no
+ * extra request.
+ *
+ * It has one blind spot, and it is the harmless one: when you are alone in the
+ * scope the only row is your own, so every comparison is against yourself and
+ * nobody expires. The answer that matters there is "there is nobody else here",
+ * which is what an empty list already says. `fallbackNow` is what your own last
+ * heartbeat answered with, for the case where the collection has arrived and you
+ * are not in it.
+ */
+declare function freshest(people: readonly Person[], fallbackNow?: string): number;
+/** Whether `person` is fresh, measured against a server-clock reading. */
+declare function isFresh(person: Person, now: number, ttlMs: number): boolean;
+//#endregion
+export { type Person, type PresenceActivity, type PresenceArgs, type PresenceHandle, type PresenceRow, type PresenceSource, type PresenceTarget, SESSION_KEY, createPresence, freshest, isFresh, onTarget, personOfRow, sameTarget };

package/dist/index.mjs

@@ -0,0 +1,349 @@
+//#region src/clock.ts
+/**
+* Whether a row still means somebody is here.
+*
+* # The clock is the interesting part
+*
+* A browser cannot compare `seenAt` against `Date.now()`. Those are two different
+* clocks, and a laptop five minutes fast shows an empty room while a slow one
+* shows people who left. Deriving an offset from a response header would work and
+* needs a seam the generated client does not have.
+*
+* It does not need one. **The freshest `seenAt` in the collection is itself a
+* reading of the server's clock**, taken at most one heartbeat ago by whichever
+* tab beat most recently — so comparing every row against the newest one instead
+* of against the wall clock cancels the skew entirely. No offset, no header, no
+* extra request.
+*
+* It has one blind spot, and it is the harmless one: when you are alone in the
+* scope the only row is your own, so every comparison is against yourself and
+* nobody expires. The answer that matters there is "there is nobody else here",
+* which is what an empty list already says. `fallbackNow` is what your own last
+* heartbeat answered with, for the case where the collection has arrived and you
+* are not in it.
+*/
+function freshest(people, fallbackNow) {
+	let newest = fallbackNow === void 0 ? 0 : Date.parse(fallbackNow);
+	for (const p of people) {
+		const at = Date.parse(p.seenAt);
+		if (at > newest) newest = at;
+	}
+	return newest;
+}
+/** Whether `person` is fresh, measured against a server-clock reading. */
+function isFresh(person, now, ttlMs) {
+	if (now === 0 || ttlMs === 0) return true;
+	return Date.parse(person.seenAt) > now - ttlMs;
+}
+//#endregion
+//#region src/session-key.ts
+/**
+* This tab's name for itself, for as long as it is open.
+*
+* A module constant, and **not** `sessionStorage`, which is the answer that looks
+* right. Storage would survive a reload — and there is nothing to survive for,
+* because a reload sends its leave on the way out — while a duplicated tab in
+* Chrome inherits a *copy* of `sessionStorage`. Two tabs would hold one key,
+* write to one row, and overwrite each other's target on every beat, so one
+* person would appear to teleport between the two things they were doing.
+*
+* In memory, every tab is a different tab, which is exactly what the server's
+* unique key means by one.
+*/
+const SESSION_KEY = randomKey();
+function randomKey() {
+	const c = globalThis.crypto;
+	if (c?.randomUUID !== void 0) return c.randomUUID();
+	return `tab-${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+//#endregion
+//#region src/transport.ts
+/**
+* Sends one heartbeat.
+*
+* Built on the runtime rather than on a generated method, for the reason
+* `web/src/auth` is hand-written in every rig front end: these routes are rig's
+* own, they sit outside `api.base_path`, and no generator writes them.
+*
+* **No retry, and that is deliberate.** A heartbeat that failed is not worth
+* repeating — the next one is seconds away — and the generated client names a
+* write it might repeat with an `Idempotency-Key`, which would have the server
+* record a row in `rig_idempotency` for every beat in the building.
+*/
+async function beat(runtime, path, body) {
+	const { res, authorization } = await send(runtime, path, "PUT", JSON.stringify(body));
+	if (!res.ok) throw new Error(`presence: heartbeat answered ${res.status}`);
+	return {
+		answer: await res.json(),
+		authorization
+	};
+}
+/**
+* Says this tab has gone.
+*
+* `keepalive` is the whole reason this is not a generated call: it is a request
+* the browser is allowed to finish after the page is gone, and no option on a
+* generated method asks for it.
+*
+* `sendBeacon` is not the alternative it looks like. It is POST-only, which would
+* be survivable, and it cannot set an `Authorization` header, which is not — so it
+* cannot authenticate at all.
+*/
+function leave(runtime, path, sessionKey, authorization) {
+	const headers = runtime.baseHeaders();
+	headers.set("Content-Type", "application/json");
+	if (authorization !== "") headers.set("Authorization", authorization);
+	runtime.fetch(runtime.url(path, void 0, void 0, true), {
+		method: "DELETE",
+		headers,
+		body: JSON.stringify({ sessionKey }),
+		keepalive: true
+	}).catch(() => {});
+}
+/**
+* Applies the credential and makes the call.
+*
+* The `Authorization` the credential produced is read back off the headers this
+* built and returned with the response, so that {@link Beat.authorization} costs
+* nothing: `apply` is called once per request, and asking a second time is not
+* a second read of the same value — with a session credential it is a second
+* run of the whole stale-check-and-exchange path.
+*/
+async function send(runtime, path, method, body) {
+	const headers = runtime.baseHeaders();
+	if (body !== void 0) headers.set("Content-Type", "application/json");
+	await runtime.getCredential()?.apply(headers);
+	const init = {
+		method,
+		headers
+	};
+	if (body !== void 0) init.body = body;
+	return {
+		res: await runtime.fetch(runtime.url(path, void 0, void 0, true), init),
+		authorization: headers.get("Authorization") ?? ""
+	};
+}
+/** Turns a target into the three optional fields the route takes. */
+function bodyOf(sessionKey, scope, target, activity) {
+	return {
+		sessionKey,
+		scope,
+		targetTable: target.table,
+		targetId: target.id,
+		targetField: target.field,
+		activity
+	};
+}
+//#endregion
+//#region src/types.ts
+/** Reads a streamed row as a [Person]. */
+function personOfRow(row) {
+	return {
+		id: row.id,
+		accountId: row.account_id,
+		sessionKey: row.session_key,
+		scope: row.scope,
+		target: {
+			table: row.target_table ?? void 0,
+			id: row.target_id ?? void 0,
+			field: row.target_field ?? void 0
+		},
+		activity: row.activity === "editing" ? "editing" : "viewing",
+		createdAt: row.created_at,
+		seenAt: row.seen_at
+	};
+}
+/** Whether a target is one a person is on, treating an absent field as a wildcard. */
+function onTarget(person, target) {
+	if (target.table !== void 0 && person.target.table !== target.table) return false;
+	if (target.id !== void 0 && person.target.id !== target.id) return false;
+	if (target.field !== void 0 && person.target.field !== target.field) return false;
+	return true;
+}
+/** Whether two targets say the same thing, so a repeated focus writes nothing. */
+function sameTarget(left, right) {
+	return left.table === right.table && left.id === right.id && left.field === right.field;
+}
+//#endregion
+//#region src/presence.ts
+/** Reads a teardown out of whatever a subscribe call answered with. */
+function unsubscribeOf(handle) {
+	if (typeof handle === "function") return handle;
+	if (typeof handle === "object" && handle !== null && typeof handle.unsubscribe === "function") return () => handle.unsubscribe();
+}
+const DEFAULT_PATH = "/presence";
+const DEFAULT_TICK_MS = 1e3;
+const DEFAULT_THROTTLE_MS = 500;
+/**
+* A target as one string, so it can key the answers above.
+*
+* The separator is a character nothing in a table name, a uuid or a column name
+* can hold, so two different targets cannot spell one key. "No target" — which
+* means everybody in the scope — gets a key of its own rather than the three
+* empty strings a target of `{}` would spell.
+*/
+function keyOf(target) {
+	if (target === void 0) return "*";
+	return [
+		target.table ?? "",
+		target.id ?? "",
+		target.field ?? ""
+	].join("\0");
+}
+/**
+* Whether two answers say the same thing, and so whether the previous array can
+* be handed back.
+*
+* Not identity — `others` maps a fresh person out of every row on every call, so
+* the objects always differ — and not a deep comparison either. What it compares
+* is what a caller draws: who is here, in what order, where, and doing what.
+*
+* **`seenAt` is deliberately not among them.** It moves on every heartbeat and
+* nothing renders it, so counting it would redraw every avatar in the room three
+* times a minute for no visible change. A person whose only change is a fresh
+* heartbeat is the same person.
+*/
+function sameAnswer(prev, next) {
+	if (prev.length !== next.length) return false;
+	for (let i = 0; i < next.length; i++) {
+		const a = prev[i];
+		const b = next[i];
+		if (a === void 0 || b === void 0 || a.id !== b.id || a.activity !== b.activity || a.target.table !== b.target.table || a.target.id !== b.target.id || a.target.field !== b.target.field) return false;
+	}
+	return true;
+}
+/**
+* Starts the presence loop for one tab.
+*
+* It owns six things, and each is a bug if the application owns it instead: the
+* heartbeat schedule, the write throttle, the clock, the tick that makes expiry
+* happen, the visibility rule, and the leave on teardown.
+*
+* **Nothing here is configured with a heartbeat interval.** The server answers
+* one on every beat and the loop re-beats at half of what is left, so changing
+* `presence.ttl` is a deploy of the server rather than a release of the front
+* end — and there is no copy of the number here to disagree with it.
+*/
+function createPresence(args) {
+	const { runtime, scope, stream, path = DEFAULT_PATH, sessionKey = SESSION_KEY, tickMs = DEFAULT_TICK_MS, throttleMs = DEFAULT_THROTTLE_MS } = args;
+	let target = {};
+	let activity = "viewing";
+	let sent;
+	let ttlMs = 0;
+	let heartbeatMs = 0;
+	let lastSeenAt;
+	let authorization = "";
+	let beatTimer;
+	let throttleTimer;
+	let tickTimer;
+	let closed = false;
+	const listeners = /* @__PURE__ */ new Set();
+	const notify = () => {
+		for (const fn of listeners) fn();
+	};
+	const answers = /* @__PURE__ */ new Map();
+	const rows = () => typeof stream.toArray === "function" ? stream.toArray() : stream.toArray;
+	async function write() {
+		if (closed) return;
+		const now = {
+			target,
+			activity
+		};
+		try {
+			const beaten = await beat(runtime, path, bodyOf(sessionKey, scope, now.target, now.activity));
+			if (closed) return;
+			sent = now;
+			lastSeenAt = beaten.answer.seenAt;
+			ttlMs = beaten.answer.ttlSeconds * 1e3;
+			heartbeatMs = beaten.answer.heartbeatSeconds * 1e3;
+			authorization = beaten.authorization;
+			notify();
+		} catch {}
+		schedule();
+	}
+	function schedule() {
+		if (closed || hidden()) return;
+		clearTimeout(beatTimer);
+		beatTimer = setTimeout(() => void write(), heartbeatMs === 0 ? 5e3 : Math.max(1e3, heartbeatMs));
+	}
+	function focus(next, act = "viewing") {
+		const wanted = next ?? {};
+		if (sent !== void 0 && sameTarget(sent.target, wanted) && sent.activity === act) return;
+		target = wanted;
+		activity = act;
+		if (throttleTimer !== void 0) return;
+		write();
+		throttleTimer = setTimeout(() => {
+			throttleTimer = void 0;
+			if (sent === void 0 || !sameTarget(sent.target, target) || sent.activity !== activity) write();
+		}, throttleMs);
+	}
+	function others(only) {
+		const people = rows().map(personOfRow);
+		const now = freshest(people, lastSeenAt);
+		const next = [];
+		for (const p of people) {
+			if (p.sessionKey === sessionKey) continue;
+			if (!isFresh(p, now, ttlMs)) continue;
+			if (only !== void 0 && !onTarget(p, only)) continue;
+			next.push(p);
+		}
+		next.sort((a, b) => b.seenAt.localeCompare(a.seenAt));
+		if (answers.size > 256) answers.clear();
+		const key = keyOf(only);
+		const prev = answers.get(key);
+		if (prev !== void 0 && sameAnswer(prev, next)) return prev;
+		answers.set(key, next);
+		return next;
+	}
+	function hidden() {
+		return globalThis.document?.visibilityState === "hidden";
+	}
+	function onVisibility() {
+		if (hidden()) {
+			stop();
+			sendLeave();
+			return;
+		}
+		sent = void 0;
+		write();
+	}
+	function sendLeave() {
+		leave(runtime, path, sessionKey, authorization);
+	}
+	function stop() {
+		clearTimeout(beatTimer);
+		clearTimeout(throttleTimer);
+		beatTimer = void 0;
+		throttleTimer = void 0;
+	}
+	const doc = globalThis.document;
+	const win = globalThis.window;
+	doc?.addEventListener("visibilitychange", onVisibility);
+	win?.addEventListener("pagehide", sendLeave);
+	const untap = stream.subscribeChanges === void 0 ? void 0 : unsubscribeOf(stream.subscribeChanges(notify));
+	tickTimer = setInterval(notify, tickMs);
+	if (!hidden()) write();
+	return {
+		focus,
+		others,
+		subscribe(fn) {
+			listeners.add(fn);
+			return () => listeners.delete(fn);
+		},
+		leave: sendLeave,
+		close() {
+			if (closed) return;
+			closed = true;
+			stop();
+			clearInterval(tickTimer);
+			untap?.();
+			doc?.removeEventListener("visibilitychange", onVisibility);
+			win?.removeEventListener("pagehide", sendLeave);
+			listeners.clear();
+			sendLeave();
+		}
+	};
+}
+//#endregion
+export { SESSION_KEY, createPresence, freshest, isFresh, onTarget, personOfRow, sameTarget };

package/dist/presence-B6KIBpNr.d.mts

@@ -0,0 +1,154 @@
+import { Runtime } from "@rig-ts/client";
+
+//#region src/types.d.ts
+/** What a browser tab says it is looking at. */
+type PresenceTarget = {
+  /** The table the row is in. Absent is the scope itself rather than a row in it. */table?: string | undefined; /** Which row. Absent with a table present is a list of them. */
+  id?: string | undefined; /** Which control has focus. Absent is looking rather than typing. */
+  field?: string | undefined;
+};
+/** Whether somebody is looking or typing. */
+type PresenceActivity = "viewing" | "editing";
+/**
+ * One presence, as this package reports it.
+ *
+ * camelCase, and normalising to it is most of what this package is for. The same
+ * row arrives two ways in a rig application and they do not agree about keys: the
+ * live shape carries Postgres column names, because nothing between the database
+ * and the browser rewrites them, while `GET /presence` answers what the
+ * hand-written route's Go struct declares. A caller should not have to know which
+ * door a row came through.
+ */
+type Person = {
+  id: string;
+  accountId: string; /** Which of that account's tabs this is. Two tabs are two people here. */
+  sessionKey: string;
+  scope: string;
+  target: PresenceTarget;
+  activity: PresenceActivity; /** When this tab first appeared. It does not move on a heartbeat. */
+  createdAt: string; /** The last heartbeat. Whether this row means somebody is here is a comparison against it. */
+  seenAt: string;
+};
+/**
+ * The shape of a streamed row, which is what the generated collection holds.
+ *
+ * Declared here rather than imported from a project's generated types so this
+ * package compiles on its own. A generated `RigPresenceRow` is assignable to it:
+ * the sync service sends every column on every row, with a null where the column
+ * is null, which is why the nullable members are nullable rather than optional.
+ */
+type PresenceRow = {
+  id: string;
+  tenant_id: string;
+  account_id: string;
+  session_key: string;
+  scope: string;
+  target_table: string | null;
+  target_id: string | null;
+  target_field: string | null;
+  activity: string;
+  created_at: string;
+  seen_at: string;
+};
+/** Reads a streamed row as a [Person]. */
+declare function personOfRow(row: PresenceRow): Person;
+/** Whether a target is one a person is on, treating an absent field as a wildcard. */
+declare function onTarget(person: Person, target: PresenceTarget): boolean;
+/** Whether two targets say the same thing, so a repeated focus writes nothing. */
+declare function sameTarget(left: PresenceTarget, right: PresenceTarget): boolean;
+//#endregion
+//#region src/presence.d.ts
+/**
+ * The minimum a collection has to look like for this package to read it.
+ *
+ * Structural rather than the collection type itself, which is what keeps this
+ * package from depending on `@tanstack/db` — and a project's sync stack has to
+ * exist exactly once, so a second copy pulled in here would be a collection
+ * nothing could read.
+ *
+ * `subscribeChanges` returns whatever the collection returns. TanStack DB hands
+ * back a subscription object with an `unsubscribe` method rather than the
+ * teardown function the name suggests, so both shapes are accepted and
+ * {@link unsubscribeOf} sorts them out.
+ */
+type PresenceSource = {
+  toArray: PresenceRow[] | (() => PresenceRow[]);
+  subscribeChanges?: (fn: () => void) => unknown;
+};
+/** What {@link createPresence} needs. */
+type PresenceArgs = {
+  /**
+   * The client the heartbeat authenticates through, and whose origin it
+   * resolves against. Taking the whole runtime rather than a base URL is what
+   * lets a `Session` refresh before a beat inherits a token about to expire.
+   */
+  runtime: Runtime;
+  /**
+   * Which part of the application this is — a board, a document. It has to
+   * match the `scope` the collection was created with, or this tab writes into
+   * a scope it is not subscribed to and never sees itself.
+   */
+  scope: string; /** The generated `rig_presence` collection. */
+  stream: PresenceSource; /** Where presencehttp is mounted. `/presence` unless the project moved it. */
+  path?: string; /** This tab's identity. Defaults to {@link SESSION_KEY}. */
+  sessionKey?: string;
+  /**
+   * How often `others()` is recomputed so rows can age out, in milliseconds.
+   *
+   * A second, because absence is the passage of time rather than an event and
+   * no collection has a change to fire for it. This is the whole reason a live
+   * query over the collection is not enough on its own.
+   */
+  tickMs?: number;
+  /**
+   * The shortest gap between two writes, in milliseconds.
+   *
+   * Leading edge immediately and a trailing edge at this, so tabbing through
+   * five controls in a second is two writes rather than five and the person
+   * watching still sees the first one at once. Below about 300ms the write rate
+   * approaches the render rate, and every write is fanned out to every
+   * subscriber in the tenant.
+   */
+  throttleMs?: number;
+};
+/** A running presence loop. */
+type PresenceHandle = {
+  /**
+   * Say what this tab is looking at. Safe to call from a focus handler on every
+   * event: repeated calls with the same target write nothing.
+   */
+  focus(target: PresenceTarget | null, activity?: PresenceActivity): void;
+  /**
+   * Everybody else who is here, freshest first, expired rows already dropped.
+   *
+   * The same array comes back until the answer actually changes, which is the
+   * contract `useSyncExternalStore` and its equivalents require of a snapshot:
+   * they compare by identity, so a fresh array every call is an unbounded
+   * re-render rather than a wasted one.
+   */
+  others(target?: PresenceTarget): Person[];
+  /**
+   * Subscribe to changes in what `others()` answers.
+   *
+   * Fires on a collection change **and** on the tick, which is the contract a
+   * framework binding needs: a person becoming absent has no event.
+   */
+  subscribe(fn: () => void): () => void; /** Leave now rather than waiting out the TTL. */
+  leave(): void; /** Stop the loop and the listeners. */
+  close(): void;
+};
+/**
+ * Starts the presence loop for one tab.
+ *
+ * It owns six things, and each is a bug if the application owns it instead: the
+ * heartbeat schedule, the write throttle, the clock, the tick that makes expiry
+ * happen, the visibility rule, and the leave on teardown.
+ *
+ * **Nothing here is configured with a heartbeat interval.** The server answers
+ * one on every beat and the loop re-beats at half of what is left, so changing
+ * `presence.ttl` is a deploy of the server rather than a release of the front
+ * end — and there is no copy of the number here to disagree with it.
+ */
+declare function createPresence(args: PresenceArgs): PresenceHandle;
+//#endregion
+export { Person as a, PresenceTarget as c, sameTarget as d, createPresence as i, onTarget as l, PresenceHandle as n, PresenceActivity as o, PresenceSource as r, PresenceRow as s, PresenceArgs as t, personOfRow as u };

package/dist/react.d.mts

@@ -0,0 +1,15 @@
+import { a as Person, c as PresenceTarget, n as PresenceHandle } from "./presence-B6KIBpNr.mjs";
+
+//#region src/react.d.ts
+/**
+ * Everybody else who is here, as a React hook.
+ *
+ * Three lines, and a second entry point rather than part of the core, so a
+ * project that does not use React never has `react` reachable from the module it
+ * imports. The core exposes `subscribe` and `others` in exactly the shape
+ * `useSyncExternalStore` wants, which is what keeps the binding this small — and
+ * what makes a binding for another framework the same size.
+ */
+declare function usePresence(handle: PresenceHandle, target?: PresenceTarget): Person[];
+//#endregion
+export { usePresence };

package/dist/react.mjs

@@ -0,0 +1,17 @@
+import { useSyncExternalStore } from "react";
+//#region src/react.ts
+/**
+* Everybody else who is here, as a React hook.
+*
+* Three lines, and a second entry point rather than part of the core, so a
+* project that does not use React never has `react` reachable from the module it
+* imports. The core exposes `subscribe` and `others` in exactly the shape
+* `useSyncExternalStore` wants, which is what keeps the binding this small — and
+* what makes a binding for another framework the same size.
+*/
+function usePresence(handle, target) {
+	return useSyncExternalStore(handle.subscribe, () => handle.others(target), () => EMPTY);
+}
+const EMPTY = [];
+//#endregion
+export { usePresence };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@rig-ts/presence",
+  "version": "0.1.0",
+  "type": "module",
+  "sideEffects": false,
+  "description": "Who is here, and what they are looking at, in a rig application",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./react": {
+      "types": "./dist/react.d.mts",
+      "default": "./dist/react.mjs"
+    }
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "@rig-ts/client": "^0.1.0",
+    "@rig-ts/electric": "^0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "19.2.2",
+    "react": "19.2.0",
+    "tsdown": "0.21.10",
+    "typescript": "5.9.3",
+    "@rig-ts/client": "0.1.0",
+    "@rig-ts/electric": "0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/simonjanss/rig.git",
+    "directory": "ts/packages/presence"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  }
+}