@autono/pinbox-core 0.1.0

package/dist/store-DM8MjB8M.js

@@ -0,0 +1,479 @@
+import { LinkSchema, PinInputSchema, PinSchema, SessionRefSchema, ThreadMessageSchema } from "./schema.js";
+import { a as NotFoundError, i as ConflictError, n as SqliteSessionStore, o as newId } from "./sessions-DrCVTMfI.js";
+import { Database } from "bun:sqlite";
+//#region src/store-deliveries.ts
+var Row = class {
+	id;
+	event_seq;
+	session_id;
+	adapter;
+	status;
+	attempts;
+	due_at;
+	last_error;
+	updated_at;
+};
+var MaxSeqRow = class {
+	last_event_seq;
+};
+function toDeliveryRow(row) {
+	return {
+		id: row.id,
+		eventSeq: row.event_seq,
+		sessionId: row.session_id,
+		adapter: row.adapter,
+		status: row.status,
+		attempts: row.attempts,
+		dueAt: row.due_at,
+		lastError: row.last_error,
+		updatedAt: row.updated_at
+	};
+}
+const COLUMNS = "id, event_seq, session_id, adapter, status, attempts, due_at, last_error, updated_at";
+var SqliteDeliveryStore = class {
+	insert;
+	selectById;
+	selectDue;
+	selectForSession;
+	selectUnassigned;
+	updateAssign;
+	updateDelivered;
+	updateFailed;
+	selectMaxSeq;
+	constructor(db) {
+		this.insert = db.query(`INSERT INTO deliveries (event_seq, session_id, adapter, status, attempts, due_at, last_error, updated_at)
+       VALUES (?, ?, ?, ?, 0, ?, NULL, ?)`);
+		this.selectById = db.query(`SELECT ${COLUMNS} FROM deliveries WHERE id = ?`).as(Row);
+		this.selectDue = db.query(`SELECT ${COLUMNS} FROM deliveries
+         WHERE status = 'pending' AND (due_at IS NULL OR due_at <= ?) ORDER BY id ASC`).as(Row);
+		this.selectForSession = db.query(`SELECT ${COLUMNS} FROM deliveries
+         WHERE status = 'pending' AND session_id = ? ORDER BY id ASC`).as(Row);
+		this.selectUnassigned = db.query(`SELECT ${COLUMNS} FROM deliveries
+         WHERE status = 'pending' AND session_id IS NULL ORDER BY id ASC`).as(Row);
+		this.updateAssign = db.query("UPDATE deliveries SET session_id = ?, updated_at = ? WHERE id = ?");
+		this.updateDelivered = db.query("UPDATE deliveries SET status = 'delivered', updated_at = ? WHERE id = ?");
+		this.updateFailed = db.query(`UPDATE deliveries SET status = ?, attempts = attempts + 1, due_at = ?, last_error = ?, updated_at = ?
+       WHERE id = ?`);
+		this.selectMaxSeq = db.query("SELECT COALESCE(MAX(event_seq), 0) AS last_event_seq FROM deliveries").as(MaxSeqRow);
+	}
+	enqueue(row) {
+		const result = this.insert.run(row.eventSeq, row.sessionId, row.adapter, row.status ?? "pending", row.dueAt, (/* @__PURE__ */ new Date()).toISOString());
+		return this.mustGet(Number(result.lastInsertRowid));
+	}
+	due(now) {
+		return this.selectDue.all(now).map(toDeliveryRow);
+	}
+	pendingForSession(sessionId) {
+		return this.selectForSession.all(sessionId).map(toDeliveryRow);
+	}
+	unassigned() {
+		return this.selectUnassigned.all().map(toDeliveryRow);
+	}
+	assign(id, sessionId) {
+		this.updateAssign.run(sessionId, (/* @__PURE__ */ new Date()).toISOString(), id);
+	}
+	markDelivered(id) {
+		this.updateDelivered.run((/* @__PURE__ */ new Date()).toISOString(), id);
+	}
+	markFailed(id, error, retryAt) {
+		this.updateFailed.run(retryAt === null ? "failed" : "pending", retryAt, error, (/* @__PURE__ */ new Date()).toISOString(), id);
+	}
+	lastEventSeq() {
+		return this.selectMaxSeq.get()?.last_event_seq ?? 0;
+	}
+	mustGet(id) {
+		const row = this.selectById.get(id);
+		if (!row) throw new Error(`delivery row not found after insert: ${id}`);
+		return toDeliveryRow(row);
+	}
+};
+const MIGRATIONS = [
+	{
+		version: 1,
+		ddl: `
+CREATE TABLE IF NOT EXISTS events (
+  seq INTEGER PRIMARY KEY AUTOINCREMENT,
+  type TEXT NOT NULL,
+  at TEXT NOT NULL,
+  payload TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS pins (
+  id TEXT PRIMARY KEY,
+  status TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  due_at TEXT,
+  json TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS thread_messages (
+  id TEXT PRIMARY KEY,
+  pin_id TEXT NOT NULL,
+  at TEXT NOT NULL,
+  json TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS pins_due_at ON pins(due_at) WHERE due_at IS NOT NULL;
+`
+	},
+	{
+		version: 2,
+		ddl: `
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY, agent TEXT NOT NULL, key TEXT NOT NULL, cwd TEXT,
+  registered_at TEXT NOT NULL, last_seen_at TEXT NOT NULL, ended_at TEXT, json TEXT NOT NULL
+);
+CREATE UNIQUE INDEX IF NOT EXISTS sessions_agent_key ON sessions(agent, key);
+CREATE TABLE IF NOT EXISTS deliveries (
+  id INTEGER PRIMARY KEY AUTOINCREMENT, event_seq INTEGER NOT NULL, session_id TEXT,
+  adapter TEXT NOT NULL, status TEXT NOT NULL, attempts INTEGER NOT NULL DEFAULT 0,
+  due_at TEXT, last_error TEXT, updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS deliveries_due ON deliveries(due_at) WHERE status = 'pending';
+`
+	},
+	{
+		version: 3,
+		ddl: `
+CREATE TABLE IF NOT EXISTS cursors (
+  consumer_id TEXT PRIMARY KEY, last_seq INTEGER NOT NULL, updated_at TEXT NOT NULL
+);
+CREATE VIRTUAL TABLE IF NOT EXISTS pins_fts USING fts5(pin_id UNINDEXED, kind UNINDEXED, body, tokenize='unicode61');
+`
+	},
+	{
+		version: 4,
+		ddl: `
+CREATE TABLE IF NOT EXISTS links (
+  pin_id TEXT NOT NULL, connector TEXT NOT NULL, ref TEXT NOT NULL, url TEXT NOT NULL,
+  created_at TEXT NOT NULL, last_synced_at TEXT,
+  PRIMARY KEY (pin_id, connector, ref)
+);
+`
+	}
+];
+var UserVersionRow = class {
+	user_version;
+};
+function migrate(db) {
+	db.transaction(() => {
+		const current = db.query("PRAGMA user_version").as(UserVersionRow).get()?.user_version ?? 0;
+		for (const migration of MIGRATIONS) {
+			if (migration.version <= current) continue;
+			db.exec(migration.ddl);
+			db.exec(`PRAGMA user_version = ${migration.version}`);
+		}
+	}).immediate();
+}
+function backfillFts(db) {
+	const fts = db.query("SELECT COUNT(*) AS n FROM pins_fts").get();
+	const pins = db.query("SELECT COUNT(*) AS n FROM pins").get();
+	if (fts.n > 0 || pins.n === 0) return;
+	db.transaction(() => {
+		db.exec("INSERT INTO pins_fts (pin_id, kind, body) SELECT id, 'pin', json_extract(json, '$.text') FROM pins");
+		db.exec("INSERT INTO pins_fts (pin_id, kind, body) SELECT pin_id, 'msg', json_extract(json, '$.text') FROM thread_messages");
+	})();
+}
+var JsonRow = class {
+	json;
+};
+var EventRow = class {
+	seq;
+	type;
+	at;
+	payload;
+};
+var SummaryRow = class {
+	open;
+	resolved;
+	lastEventSeq;
+};
+var CursorRow = class {
+	last_seq;
+};
+var LinkRow = class {
+	pin_id;
+	connector;
+	ref;
+	url;
+	last_synced_at;
+};
+function rowToLink(row) {
+	return LinkSchema.parse({
+		connector: row.connector,
+		ref: row.ref,
+		url: row.url
+	});
+}
+function parsePin(json) {
+	return PinSchema.parse(JSON.parse(json));
+}
+function openStore(path) {
+	const db = new Database(path);
+	if (path !== ":memory:") db.exec("PRAGMA journal_mode=WAL;");
+	migrate(db);
+	backfillFts(db);
+	return new SqlitePinStore(db);
+}
+var SqlitePinStore = class {
+	db;
+	sessions;
+	deliveries;
+	insertEvent;
+	insertPin;
+	selectPin;
+	selectAllPins;
+	selectPinsByStatus;
+	updatePin;
+	updateDueAt;
+	selectDuePins;
+	insertMessage;
+	selectThread;
+	selectEventsAfter;
+	selectSummary;
+	insertFts;
+	selectSearch;
+	insertLink;
+	selectLinksForPin;
+	selectAllLinks;
+	updateLinkSynced;
+	cursors;
+	links;
+	listeners = /* @__PURE__ */ new Set();
+	pendingEvents = [];
+	constructor(db) {
+		this.db = db;
+		this.sessions = new SqliteSessionStore(db);
+		this.deliveries = new SqliteDeliveryStore(db);
+		this.insertEvent = db.query("INSERT INTO events (type, at, payload) VALUES (?, ?, ?)");
+		this.insertPin = db.query("INSERT INTO pins (id, status, created_at, json) VALUES (?, ?, ?, ?)");
+		this.selectPin = db.query("SELECT json FROM pins WHERE id = ?").as(JsonRow);
+		this.selectAllPins = db.query("SELECT json FROM pins ORDER BY created_at DESC, rowid DESC").as(JsonRow);
+		this.selectPinsByStatus = db.query("SELECT json FROM pins WHERE status = ? ORDER BY created_at DESC, rowid DESC").as(JsonRow);
+		this.updatePin = db.query("UPDATE pins SET status = ?, json = ? WHERE id = ?");
+		this.updateDueAt = db.query("UPDATE pins SET due_at = ? WHERE id = ?");
+		this.selectDuePins = db.query("SELECT json FROM pins WHERE due_at IS NOT NULL AND due_at <= ? ORDER BY due_at ASC").as(JsonRow);
+		this.insertMessage = db.query("INSERT INTO thread_messages (id, pin_id, at, json) VALUES (?, ?, ?, ?)");
+		this.selectThread = db.query("SELECT json FROM thread_messages WHERE pin_id = ? ORDER BY rowid ASC").as(JsonRow);
+		this.selectEventsAfter = db.query("SELECT seq, type, at, payload FROM events WHERE seq > ? ORDER BY seq ASC").as(EventRow);
+		this.selectSummary = db.query(`SELECT
+           (SELECT COUNT(*) FROM pins WHERE status = 'open') AS open,
+           (SELECT COUNT(*) FROM pins WHERE status = 'resolved') AS resolved,
+           (SELECT COALESCE(MAX(seq), 0) FROM events) AS lastEventSeq`).as(SummaryRow);
+		this.insertFts = db.query("INSERT INTO pins_fts (pin_id, kind, body) VALUES (?, ?, ?)");
+		this.selectSearch = db.query(`SELECT json FROM pins
+         WHERE id IN (SELECT DISTINCT pin_id FROM pins_fts WHERE pins_fts MATCH ?)
+         ORDER BY created_at DESC, rowid DESC`).as(JsonRow);
+		const selectCursor = db.query("SELECT last_seq FROM cursors WHERE consumer_id = ?").as(CursorRow);
+		const upsertCursor = db.query(`INSERT INTO cursors (consumer_id, last_seq, updated_at) VALUES (?, ?, ?)
+       ON CONFLICT(consumer_id) DO UPDATE SET last_seq = excluded.last_seq, updated_at = excluded.updated_at`);
+		this.cursors = {
+			get: (consumerId) => selectCursor.get(consumerId)?.last_seq ?? 0,
+			set: (consumerId, lastSeq) => {
+				upsertCursor.run(consumerId, lastSeq, (/* @__PURE__ */ new Date()).toISOString());
+			}
+		};
+		this.insertLink = db.query("INSERT INTO links (pin_id, connector, ref, url, created_at) VALUES (?, ?, ?, ?, ?)");
+		this.selectLinksForPin = db.query("SELECT pin_id, connector, ref, url, last_synced_at FROM links WHERE pin_id = ? ORDER BY rowid ASC").as(LinkRow);
+		this.selectAllLinks = db.query("SELECT pin_id, connector, ref, url, last_synced_at FROM links ORDER BY rowid ASC").as(LinkRow);
+		this.updateLinkSynced = db.query("UPDATE links SET last_synced_at = ? WHERE pin_id = ? AND connector = ? AND ref = ?");
+		this.links = {
+			forPin: (pinId) => this.selectLinksForPin.all(pinId).map(rowToLink),
+			all: () => this.selectAllLinks.all().map((row) => ({
+				pinId: row.pin_id,
+				link: rowToLink(row),
+				lastSyncedAt: row.last_synced_at
+			})),
+			markSynced: (pinId, link, at) => {
+				this.updateLinkSynced.run(at, pinId, link.connector, link.ref);
+			}
+		};
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	createPin(input, env) {
+		const parsed = PinInputSchema.parse(input);
+		const mergedEnv = { ...parsed.env };
+		if (env.branch !== void 0) mergedEnv.branch = env.branch;
+		if (env.commit !== void 0) mergedEnv.commit = env.commit;
+		const pin = PinSchema.parse({
+			...parsed,
+			env: mergedEnv,
+			id: newId("pin"),
+			schemaVersion: 1,
+			status: "open",
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		this.mutate(() => {
+			this.insertPin.run(pin.id, pin.status, pin.createdAt, JSON.stringify(pin));
+			this.insertFts.run(pin.id, "pin", pin.text);
+			this.logEvent("pin.created", pin.createdAt, pin);
+		});
+		return pin;
+	}
+	getPin(id) {
+		const row = this.selectPin.get(id);
+		return row ? parsePin(row.json) : null;
+	}
+	listPins(filter) {
+		return (filter?.status ? this.selectPinsByStatus.all(filter.status) : this.selectAllPins.all()).map((r) => parsePin(r.json));
+	}
+	addThreadMessage(pinId, role, text, opts) {
+		const message = ThreadMessageSchema.parse({
+			id: newId("msg"),
+			pinId,
+			role,
+			...opts?.origin !== void 0 ? { origin: opts.origin } : {},
+			text,
+			...opts?.attachments !== void 0 ? { attachments: opts.attachments } : {},
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		this.mutate(() => {
+			this.mustGetPin(pinId);
+			this.insertMessage.run(message.id, message.pinId, message.at, JSON.stringify(message));
+			this.insertFts.run(message.pinId, "msg", message.text);
+			this.logEvent("thread.message", message.at, message);
+		});
+		return message;
+	}
+	getThread(pinId) {
+		return this.selectThread.all(pinId).map((r) => ThreadMessageSchema.parse(JSON.parse(r.json)));
+	}
+	resolvePin(id, by, note, commit) {
+		let resolved;
+		this.mutate(() => {
+			const pin = this.mustGetPin(id);
+			if (pin.status === "resolved") throw new ConflictError(`pin already resolved: ${id}`);
+			const at = (/* @__PURE__ */ new Date()).toISOString();
+			resolved = PinSchema.parse({
+				...pin,
+				status: "resolved",
+				resolution: {
+					by,
+					...note !== void 0 ? { note } : {},
+					...commit !== void 0 ? { commit } : {},
+					at
+				}
+			});
+			this.updatePin.run(resolved.status, JSON.stringify(resolved), id);
+			this.logEvent("pin.resolved", at, resolved);
+		});
+		return resolved;
+	}
+	bindSession(pinId, ref) {
+		const parsedRef = SessionRefSchema.parse(ref);
+		let bound;
+		this.mutate(() => {
+			const pin = this.mustGetPin(pinId);
+			bound = PinSchema.parse({
+				...pin,
+				agentSession: parsedRef
+			});
+			this.updatePin.run(bound.status, JSON.stringify(bound), pinId);
+		});
+		return bound;
+	}
+	verifyPin(id, outcome) {
+		let verified;
+		this.mutate(() => {
+			const pin = this.mustGetPin(id);
+			if (pin.status !== "resolved") throw new ConflictError(`pin not resolved: ${id}`);
+			const at = (/* @__PURE__ */ new Date()).toISOString();
+			verified = PinSchema.parse({
+				...pin,
+				status: outcome === "reopened" ? "open" : "resolved",
+				verification: {
+					outcome,
+					at
+				}
+			});
+			this.updatePin.run(verified.status, JSON.stringify(verified), id);
+			this.logEvent("pin.verified", at, verified);
+		});
+		return verified;
+	}
+	searchPins(query) {
+		const phrase = `"${query.replaceAll("\"", "\"\"")}"`;
+		return this.selectSearch.all(phrase).map((r) => parsePin(r.json));
+	}
+	addLink(pinId, link) {
+		const parsed = LinkSchema.parse(link);
+		let updated;
+		this.mutate(() => {
+			const pin = this.mustGetPin(pinId);
+			const existing = pin.links ?? [];
+			if (existing.some((l) => l.connector === parsed.connector && l.ref === parsed.ref)) throw new ConflictError(`pin already linked: ${pinId} → ${parsed.connector}#${parsed.ref}`);
+			const at = (/* @__PURE__ */ new Date()).toISOString();
+			updated = PinSchema.parse({
+				...pin,
+				links: [...existing, parsed]
+			});
+			this.insertLink.run(pinId, parsed.connector, parsed.ref, parsed.url, at);
+			this.updatePin.run(updated.status, JSON.stringify(updated), pinId);
+			this.logEvent("pin.linked", at, updated);
+		});
+		return updated;
+	}
+	setDueAt(id, at) {
+		if (this.updateDueAt.run(at, id).changes === 0) throw new NotFoundError(`pin not found: ${id}`);
+	}
+	pinsDueBefore(at) {
+		return this.selectDuePins.all(at).map((r) => parsePin(r.json));
+	}
+	eventsAfter(seq) {
+		return this.selectEventsAfter.all(seq).map((row) => ({
+			seq: row.seq,
+			type: row.type,
+			at: row.at,
+			payload: JSON.parse(row.payload)
+		}));
+	}
+	summary() {
+		const row = this.selectSummary.get();
+		return {
+			open: row?.open ?? 0,
+			resolved: row?.resolved ?? 0,
+			lastEventSeq: row?.lastEventSeq ?? 0
+		};
+	}
+	close() {
+		this.db.close();
+	}
+	/**
+	* Runs a mutation inside one immediate transaction (two-writer SQLITE_BUSY case:
+	* daemon + stray CLI call, deep-dive §1.11), then flushes events collected by
+	* logEvent to subscribers — post-commit, in seq order, on the mutating call's stack.
+	*/
+	mutate(mutation) {
+		let result;
+		try {
+			result = this.db.transaction(mutation).immediate();
+		} catch (cause) {
+			this.pendingEvents = [];
+			throw cause;
+		}
+		const events = this.pendingEvents;
+		this.pendingEvents = [];
+		for (const event of events) for (const listener of this.listeners) try {
+			listener(event);
+		} catch {}
+		return result;
+	}
+	logEvent(type, at, payload) {
+		const result = this.insertEvent.run(type, at, JSON.stringify(payload));
+		this.pendingEvents.push({
+			seq: Number(result.lastInsertRowid),
+			type,
+			at,
+			payload
+		});
+	}
+	mustGetPin(id) {
+		const pin = this.getPin(id);
+		if (!pin) throw new NotFoundError(`pin not found: ${id}`);
+		return pin;
+	}
+};
+//#endregion
+export { openStore as n, MIGRATIONS as t };

package/dist/store.d.ts

@@ -0,0 +1,2 @@
+import { a as LinkStore, c as PinStore, d as ConflictError, f as NotFoundError, i as DeliveryStore, l as StoredEvent, n as DeliveryRow, o as MIGRATIONS, r as DeliveryStatus, s as Migration, t as CursorStore, u as openStore } from "./store-DHbwWu93.js";
+export { ConflictError, CursorStore, DeliveryRow, DeliveryStatus, DeliveryStore, LinkStore, MIGRATIONS, Migration, NotFoundError, PinStore, StoredEvent, openStore };

package/dist/store.js

@@ -0,0 +1,3 @@
+import { a as NotFoundError, i as ConflictError } from "./sessions-DrCVTMfI.js";
+import { n as openStore, t as MIGRATIONS } from "./store-DM8MjB8M.js";
+export { ConflictError, MIGRATIONS, NotFoundError, openStore };

package/dist/types-BLNQb7MH.d.ts

@@ -0,0 +1,28 @@
+import { a as Pin, m as ThreadMessage, r as Link } from "./schema-BOTmn5SM.js";
+//#region src/connectors/types.d.ts
+/** Host-injected transport: local = `gh` CLI shell-out (impl in packages/cli, Bun.$); Worker = App token fetch. */
+interface ConnectorTransport {
+  request(op: string, params: Record<string, unknown>): Promise<unknown>;
+}
+type RemoteComment = {
+  origin: string;
+  text: string;
+  at: string;
+};
+type RemoteStatus = "open" | "closed";
+/** Hub-supplied sinks — the connector reports inbound activity, core writes it. */
+type ConnectorEvents = {
+  onRemoteComment(link: Link, comment: RemoteComment): Promise<void>;
+  onRemoteStatus(link: Link, status: RemoteStatus): Promise<void>;
+};
+interface Connector {
+  readonly name: string;
+  createItem(pin: Pin, thread: ThreadMessage[]): Promise<Link>;
+  postComment(link: Link, message: ThreadMessage): Promise<void>;
+  /** Inbound: poll (local, scheduled via pins.due_at + drainDue) or webhook-parse (Worker route); reports through the sinks; caller marks links.markSynced. */
+  sync(link: Link, events: ConnectorEvents): Promise<void>;
+  /** The outbound half of the status rule; the Slack connector implements it too. */
+  setRemoteStatus(link: Link, status: RemoteStatus): Promise<void>;
+}
+//#endregion
+export { RemoteStatus as a, RemoteComment as i, ConnectorEvents as n, ConnectorTransport as r, Connector as t };

package/dist/verify-BDt9d9Np.js

@@ -0,0 +1,55 @@
+import { createRemoteJWKSet, jwtVerify } from "jose";
+//#region src/auth/jwt.ts
+function verifyJwt(opts) {
+	const jwks = createRemoteJWKSet(new URL(opts.jwksUrl));
+	return async (req) => {
+		const token = bearerToken(req);
+		if (token === null) return null;
+		try {
+			const { payload } = await jwtVerify(token, jwks, {
+				issuer: opts.issuer,
+				audience: opts.audience,
+				algorithms: ["EdDSA", "RS256"]
+			});
+			if (typeof payload["sub"] !== "string") return null;
+			const identity = { userId: payload["sub"] };
+			if (typeof payload["tenant"] === "string") identity.tenantId = payload["tenant"];
+			if (typeof payload["name"] === "string") identity.name = payload["name"];
+			if (typeof payload["email"] === "string") identity.email = payload["email"];
+			return identity;
+		} catch {
+			return null;
+		}
+	};
+}
+function bearerToken(req) {
+	const header = req.headers.get("authorization");
+	if (header === null || !header.startsWith("Bearer ")) return null;
+	return header.slice(7);
+}
+//#endregion
+//#region src/auth/verify.ts
+function verifyNone() {
+	return async () => ({ userId: "anonymous" });
+}
+function verifyToken(expected) {
+	return async (req) => {
+		const token = bearerToken(req);
+		if (token === null) return null;
+		return await digestsEqual(token, expected) ? { userId: "token" } : null;
+	};
+}
+function verifyCustom(fn) {
+	return fn;
+}
+async function digestsEqual(a, b) {
+	const encoder = new TextEncoder();
+	const [da, db] = await Promise.all([crypto.subtle.digest("SHA-256", encoder.encode(a)), crypto.subtle.digest("SHA-256", encoder.encode(b))]);
+	const ua = new Uint8Array(da);
+	const ub = new Uint8Array(db);
+	let diff = 0;
+	for (let i = 0; i < ua.length; i++) diff |= (ua[i] ?? 0) ^ (ub[i] ?? 0);
+	return diff === 0;
+}
+//#endregion
+export { verifyJwt as i, verifyNone as n, verifyToken as r, verifyCustom as t };

package/dist/ws-protocol.d.ts

@@ -0,0 +1,61 @@
+import { l as StoredEvent } from "./store-DHbwWu93.js";
+import { z } from "zod";
+//#region src/ws-protocol.d.ts
+declare const WS_PATH = "/ws";
+declare const WS_PROTOCOL_VERSION = 1;
+declare const WS_MIN_PROTOCOL = 1;
+declare const WS_TOKEN_SUBPROTOCOL_PREFIX = "pinbox.token.";
+declare const WS_CLOSE_PROTOCOL = 4400;
+declare const WS_CLOSE_UNAUTHORIZED = 4401;
+declare const ClientHelloSchema: z.ZodObject<{
+  type: z.ZodLiteral<"hello">;
+  protocol: z.ZodNumber;
+  consumerId: z.ZodString;
+  lastSeq: z.ZodNumber;
+}, z.core.$strip>;
+declare const WsEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"event">;
+  seq: z.ZodNumber;
+  eventType: z.ZodEnum<{
+    "pin.created": "pin.created";
+    "pin.linked": "pin.linked";
+    "pin.resolved": "pin.resolved";
+    "pin.verified": "pin.verified";
+    "thread.message": "thread.message";
+  }>;
+  at: z.ZodString;
+  payload: z.ZodUnknown;
+}, z.core.$strip>;
+declare const ServerCatchUpSchema: z.ZodObject<{
+  type: z.ZodLiteral<"catch-up">;
+  protocol: z.ZodLiteral<1>;
+  minProtocol: z.ZodLiteral<1>;
+  lastSeq: z.ZodNumber;
+  events: z.ZodArray<z.ZodObject<{
+    type: z.ZodLiteral<"event">;
+    seq: z.ZodNumber;
+    eventType: z.ZodEnum<{
+      "pin.created": "pin.created";
+      "pin.linked": "pin.linked";
+      "pin.resolved": "pin.resolved";
+      "pin.verified": "pin.verified";
+      "thread.message": "thread.message";
+    }>;
+    at: z.ZodString;
+    payload: z.ZodUnknown;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const ServerErrorSchema: z.ZodObject<{
+  type: z.ZodLiteral<"error">;
+  code: z.ZodEnum<{
+    E_INVALID_INPUT: "E_INVALID_INPUT";
+    E_WS_PROTOCOL: "E_WS_PROTOCOL";
+  }>;
+  message: z.ZodString;
+}, z.core.$strip>;
+type WsClientMessage = z.infer<typeof ClientHelloSchema>;
+type WsServerMessage = z.infer<typeof ServerCatchUpSchema | typeof WsEventSchema | typeof ServerErrorSchema>;
+/** One WsEvent frame, JSON. */
+declare function encodeWsEvent(event: StoredEvent): string;
+//#endregion
+export { ClientHelloSchema, ServerCatchUpSchema, ServerErrorSchema, WS_CLOSE_PROTOCOL, WS_CLOSE_UNAUTHORIZED, WS_MIN_PROTOCOL, WS_PATH, WS_PROTOCOL_VERSION, WS_TOKEN_SUBPROTOCOL_PREFIX, WsClientMessage, WsEventSchema, WsServerMessage, encodeWsEvent };

package/dist/ws-protocol.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+//#region src/ws-protocol.ts
+const WS_PATH = "/ws";
+const WS_PROTOCOL_VERSION = 1;
+const WS_MIN_PROTOCOL = 1;
+const WS_TOKEN_SUBPROTOCOL_PREFIX = "pinbox.token.";
+const WS_CLOSE_PROTOCOL = 4400;
+const WS_CLOSE_UNAUTHORIZED = 4401;
+const ClientHelloSchema = z.object({
+	type: z.literal("hello"),
+	protocol: z.number().int().positive(),
+	consumerId: z.string().min(1),
+	lastSeq: z.number().int().nonnegative()
+});
+const WsEventSchema = z.object({
+	type: z.literal("event"),
+	seq: z.number().int().positive(),
+	eventType: z.enum([
+		"pin.created",
+		"pin.resolved",
+		"thread.message",
+		"pin.verified",
+		"pin.linked"
+	]),
+	at: z.string(),
+	payload: z.unknown()
+});
+const ServerCatchUpSchema = z.object({
+	type: z.literal("catch-up"),
+	protocol: z.literal(1),
+	minProtocol: z.literal(1),
+	lastSeq: z.number().int().nonnegative(),
+	events: z.array(WsEventSchema)
+});
+const ServerErrorSchema = z.object({
+	type: z.literal("error"),
+	code: z.enum(["E_WS_PROTOCOL", "E_INVALID_INPUT"]),
+	message: z.string()
+});
+/** One WsEvent frame, JSON. */
+function encodeWsEvent(event) {
+	return JSON.stringify({
+		type: "event",
+		seq: event.seq,
+		eventType: event.type,
+		at: event.at,
+		payload: event.payload
+	});
+}
+//#endregion
+export { ClientHelloSchema, ServerCatchUpSchema, ServerErrorSchema, WS_CLOSE_PROTOCOL, WS_CLOSE_UNAUTHORIZED, WS_MIN_PROTOCOL, WS_PATH, WS_PROTOCOL_VERSION, WS_TOKEN_SUBPROTOCOL_PREFIX, WsEventSchema, encodeWsEvent };

package/dist/ws.d.ts

@@ -0,0 +1,7 @@
+//#region src/ws.d.ts
+interface Broadcaster {
+  publish(topic: string, data: string): void;
+  subscriberCount(topic: string): number;
+}
+//#endregion
+export { Broadcaster };

package/dist/ws.js

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